<inserted> (Regarding the expected "Testing" session tomorrow, Kaz mentions that he'll provide information on the basic framework (what to do for CR/PR transition). also he has invited Mike Smith from W3C Team who works on the W3C Testing Platform. McCool will update the agenda for tomorrow)
<inserted> scribenick: mjkoster
Sebastian: the motivation is that
there are more developer errors using writeable
... read-only is a more familiar concept
issue #209
https://github.com/w3c/wot-thing-description/issues/209
Matthias: has observed the “writEable” problem and it seems to be a common pitfall
Lagally: makes sense
Matthias: the default makes sense
Zoltan: what is the motivation for default?
Matthias: we want the defaults of boolean to be "false"
Ege: this is camel case?
Matthias: discussion on this later
RESOLUTION: we'll change "writeable" to "readonly"; case notation still to be discussed
Sebastian: version is provided as
a version number for the instance version
... it can be useful to add more metadata for creation and
modification date
... the proposal is to provide created and lastModified using
ISO 8601 compatible format
... where should we put it?
... does it go into the versioning container?
Lagally: other date-time representations should also use ISO 8601
Matthias: there could be many
versions besides the TD instance
... is created/lastModified metadata version information
Mccool: ... the dates could be
used independently from version
... created/lastModified can be included at the top level as
timestamps
Matthias: preference also for timestamps at the top level
Mccool: any other opinions?
Matthias: we seem to be in consensus
Mccool: what about using "modified" instead of lastModified?
Matthias: we should look at other specifications to see what the common usage is
Lagally: oracle uses "created" and "lastModified"
RESOLUTION: we'll add "create" "lastModified"
Lagally: and include the timestamps at the top level of the TD
Matthias: proposal to add a serial number
https://github.com/w3c/wot-thing-description/issues/142
Matthias: a serial number is not
a uri
... this is a simple string
Mccool: there is also model number and other identifiers
Koster: other SDOs create a separate model for this, should it be top level statement?
Mccool: it makes sense at the top
level because TD is an instance
... we need to combine model and serial for it to be correctly
interpreted
<taki> +q
Matthias: not ready to resolve but we have good consensus
Lagally: we prepose three additional fields to include HW and SW versions
Matthias: the version container
has three level version numbers and allows for semantic
versioning to express things like HW version, SW version
... we can't limit the version categories to just three, so are
using a more extensible scheme in the version container
... the "id" fiend in TD is the persistent identifier and
remains the same when version changes
... there is an IETF document that defines URNs for device identifiers that can be used in "id"
... this is not for secure ID per se, but it could be
cryptographically verified
<mkovatsc> https://tools.ietf.org/html/draft-ietf-core-dev-urn-03
Matthias: we don't provide the means to cryptographically verify IDs
Lagally: note that the dev:urn format is only an example of a unique ID and not a required format
Sebastian: would be very useful
as a core term in the TD
... which vocabulary should we use?
<victor> note on "serial": schema.org has a range of properties to use to provide product IDs. See https://schema.org/Product
<victor> for instance gtin13, productID
Matthias: it has been included in an ad-hoc way to date but it's not official
Mccool: which system would we use and would other be allowed, and how?
Darko: we have a unit code
term in schema.org that aligns with QUDT and others
... you need to have the context included
Matthias: what predicate should
we use?
... there are problems with QUDT and UCUM
Darko: schema.org has it's own that is not tied to the other systems
Mccool: we could define unit as a predicate that is defined in our vocabulary and allow it to be over-ridden with prefixes
Matthias: there is a cdt (common data type) ontology being proposed that enables most of these use cases
<mkovatsc> https://ci.mines-stetienne.fr/lindt/v2/custom_datatypes.html#ucumunit
Taki: suggest looking at existing
ontologies e.g. GS1
... also edifact
Lagally: looked at UCUM
... it's a big bag of all possible things you might
measure
... furlongs, etc.
... it looks like UCUM is not constrained enough, should we add
our own constraints
Matthias: adding constraints may be problematic because the lack of coverage on existing systems
Mccool: different countries have different schemes, the defined term "unit" is good
Darko: it's too early to require
any one scheme
... the prefix doesn't work with the JSON serialization
... it would be good to have a default vocabulary that doesn't
need a prefix
Lagally: we could define the
term "unit" and with a default
... we should allow for constrained devices to be able to
interpret units
Victor: it's hard to mix literals
with URIs
... the prefix would be ignored
... constrained devices may not have web access
Matthias: ucum is adopted by IETF CoRE in many ways, built into LWM2M
Mccool: propose that we provide
"unit" and default to UCUM
... the value of "unit" should conform to UCUM
<kaz> Sebastian: there are many more topics today, so let's talk about this later
<kaz> Kaz: maybe a good topic for the joint session with WISHI later
Sebastian: we can continue the discussion in the TD section
Matthias: look at the cdt+ucum as it's being adopted in a lot of places
Matthias: the proposal is to add
"safe" and "idempotent" terms
... boolean default false
issue 130
https://github.com/w3c/wot-thing-description/issues/130
Mccool: what about other terms? "pure"?
Matthias: "pure" has another meaning, "safe" is a well known term
Mccool: safe should also produce no actuation
Victor: should this be at the protocol level, in the form?
Matthias: it should not be dependent on the protocol used
Mccool: these terms are appropriate, well defined, and useful
<inserted> Matthias: no resolution at the moment
<inserted> Sebastian: discussion during the TD calls
Matthias: actions may use
different media types for input and output
... for example, a camera action mat return an image
... we need to think more about the possible responses that
might come back
proposal: add "responses" field to the form
Kaz: can there be multi-part or compound return types?
<kaz> Kaz: possibly time synchronized/shifted with each other. maybe this idea might be too advanced for the current TD, though
Matthias: we could use the multipart media type
Koster: does "responses" allow status codes?
Matthias: we want to be more hypermedia-aware than having to declare response codes
Koster: what about returning location in the responses
Matthias: yes, that is something we have thought about for this
Mccool: this provides future
extension points by using an array
... there could be new fields added
RESOLUTION: we'll add "responses" (as an array of media types) to handle multiple media types
Matthias: mediaType can only have
a value of a simple media type and doesn't allow for
parameterized media types
... for example, encodings and compound types
... content type allows additional parameters to be used
... proposal is to rename "mediaType" to "contenttype" and
allow parameters
... this aligns with IETF "ct" identifier
Mccool: is the simple media type still allowed?
Matthias: yes
Mccool: +1
... also supports COSE
kawaguch: no objection but does it impact for example the use of utf-8 with JSON?
Matthias: this doesn't change the defaults
Matthias: a lot of constraints in
identifiers require conversion to lower case, for example
encodings for web linking
... some conventions use camelCase
... some conventions are InitialCaps
Victor: sometimes class id InitialCaps and instance is camelCase
<kaz> (break till 11am)
<kaz> scribenick: kaz
Matthias: let's resume
... last block for TD
... related to Scripting API as well
... btw, discussion about letter casing?
Daniel: we do allow various
combinations
... historical reasons
Matthias: case in-sensitive,
etc.?
... consistency with the TD core vocab
... usual convention here
... we're defining web linking
... core link format for JSON
... might need lower case terms
... may convert back to camel case again
... the opinion so far is using camel casing
... but not conclusion yet
... show hands?
McCool: consistent for camel casing?
Matthias: initial lower case?
McCool: anybody agains?
(nobody objects)
Koster: no conflict with JSON or JSON-LD
Matthias: we have other cases for other
mechanisms
... we definitely to be consistent
... so far nobody against with using camel case for TD
Sebastian: except web linking?
Matthias: predicate terms in TD
... camel cases
<McCool> mm: proposal is that camel case would be for predicate terms, literals would be as in registries, etc.
Matthias: we set web linking out
... need to see in detail
Zoltan: camel case is ok
... but need to see webidl
Matthias: other different systems
outside TD
... JSON schema vocab, etc.
issue 44
Matthias: uri with curly brackets
here
... often used in web apis
... in our plugfest, didn't take into account
... but we need to revisit this topic
... sometimes required, e.g., for OMA LWM2M
... coding URI query parameters
... some kowledge on the client
McCool: two more examples
... NYC and OGC smart things
... definitely need it
Matthias: OpenAPI and HAL support
that
... proposal
... something similar to uri template here
... understandable what this would mean
... data schema would provide information too
... full spectrum
... payload by the client
... I provide another proposal
... input field of action
... term templated to indicate input data goes into URI
template
... question
... api example uses both uri template and payload data?
... different levels there
... fixed parameter for URI and can be used for payload
... go back to the original proposal
... and visit alternative again
... wondering if it's good
Koster: 2 items
... input points to item and schema
... could be validated by schema
... our use cases include both template and payload
Matthias: by definition we use object
data schema
... subset of data schema allows
... object data schema, array, integer, ...
... template would be object data schema
Koster: understand it
... data schema, object schema, etc.
Daniel: if we introduce yet antoher
level
... kind of fulfill?
Koster: better than 2 terms
Daniel: make sense to have two
(discussions on the proposal)
Matthias: would construct specific data
schema
... uri input
... payload input
... multiplex basically
... identify some semantic terms
... sub part of data schema to be considered
McCool: uri template as name
... different name spaces
... can see json template and payload
... assuming including other places
... will be willing to limit it for actions and events
Matthias: url template at the same time for property?
McCool: fallback is using action
Lagally: looking at the example
... missing regular input
... this uri template only referes to HTTP
... we should come up with concrete/complete example
Koster: we need to provide a
schema
... type and value constraint
... providing schema to fill into the template
Lagally: somewhere on the layer?
Koster: still under the action
... those values are parameters of actions
Lagally: we should define the data
schema
... values of data schema to be defined as well
McCool: we should see CoAP, etc., as
well
... header options
... extra parameters for uri template
Matthias: uri template is for URI
... not protocols
... fill in topic part
... imagine the server fills in the detail
... property to be written up
... possibly have 2 forms
... with same input
Lagally: we should think about concrete example for the detailed discussion
Koster: we should look up an example
Sebastian: maybe to move to the uri template for form container?
Matthias: constraint here
... defined dictionary for TD level
... possibly 2 different levels, one for uri and another for
payload
... input definition
... forms knows how to construct message
... and the 3rd proposal would be only having input here (under
moveleft)
... what is tricky is we have some container structure
Victor: additional properties
... as part of the schema?
Matthias: you can't decide
Victor: still have type, name,
...
... would see this information in te schema
... input schema
Matthias: user concept defines new
parameter
... on application matter, wouldn't matter
Victor: that's why I want to have it on the schema side
Matthias: we have to generate concrete example for further discussion
McCool: looked at CoAP
... supports uri template
... it's in the protocol
Koster: you're not sure how to
generate the schema
... hard to know how to handle payload
Lagally: we should have an example on property
Matthias: generating "4th
proposal"
... decouple and only have input
... that's it for TD discussion
<zolkis> https://docs.google.com/presentation/d/1QlfbHzRKhdA3h0nsicDLj_QADV3urhGyqW9qB3zQ0zs/edit?usp=sharing
Zoltan: programming idioms
... how to handle events
... discuss other topics on WebIDL vs TypeScript
... challenges for scripting
... overloaded temrs
... object vs Thing
... WoT events vs programmatic events
... wot properties vs object properties
... wot actions vs object methods
... type definitions and mappings
... trends in the web platform
... do we use DOM or Node?
... our implementations are Node
... Sangwhan from TAG promised on that
... we don't use event currently
... how to do asynchronous programming?
... semantic meanings
... got feedback from TAG memtbers
... separate discussion on WebIDL break
... have slides about that
... respec makes braking changes
... multiple webidl versions
... "wild" ideas
... including Dave's simplified API proposal
... constructing DOM to represent WoT Things
... something new
... trying to create an issue
... Dave will have a slot?
... about the first point
... WebIDL or TypeScript or ...?
... discussions back and force
... some people suggest webidl
... some for typescript
... TC39 i moving to use WebIDL for ECMAScript
... WEbIDL is coercive and is used by all WEb specs
... typescript is informative
... should not use WebIDL for data structure
... need to see what the other specs use
... should use the infra standard to refer to @a
Daniel: given WebIDL causes many
issues
... using TypeScript would make sense
... going back to WebIDL based on the TAG's comment is a
possible option
... but would cost issues again
... don't know how others do
Zoltan: could handle typescript to appendix and say "typescript is an example"
Matthias: typescript is helpful for
appendix
... one way to do it
Zoltan: the next step is getting
prepared for TAG review
... programming object vs Thing
... description on object and Thing
... Traditional IoT interactions
... <- request
... server-sent notification subscribed
... what we need to map
... to move on the topic MK asked
... web-nfc/issues/152#issuecomment-425179760
... you get promise
... written data or errors
... Traditional async programing with Events
... should use events
... traditional way is not really good enough
... DOM Events
... different context for EventTarget
... event listeners can dispatch events
... Node.js events
... difference how we add signature, etc., to event
listener
... promise
... model for one-shot async operation
... no easy way to cancel the event
... cancellable promises have been discussed
Matthias: ongoing discussion about overall event listner?
Zoltan: yes
... Observables
... event hander can get any value (not restricted to
event)
... AbortController/AbortSignal
... becoming similar
... pass the signal to dictionary
... have to implement some algorithm
... AbortController/AbortSignal (rationale)
... how to use it in the spec?
... function retures a promis and takes a dictionary
parameter
... we have subscriber mechanism already
... takes notification handler
... takes optional subscriber
... named filter
... notification handler can take any values
... included onerror callback
... not DOM event
... we can take cancel into account
Koster: haven't seen particular examples
Matthias: possible use case on delete
Koster: may or may not schema
Matthias: how does the message look
like
... to create a webhook
... for cancellation, you usually need
... body in the response
... where the resource is
Zoltan: why we need
cancellation
... description here
... updated ConsumedThing
... different structure
... discussion
... last slide here
... do we expose programmable events?
... should follow DOM events
... one way to go
Matthias: what's the future one?
Zoltan: use the
AbortController-compatible subscriber proposal?
... you can have options for subscribe/unsubscribe
Matthias: definitely important on the TD level
Zoltan: this is for discussion
... any comments?
Lionel: question about abort signal
Zoltan: they call it signal but not
event
... some associated task
Matthias: this is from web platform
Zoltan: right
... there is no Thing event or Thing signal
... you could handle multiple signals
... maybe overkill for us
Lagally: interrupting a thread was a nontrivial problem in the Java language, which was addressed 20 years ago
... interrupting a promise or using an abort action for unsubscribing does not feel natural
Zoltan: JavaScript also has the capability
McCool: what if we use subscriber
again?
... dependency wiht current subscriber
Lin: observe action?
... do you have observe action?
Zoltan: we can subscribe to thing
change
... event
Matthias: here we're talking about
programming language level problem
... 2 different levels there
Lin: if you have action
there
... relationship between action and event?
Zoltan: not proposing we get
resolution now
... people can give comments
... and we can make decision during the scripting calls
Matthias: DOM model to do or node model
to do?
... we're at somewhere in the middle
... motivated this additional subscriber concept
Matthias: which event model to be used is confusing
Zoltan: if there is problem, let's create an issue and continue the discussion
<McCool> to clarify my earlier question: I asked if the Subscriber had a dependency on AbortSignal. It does. My concern was if it would break if AbortSignal turns out not to be "the future". It does, but my impression was changing it would be relatively minor.
<McCool> also, to clarify my comment: I was just asking if it was a convenience layer on top, and my comment about "not mappable" was about "not easily mappable to other languages that are not Javascript"
Kaz: wondering if PlugFest participants have any idea/feedback on discovery and directory
Matthias: would suggest we skip this given we have many remaining topics
Dave: explains his ideas
Dave: produce and consume resolve
with Thing that looks like a regular JS object
... special reserved name?
... or wot.model
Jose: web push api to be considered?
Dave: not visible to developers
McCool: comment on this
proposal
... looks clean but not easily mappable
... convenient layer on the top?
... need minimal functionality
Dave: programming adaptation
layer
... API exposed to the developers would be cleaner
Matthias: how to deal with
rollbacks?
... recover from errors
Dave: several clients for a
server
... has to have some mechanism
Matthias: where is the mechanism?
... this part is clean
... but what about the underlying mechanism?
... what about lost message?
Dave: system metadata
Matthias: where is the underlying
mechanism?
... this is ignoring the basis
Matthias: not modeled?
... maybe you're criticizing promise mechanism
Zoltan: we could do that promise and
wait
... there are JS implementation
... don't see any reasons we don't use promises
... the question about metadata
... is it similar idea to Koster's proposal?
Dave: maybe should have offline
discussion
... e.g., how big the expected buffer should be
... read metadata, update metadata, etc.
Zoltan: who writes the platform for this mechanism?
Dave: maybe this discussion is premature
Matthias: useful to start discussion
about what the procedure is
... could see what developers prefer
... we've been defining low-level APIs
... reflecting the needs
... there are different flavors to be seen
... need to see if it's testable
Dave: basically agree
Jose: one important thing we like
WoT is that WoT is simple approach
... web has millions/10 millions of users
... you have many libraries already
... simplicity is good point of WoT
Zoltan: it's a low-level API you
could use
... this is what this group would like to work on
... do we want to create a specific TF for simpler API?
Matthias: agree to make things
simple
... WoT makes IoT easy to use
... we can show things work
<mjkoster> what about using the IG for these new ideas?
Matthias: this proposal looks
neat
... but developers need to handle the mechanism
themselves
... how to roleback all the transition, etc.
Dave: depending on the use cases
Zoltan: wondering how to proceed
<inserted> scribenick: mjkoster
Zoltan: stick with a scripting API
that follows the TD
... the underlayer with metadata access needs more
specification
Kaz: we can define high level APIs in terms of the low level API
Matthias: we agree that it's a good
idea to create a simplified API but it needs more
discussion
... we can keep this discussion going in the IG and CG where we
incubate new ideas
Zoltan: should we set up a task force to work on this?
Matthias: we can consider this in
context of the rechartering
... if there are distinct communities that different ideas we
could to work on it i a CG or IG
McCool: we need to finish our CR and these items can be worked on in parallel
Matthias: can we establish a consensus on pursuing the scripting API as a low level TD based API and build more simplified/specialized layers on top
Dave: keep the current API focused
on CR and do the simplified stuff in the IG without impacting
the CR
... the simple event model using subscribe/unsubscribe
McCool: would prefer more abstraction to hide the signals and abortstuff
<Zakim> kaz, you wanted to ask if it's OK to record the conclusion using RESOLUTION
Matthias: the interest group is
chartered to explore what should be standardized
... the WG is chartered to complete the CR
RESOLUTION: simplified API discussion to be handled by the IG; WG will continue the work on the current API towards REC
Zoltan: do we keep the simplified API in the repository?
Matthias: we shuld move it to the IG and put it in a different repo
<kaz> [lunch till 2pm
Matthias: break for lunch, reconvene at 2pm]
<dsr> Here is a summary from my slide:
<dsr> A simplified API can be layered on top of the existing lower level API. The simplified API provides an object that you can synchronously read and write properties, and invoke actions as methods on the object.
<dsr> e.g. let value = thing.foo; thing.foo = 42;
<dsr> You get an exception when attempting to write an invalid value or writing to a read-only property - this can be done immediately using the TD
<dsr> The updates and notifications are handled in the background. Server pushes updates to client and vice versa.The client polls if necessary. Applications can subscribe to events such as the expiry of a security token or loss of connectivity.
<dsr> There is a means to get the meta data for a thing, e.g. either thing[“@model”] or wot.model(thing_name)
<dsr> The plan is to incubate this in the WoT IG, while the WoT WG focuses on moving the lower level API to CR as fast as practical
<mlagally> good afternoon
<kaz-wing> https://www.w3.org/WoT/IG/wiki/F2F_meeting,_20-26_October_2018,_Lyon,_France
<mlagally> scribenick: mlagally
Koster gives an overview about binding
templates
... describe the binding of the transport to the interactions.
... binding template examples for different serialisations
(MQTT, CoAP, HTTP)
Matthias: binding templates specification is an informal document, not normative
<kaz> WoT WG Charter, fyi
Matthias: used to describe bindings for
different existing devices
... not a normative part of the WoT spec
... (talks about an example of OCF / CoAP binding)
... descriptive approach to compensate for the "noise" of
specific protocols
... describing how to integrate LWM2M, CoAP
... we consider restructuring the document with sections for
individual protocols
... and then sections with bindings into OCF, LWM2M ...
Mccool: who will standardise the
coap binding
... who will standardise the coap binding?
Matthias: later on the agenda
... for HTTP we need to capture the method name - there is a
W3C note describing HTTP in RDF - we can include this
... want to include it - need some help from w3c staff how to
include it as a normative choice
... Victor has modelled CoAP in RDF
... should it become a note of the WoT spec?
<kaz> https://www.w3.org/TR/HTTP-in-RDF/
Matthias: we need feedback of W3C staff or someone who had the same problem.
Koster: we could make WG notes and decide later how to formalize or define a scheme and register with IANA
Kaz: This is a WG note, but please note that this is a Note because the WG who generated the document was closed before making this document a W3C REC. Also it seems there was a breakout session about how to manage vocabulary, e.g., registry. So we might want to check the minutes from that session and talk with those who organized that session. the minutes of the group that produced this note.
Mccool: we should publish the
note.
... the problem is to describe HTTP formally in RDF.
Matthias: we need this in the TD to describe the protocol.
Sebastian: prefer the HTTP approach - we could extend this to other protocols later
Mccool: include vocabulary in the core.
Sebastian: need a volunteer to clone the HTTP document and adapt to CoAP
Matthias: we need to have a group resolution to have this informative document
<McCool> and MQTT
Kajimoto: our document will refer to various protocols, what about new protocols?
Matthias: new protocols can be defined
by @context and including new protocols
... we can decide to include new protocols into the core
later
<kaz> another example
Kaz: another WG note - emotion markup language
Matthias: this declares a vocabulary,
but not a linked data vocabulary
... we use this markup for HTTP and RDF
... we have the ontology and can generate the documentation
Kaz: the group was closed, so it was published as a WG note. Could become a normative document later.
Matthias: if there are errata, there's
no WG to maintain
... who can answer these questions
<kaz> Kaz: let's talk with Wendy as I suggested the other day
Matthias: I work on CoAP with Victor
Sebastian: will work with Koster on MQTT
<mlagally_> scribenick: mlagally_
<kaz> We need to talk with Wendy again about:
(1) What would be the right way to handle vocabulary for HTTP, MQTT and CoAP?
(2) Can we refer to HTTP vocabulary in RDF 1.0?, etc.?
Matthias: Kaz and Wendy figure out the process requirements
Sebastian: roadmap until end of the year
Matthias: yes
Proposal: add informal deliverables (WG note) for MQTT and CoAP vocabulary .
Matthias: we will have 2 more informal deliverables for CoAP and MQTT.
Resolution was approved by the WG.
RESOLUTION: add informal deliverables (WG note) for MQTT and CoAP vocabulary
<McCool> http://ogc-iot.github.io/ogc-iot-api/
<McCool> OGC Sensor Things API as a good test case for complex RESTful APIs
<McCool> lots of query parameters...
Mccool: this group wants to participate in the next plugfest. They have complex APIs we may want to test
(revisiting slides with URI templates)
Matthias: (shows proposal 3)
Mccool: there could be also a
name conflict
... if a device is already defined and I use the same name in
the parameter and the payload there'S a conflict
(4th proposal)
Matthias: separates API interface
and protocol bindings
... the example takes one parameter into the URI and the other
into the payload
... the example takes one parameter into the URI and the other
into the payload - there may be naming conflicts, ambiguity of
whether the payload is encapsulated in an object
Mccool: you could rename things if you have a name conflict
Matthias: this is a corner case - you
could define two actions
... we could fix it via extensions. Are there real use
cases?
Mccool: we should be able to model any API that's important in the industry
Koster: what if I have different
payload format for HTTP and CoAP?
... that also won't work.
Matthias: it is unlikely that devices have multiple protocols with this kind of problem
Mccool: some cases have mixed
protocols - in the worst case you have two TDs
... I prefer the original proposal.
Matthias: if you have optional parameters, you may pass in a null parameter
Zoltan: how to handle this in scripting?
Matthias: the developer of code has to look at the TD anyway, so he can handle it in code
Zoltan: I could also encode the whole TD using the scripting API
Matthias: scriting API could enclose the container structure
Zoltan: when we consume a TD and call
an action - can we make a map of the consumed thing and use it
implicitly?
... variables are used for generating the URI
Koster: we send the same structure, the middleware has to build the URI
Zoltan: we have real applications-
how does the end user handle that?
... what is the use case? if you change your service you just
change the app. Is this part of the service or the
datamodel?
Mccool: I have a 5th proposal: like proposal 4 , but with a rename option in the TD
(discussion to be continued in the binding call)
Kajimoto: will this resolved in WG or IG?
Matthias: if we can resolve, it goes
into WG, otherwise the IG
... suggest to merge binding call into TD call
<scribe> new timeslot for TD+Binding call is Tuesday 5am PDT
[break till 15:30]
<ege> scribe: ege
[Slides]
everyone: introduced themselves
Matthias: there are also people
participating remotely
... as you know TD makes use of JSON-LD
... one aspect is readability for the developers to understand
the TDs, other aspect is the LD part that is machine
readable
... we had a preparation meeting with Greg on tuesday
... one requirement is defining the @id
... the goal is to do that without the @context
... it should be possible to have a pure JSON without any
linked data
... this requirement was given by the developers
... as you can see you write the context like this which is a
bit complicated
... it would be better to have an id alone like this
... we have this requirement in the WoT WG and we want to see
what JSON-LD guys think of it
Gregg: this looks like a
straightforward solution
... it doesn't solve everything you want to do
... the primary change to the processing rules would be local
(?)
Leonard: that id is particularly
useful if you want to refer to a specific node
... but if you have a separate id, then call it something other
than id
Matthias: we want this identifier to work like your id but the people who don't know can still use it
Robert: something written like that is totally ok or ...?
Matthias: we get then the problem that when this is resolved as a triple
Jose: will td+json be a different
...?
... so it will imply a particular context
Matthias: context can also import additional remote contexts
Gregg: there are two issues with that
Jose: my problem is that we have
a new media type
... instead of using existing standards
... and also new processing rules
Matthias: that is fine in JSON-LD
WG but WoT WG is broader
... there are people who want a defined a format, classically
defined
... we have many people with different background
... that is why JSON-LD doesn't apply to everything
... that is why in IETF we rely in explicit media types to
enable M2M communications
<Zakim> bigbluehat, you wanted to ask about profile="" media type param
Benjamin: is there more processing?
Matthias: there is framing if you
want to use JSON-LD
... you have to option fill it in because you have the
preprocessing
... we need JSON-LD framing to these filling
... you cannot do it with just @context
<Zakim> azaroth, you wanted to also mention accept-profile
Matthias: we are the guinea pig and we will try the media type approach
<bigbluehat> Profile URI registry at the IETF https://www.iana.org/assignments/profile-uris/profile-uris.xhtml
Robert: this gives a
model
... it is a profile that is registered with ld+json
Matthias: there are multiple ways
to do it
... the straightforward would be to define a new media type
Benjamin: I would hate to see a
path that leads into a lonely direction
... like as if someone replaced the curly brackets with corner
brackets
... you lose the community with all the tools
... the fewer media types would mean that there is less tools
floating around
Matthias: but this constrained
media type model doesn't scale
... there is now multiple combinations
... so we are not confident that we will solve all the
problems
... we want to define a mediatype so that we can define an
algorithm
... we want to go this way because we have these specific
processing rules
Gregg: if the group wanted to do that, it can be in the next working draft
Matthias: (said before) if id is possible, we want to do it for january
Ivan: our working group cannot do a commitment the feature won't change
<kaz> kaz: we've started to talk with PLH about the procedure
Gregg: certainly one of your
requirements
... the fact that we are with these non fixed things
Matthias: to explain this, we
have this @container
... here is this example on how it would look like for the
td
... ifwe look at this in a processing step
... pump status has this @id
... if we convert into triples
... we have this first part that is nice
... we have these statements that pump status is set to
false
... writable set to false
... now these URIs are the same because the / is missing
... people are confused on why the / is not added
automatically
... we have this @container solution
... compacting should also work
... our argument is that a lot of usage of JSON works like
this
... that is why we would advocate this feature in JSON-LD
... do you need an @ based @id
Gregg: I think these are ...
issues
... in any case we have the timing issue
Matthias: this is not something
that can be or should be rushed
... there is definetly need for preprocessing
... best of both worlds
... json for developers and ld for semantic processing
Robert: is it possible that same property would be used in different parts of the tree
Matthias: the main requirement is that we get a full URI ...
Leonard: if your assumption is that pump status is used only in this context
Matthias: it can appear somewhere else but it would have a different id
Leonard: you are not creating
reusable objects
... it doesn't do other references, it is self contained
Matthias: they are handmade, a
nuclear plant that is unique, one of a kind
... iot schema and ocf define these reusable parts
... we have use cases, like the Oracle cloud, it is out there,
designed like that
Robert: that is why I ask if properties are defined with a path
Matthias: since they are trees, it is not necessarily pump status
Gregg: certainly the the usage
case for json ld was ...
... this is deployed code I guess so there is no way to change
it
Robert: everyone would be comfortablewith that one
Matthias: in our algorithm we
will do these slashes
... if you use a json structure
... there is a hierarchy that these are different scopes
... so working in iot for a long time now
... there are lot of projects there are a lot of projects
... who do this slash
Gregg: i think it might be useful to review other JSON-LD 1.1 features
Matthias: so you are chartered until the end of 2020?
Gregg: yes
Matthias: so there is still some time
<kaz> JSON-LD WG Charter
Matthias: working group will go
until june
... with a possible extension
... I heard you in the internationalization discussion
... we also have human readable fields
... so far we thought that a construct like this would be
enough
<kaz> IANA language subtag registry
Ivan: the language spec covers a
lot of specs
... the problem is with language text that mixes both
directions
... language spec doesn't cover these kind of cases
<kaz> I18N - Bidirectional text in HTML
Ivan: bidirectioanlity, ruby
...
... other groups hit this issue as well
... but that is the problem, it is up to you to decide
... while we know that we cannot express everything ... the
internationalization review will not be "nice"
<leonardr> https://w3c.github.io/string-meta/
Ivan: think of the case where you have a machine that has a number in the name and you send it to Iraq and you have big problems.
<ivan> I18n discussions at the publication working
Leonard: they removed the these markup languages
<bigbluehat> Ruby Markup for those new to this space https://www.w3.org/International/questions/qa-ruby
Matthias: this is metadata
Ivan: but the application may want to display it
<kaz> Japanese example
Ivan: as I said if you can
convince them, in practice these are, rare
... so it is an acceptable risk, in inverted comas :)
Matthias: if these numbers are mixed, they would destroy the machines or something
(majority) laughes :)
Alan: you are not the first one to stumble upon this
<kaz> Bidirectionality example
Matthias: i am not happy with the html solution
Benjamin: I was tasked with the
json-ld
... ? ... without the whole html parser kit
... who know what it will turn into
Matthias: I would like to see the unicode solution
Mccool: exactly
Matthias: it was good for us to see the ... ?
Mccool: if a text has no markup it is interpreted as open ?
Benjamin: that is an open question
Ivan: it is slightly better than
that
... unicode caracters indicate whether they are written from
left to right or rtl
... arabic is by default a bidrectional language
... web applications has a table in the end
... written by richard ishida
<kaz> Bidirectionality example
<kaz> https://www.w3.org/TR/css-writing-modes-3/#text-direction
Ivan: the fundamental problem
from json ld point of view
... rdf never handled the bidirectionality
Alan: it is actually quite good
Matthias: then we go forward like that
Matthias: the last thing is about remote context privacy leak
<ivan> bi-di examples as expressed with extra unicode characters (to be moved above)
Matthias: danbri gave an
issue
... in our WG
... DanielP has said that xml solved it by registering your xml
resolver
... these context files are stored locally
... we can say that the implementors should be aware of
that
Ivan: we were discussing an
alternative
... this is what css does
Matthias: this is a big jump
Benjamin: this is not related
to that, packaging as a potential option
... short living signatures
... cache this hash, if you find another request hash that
one
Matthias: we will work on that
for sure
... maybe some knowledge from how fw updates are done in
IoT
Benjamin: this is a generic web
problem
... it has been in the web for a long time
Matthias: is it forbidden to have
prefix registries
... if you have issues with that it would be good to hear
that
Robert: they want to guarantee contextes
Matthias: So i know that there are some discussions going on about these verifiable claims
Carsten: there is a lot activity
<ege> +1 to kaz :)
Matthias: I was assuming that you
were talking about the W3C activity
... thank you very much, for me it was really useful
... we now know about the timing issue
... we would like to stay in touch developing this
Robert: thank you for inviting us, very clear slides and all those who were present in spirit!
Matthias: thank you for keeping up with the agenda
Kaz: GROUP PHOTO!
Meeting finished
<kaz> [day 1 adjourned]
<inserted> scribenick: mjkoster
presentation from Jose Manuel Cantera on ETSI NGSI
Jose: NGSI-LD is based on
json-LD and describes entity types, entities, and
attributes
... NGSI follows a RESTful approach to API design and also has
a pubsub model using webhooks
... entities have formal relationships with other entities
following the property graph approach, i.e. provides properties
for relationships
... also allows properties of properties
... (presents example)
... entity type vehicle, property of brand name
... the example describes an accident with a number of actors
and relations
... vehicle has a location, accident is "observedAt"
... s/At"/At" some time some time
... THe API exposes the entities for RESTful operation and
queries
... we call it a temporal API because it can be used to
predict
... not strictly historical
... a subscription is a type of query that results in
notification via webhooks, as previously noted
... we don't use SQL or SPARQL languages but prefer a simpler
approach
... we allow queries by entity type and relations
Sebastian: are queries allowed in th epayload?
Jose: only in the URI, it
is more RESTful
... we use GeoJSON
... all results are returned in a single compact array
format
... thoughts on interoperability with WoT
... thoughts on interoperability with WoT
... bring WoT Things into the NGSI-LD system by accepting Thing
Descriptions
... establish a relationship between the entity and the WoT
thing
... it can work with semantic annotation in a TD
... we need to find a way to describe a room and the things in
it with their relationships
... considering how to map events that trigger actions in the
management layer
... considering how to actuate things using TD
... important to interoperate with WoT to make it easy for
developers vs. lower level systems
... (presents a list of links for further study and
investigation)
McCool: we have a threat model that could be extended to general IoT threat model and we can share the concepts
Jose: (presents roadmap
for NGSI-LD with FiWare)
... Thanks!
Matthias: there is a lot of good
experience we can share
... we should work on aligning terms like Thing Description
McCool: we can work on discovery
Koster: we are conceptually aligned on entities and Feature of Interest and the integration pattern
Matthias: +1
... we are working on setting up a W3C CG for the semantic
vocabs
... had a discussion with Orange also on the property graph
patterns
Jose: we did some
investigation and found that the number of nodes in the graph
explodes when mapping to RDF
... there may be a better mapping model
... it needs a lot of intermediate nodes
Matthias: please keep us updated on the
progress on property graphs
... and on the alignment with RDF
McCool: we need to evaluate an implementation of property graphs
<ryo-k> W3C Workshop on Web Standardization for Graph Data https://www.w3.org/Data/events/data-ws-2019/cfp.html
<kaz> [ ALL, sorry but it seems the PC for webex connection got rebooted. so please wait a moment. ]
Dave: there will be a workshop
coming up on property graphs
... (describes a bunch of stuff around the workshop with a
sales pitch)
... i.e. please particiate
McCool: there is a SensorThings API with queries built into the API, also the NYC has implemented some query languages
Matthias: especially need to look at
use cases
... need industry cases to be covered
... looking for more diverse material
McCool: We could provide some material for the security section
... we are also extending the functional requirements
... cleaned up the structure to improve the explanation of the
concepts and architecture
... starting with common IoT architecture
... going into how Wot works with IoT architecture
... describe the constraints e.g. URI addressing
... then describe some abstract flows for interactions that we
can also use to explain binding templates
... then explain the building blocks
... then describe implementation of servients
... next section explains deployments with servient roles, e.g.
devices, proxies, applications
... also describes directories and discovery but this is
informal since it's not in the current scope
... then describe integrations and plugfests
... finally the security section
... the security section also covers alot of general IoT
concepts, e.g. the threat ontology
Matthias: if anyone has time to help with this document, please let us know
Sebastian: we need to work on alignment of the figures
Matthias: the examples show one way we could normalize the figures
Lagally: this is a summary of
IoT use cases from Oracle perspective
... predictive maintenence, real time monitoring, and other
categories
... also some specific application domains, e.g. cold chain
management, utilities, oil and gas
... Smart Cities, Environmental monitoring
... Smart Buildings
Koster: we can say "climate change"
McCool: I see a few more we can add, but it's already a big list
Matthias: what are the use cases that
need integration across application domains?
... These are the real applications for Web of Things
Dave: when there are many producers and consumers
McCool: when there is data
sharing
... maybe we can define like 5 characteristics related to
architectural patterns
... or some way to aggregate into groups
Lagally: the list is aggregated by vertical
Matthias: we should be focusing on those use cases that need integration
McCool: (restates the conclusion around use cases that need integration)
Kaz: can we link functional requirements to use cases?
Matthias: yes, that's the idea
<inserted> and maybe the discussion from this session could be a good starting point for that purpose
McCool: and maybe there are different patterns for different scenarios
Matthias: terminology needs to be
improved
... the new terms are hard to learn
... we tried to change the terms be used but they are all
important and meaningful to the group
... so we need to document what terms we use and do a good job
of explaining to newcomers
... (proposal is to keep the terminology and make a good
explainer)
Jose: it was a challenge to find the examples to help understand WoT
Lagally: could we start up a Q&A to capture these issues?
Matthias: feedback is welcome so let's work together
<McCool> https://github.com/w3c/wot-security/blob/master/presentations/wot-security-tpac-10-2018.pptx
McCool: I will summarize 3 hour
meeting on Monday and other recent work, and some other small
topics
... coap security schemes added to the security test
... question about how strong the guidance needs to be, e.g.
should vs, SHOULD
... security considerations document is done but needs to be
strengthened
... (monday October 22 meeting summary)
... functional testing and adversarial testing are two
different things that we track separately
... we are working on how to use https locally
... also working on object security defined as a content
format
... defining adversarial tests
... (describes https local ideas with oauth and forms and
overrides)
... strawman proposal for local https modeled on coaps
... presented to the local WG
... the local WG is looking for things that work with
browsers
... their schemes all have some issues and there is no firm
recommendation
... (discusses some of the issues)
<ryo-k> httpslocal CG F2F Agenda (took place yesterday) : https://github.com/httpslocal/group/wiki/Meeting2018Oct25TPAC
McCool: psk could be made to work but
there is additional specification required
... recommendation to not develop this in our spec but work
with upcoming implementations
... it's not baked yet
Ryo: we don't have a concrete
roadmap for which proposal(s) to follow up on
... also they hav eexternal dependent orgs like IETF
... but as of now there is no concrete direction maybe in 1/2
year
McCool: machine to machine is
solvable but might not be the same solution needed for
browsers
... there is a best practices section which lists the
configurations that achieve a minimum required security level
for testability
... looking at discovery security and TD signing
... finally, we are working to develop adversarial testing
Jose: how are TDs distributed?
Matthias: the distribution of TDs is
not in scope for the WG
... it is use case dependent
... there is Thing Directory but that is a topic for the new
charter
McCool: we are trying to first
mitigate the risk of surveillance and tampering
... need to go through the document and make security
assertions
Matthias: also we need to define what is expected from an implementation
McCool: deferring the work on
Security Definitions
... there is not a big need for this
Matthias: this comes from
implementation experience where there is work for an
implementer to do research
... people prefer to have security definitions at the top level
of the document
McCool: OK, we will look at restructuring the document with a definitions block
Matthias: we should create a workshop to address this
Koster: smartthings would like to participate in a workshop
<McCool> https://www.w3.org/TR/wot-security/
McCool: proposing a terminology
change from URI
... (showing some examples from BP document)
<McCool> https://github.com/w3c/wot-security/blob/master/wot-security-best-practices.md
McCool: we don't need some of the
content, moving some content, etc.
... the important part is transports and their security
schemes
Matthias: TLS 1.3 is pretty new and might be approached cautiously
McCool: should we simplify the testing by removing things from the document we don't test
Matthias: propose to keep them in as informative terms
Sebastian: how do we add new upcoming security schemes?
McCool: we develop a general
extension mechanism and test it with some cases
... it needs an implementation and a test
Matthias: we need to look at how it
will work with terms in the controlled vocabularies
... it comes down to whether an implementations can understand
the terms and correctly act on them
recess until 11:00
<boaz> present
<dape> scribe: dape
Mike: work for W3C (Japan)
... involved in testing HTML
... have test suite with ~200 specs
... github web platform test
... open source, not controlled by W3C
... other organizations involved too
<kaz> General requirements/resources on testing
Mike: wold like to hear testing plan.. so that we know how we can help
McCool: WoT not browser oriented spec
<McCool> https://github.com/w3c/wot/blob/master/testing/wot-test-plan-tpac-10-2018.pptx
<kaz> General requirements/resources on testing
Kaz: wanted to provide basic
resources (see md)
... from CR to PR we need implemenation experience
McCool: No substantial changes after CR?
Philippe: possible. but requires to go back
Kaz: What implemention
experience?
... browser example... implementation for each feature in
IE/Chrome/FF/..
McCool: test pairs of implementations (at least 2 pairs)
Matthias: in browsers client side tests
only
... in WoT there are tests for each side
(server&client)
Kaz: need to different sections in report, one for client and one for server
McCool: node-wot client vs node-wot client is ok
Simon: in W3C there is custom server in pyhton ... can be used to do more complex stuff
McCool: different validation/testing tools.. e.g. security vs dataSchemes
Kaz: test report can mark optional/required feature ... number of passed implementations
Boaz: Not sure what we are doing right know...
Matthias: WoT group tries to figure out what other groups did w.r.t. testing
Kaz: web platform test might not work in all cases for our use-cases
<zcorpan> https://wpt.fyi/
Boaz: interesting. worth showing how web platform tests look and work
<boaz walks over results/material>
Federico: difference between "test results" and "interop"
Boaz: can test custom protocols
Simon: e.g. also websocket
Matthias: reference websocket server?
Simon: websocket server implementation...
Matthias: test results for websocket also...
Simon: no tests for server
side
... server needs to be correct
... server developed organically
Matthias: we need server side also
Boaz: first time we would do that... interested in doing that
Matthias: server side might be out-of-our control
Kaz: most of our implementation
is not browser-based
... other testing framework... TV browser-related
<boaz> can you paste a link to this?
<boaz> kaz, can you paste a link to that site?
Boaz: what is the timeline?
Kaz: 2 months
McCool: asked for extension
... June
Boaz: should start sharing
materials
... are already sharing material with node.js
... Bocoup is interested in verifying submitted data
McCool: most of our systems run node.js
<boaz> kaz, can you link to the wave report that you had up?
Kaz: automotive did testing also. WoT can do the same
Matthias: We got experience in our
PlugFests
... automatic testing woud be great.. but I do foresee also
manual steps
McCool: Timeline
... charter extends to 30 June 2019
... REC 27 June
... PR 28 May
... CR 16 April
... "at risk" feature can be removed
Simon: minimum time in CR?
Mike: there is.. not sure out of my
head
... believe less than 6 weeks
Boaz: need way to show spec conformat impls for enter/exit CR
McCool: starting CR we should be
sure assertions do not change
... have functional and non-functional testing
... functional testing: traditional, TD validation etc
... non functional testing: security, robustness
... Scripting API is separate
<Zakim> MikeSmith, you wanted to comment
Mike: wanted to make sure. web
platform tests are mainly for browser apis
... main benefit: all browser run test for CR
... get good characteristics
... do not see real benefit for non browser APIs at the
moment
... possible.. but maybe not sensible
... use separate repo
Simon: W3C process: should make
it as smooth as possible.. not entering CR until tests are
fine
... avoids entering CR multiple times
Mike: no point starting CR when still unsure when exiting CR
Kaz: need to check progress
Matthias: No need to are in CR for testing
Simon: Correct. start before
Singer: testing shows no issues --> ready for CR/REC
Lagally: 2 thoughts
... validate TD.. fine
... behaviour testing...
... was thinking about "describing what we want to test"
... concrete reference devices
Matthias: we have a "test thing"
... tries to cover corner cases
Lagally: Not complete yet... see uri templates et cetera
Matthias: sure...
... need to collect more input
McCool: discover all features
... proving all features
Matthias: BTW: our job is not that OCF
device behaves properly
... our job is about TD
Kaz: should concentrate on TD assertions first
McCool: did have preliminary scan
through assertions
... marked assertions and have tool to extract them
Boaz: wanted to say more about browser testing
<boaz> kaz, can you share a link to the wave test suite you showed?
Lagally: question about test categories (adequate representation of target eco standard)
McCool: tested it in PlugFest, but need to document it
Boaz: i think this point is beyond CR testing and their needs
<taki> +q
Kaz: suggest separate topics into (1) testing for spec transition and (2) more advanced ones
McCool: lets correct items under "behaviour testing" (on MCC slide)
Lagally: reference test thing used for advanced testing?
McCool: think so
... >back to assertion test collector<
... some of our assertions can be handled by "is JSON
valid"
... Ege proposed "postive" and "negative" example
Taki: the earlier we have test
framework... the earlier we get feed back from outside the
group
... --> should publish testcases and framework soon...
McCool: hope to get this up on
github soon
... have set already
... 2 pairs needed (server/client)
Ege: TD is only contract between
2 devices
... can test whether client creates correct requests
Matthias: parts of tests are for
REC
... others are good in general.. (interoperbaility)
Ege: trace can be used for testing
Matthias: clients creates right request, ..and gets/interprets response
Lagally: question also whether JSON schema in annex conforms to the rest for the spec
McCool: make sure assertions are
clear (not to vague)
... I can do the tooling#
... we have several tools we need
... JSON Schema and JSON-LD tools
... need to figure out which tools are needed
Matthias: Question: How is HTML spec tested (document format)
Simon: question how html parser
is tested?
... tests live in separate repo, html5
... different kinds of tests
<boaz> https://github.com/html5lib/html5lib-tests
Simon: tests for
tokenizer
... difficult to run in WPT
... tests... compare DOM tree in browser with DOM in
format
... tree builder tests
Matthias: expected DOM... how is this represented?
Simon: custom format
see github repo
Matthias: how is comparion done
Simon: custom runner.. able to
parse this format
... for WPT runner.. own parser written in JS
... comparing browser DOM and virtual DOM
Matthias: have something similar..
scripting API
... BUT needs to be tested separated
bouz: parsing natively implemented?
Matthias: in node-wot it is TS
implementation
... Panasonic is browser-based
Simon: represent object in JSON?
Matthias: TD is JSON already
... not exact roundtripping...
... client just needs to parse JSON.. not produce JSON
Boaz: browser implementations run in sync... exporting/importing tests
McCool: like to see this kind of automation
Matthias: Believe we have to deal with
mixture
... work on automation step by step
Boaz: Implementors should be able
to "push the button" to run the test
... aria practices guidelines table look similar to your..
worth looking at it
<mkovatsc> https://github.com/w3c/aria-practices (?)
McCool: Gaps and Issues
... non functional testing
... we have some assertions that are too broad.. and some are
to narrow
<boaz> https://w3c.github.io/aria-practices/
<boaz> and here are the examples source code: https://github.com/w3c/aria-practices/tree/master/examples
<boaz> ^ mccool
McCool: should focus on functional
testing
... ToDo's
... look at assertions carefully
... to exit CR we need complete sets of tests
... example and counter example
Kaz: finalize test preparation before CR
Simon: correct.. that would be
my suggestion also
... how do we approach manual tests in WPT
... use test drivers
... e.g. clicks on coordinates
Koster: emulator?
McCool: would be a good
solution
... wrap w.r.t next steps
... make sure assertions are clear
Dave: can we group up the work
Sebastian: we have some new stuff in
TD
... still some open issues on github w.r.t. TD
McCool: when do we say "no new features"?
... we need last day like freeze in January
Matthias: start with assertions for stable stuff
McCool: will start working/organizing tool.. creating reports
Matthias: got inspiration from other
testing reports
... white for not implemented, green pass, red failes.. row per
test case
column for test pairs
Sebastian: new TD slot... test discussions should take place there also
Kaz: should start test work soon
McCool: Focus testing in Online PlugFest also
RESOLUTION: we'll start initial review on test assertions in 2 weeks with the TD TF; concrete time slot to be determined
<inserted> [lunch till 2pm]
<dsr> present?
<dsr> scribenick: dsr
This is something we’ve been discussing for quite a while now within Intel
The opening slide lists the people involved so far
From a business perspective, the diversity of the IoT inhibits scaling, slowing growth
Smart cities seem like a domain which has a great deal to gain from establishment of open standards
There is a proposal to launch a W3C Business Group and to enage in pilots
The early market with early adopters is qualatively different from that for later adopters post the chasm
Early on different vendors push their own proprietary solutions, but later the market matures and grows as open standards are widely adopted
We want to motivate and enable cities themselves to articulate use cases and requirements
The ultimate goal is to enable economies of scale
A McKinsey survey identified New York and Singapore as two successful first mover smart cities
They both implemented an online data portal for others to create applications
Applications are typically not portable to other cities due to local contextual requirements
NYC adopted a proprietary approach for making data available. Singapore went down the route of CSV files.
McKinsey talks about the technology base, open data access, and the application ecosystem
Open data access an an open application ecosystem needs standardisation to scale
Michael shows a crowded slide for IoT standards and reference architectures
Many standards and tools for ingesting and managing data
User interfaces provide value through visualisation and control
W3C’s strengths include user interfaces (web browsers) and metadata (RDF, Linked Data and a suite of associated standards)
Metadata management and semantic modelling are key missing elements in many other standards but are necessary to manage and combine data from diverse sources
W3C Web of Things provides simple clean way to describe devices and services. The Linux Foundation’s OpenAPI defines a way to describe Web APIs.
We want to work with W3C’s Alan Bird to launch the Smart Cities BG and to feed emerging use cases to drive technical requirements in the WoT IG/WG
We want to do so in collaboration with other groups outside of the W3C
Some discussion about the security scaling challenges
Smart cities nonetheless have difficulties with running their subways (metros) and heavy traffic
Michael: different kinds of cities have different problems to overcome
Cities can be classified into groups by their most important challenges
Michael notes that we are expecting to focus on deep analysis for a few problems rather than an overall top down approach
Lagally: do we expect new use cases to emerge (after the list he presented this morning)
yes
mkovatsc talks about the architecture document which includes that list. The Smart Cities BG will come too late for our short term deadline for the WoT architecture doc.
jbrewer: we’re very interested in plugging in to the scenarios and use cases in relation to accessibility
Michael: one example is helping people to discover accessible entrances for buildings
Accessibility also relates to support for aging populations in cities
an increasingly important topic for smart cities
mjkoster introduces the context for the work on semantic vocabularies and the role of iot.schema.org
Darko is collaborating with Michael Koster on this. He talks about some work based upon Node-RED for designing simple applications
An example involving a CO2 alarm
Node-RED supports event flows across a graph of components
You use a graphical interface to add components to a canvas, to connect them up and specify the handling behaviour.
Adapter components (nodes in Node-RED) can be used to broker between other nodes that are not directly compatible, e.g. due to using different physical units
The Node-RED demo uses nodes designed with iot.schema.org vocabulary
This could be offered to people contributing to WoT plugfests and interested in creating mashups
McCool: How far can this go?
Darko: this is currently based upon thing directories for the set of nodes
<kaz> kaz asks Darko if he would participate in the upcoming plugfest using this mechanism, and Darko says "yes"
<inserted> it would help people implement servients easily
Koster: I presented iot.schema.org at the SSN workshop last week
<mlefranc> Link to the SSN workshop webpage: https://ssn2018.github.io/
We’ve created a charter for a W3C community group, and one of the reasons for the CG is to provide an IPR framework
We’ve created some introductory materials
We’re looking at integration with schema.org perhaps a sub-domain
Matthias: schema.org focuses more on ecommerce
Some commentary on developer tools
<mkovatsc> ... and hence has conflicting classes. The subdomain is most likely necessary
We can map existing schemas in different formats into TDs and then annotate them with semantic descriptions
We need to get the CG running with the new charter
Amelie Gyrard has done an industry wide survey of existing definitions
Michael talks about integration with other ontologies
The web of things TD is a crucial ingredient
Bruce Nordman has worked on vocabularies for smart energy
(perhaps similar to the European work on SAREF?)
Dave needs to chat with mjkoster on conversational agents (chatbots) and future W3C workshop
<mjkoster> https://github.com/iot-schema-collab/teleconferences/blob/master/iotschema-status-20181026.pdf
Current charter ends 31 Dec 2018. We will get a 6 month extension within which to get our work items to REC
<mjkoster> (the iot.schema.org slides)
We are encouraged to recharter the WoT IG as soon as practical
charter for 30 months to sync end with rechartered WoT WG (assuming it is rechartered at the end of June 2019)
IG charter to work on incubation and liaisons
Mozilla want to avoid wording precluding developing a Web platform, so we need to figure out some tweaks to the IG description
Initial planning for a WoT workshop for technical audience and out reach around the RECs
McCool: we’re also talking about a separate (non technical) workshop on smart cities
Matthias: we’ve also expecting to incubate work on simplified APIs layered on top of the existing API
We want to avoid blocking constraints between the different groups
The smart city workshop could be later - in September
Some discussion about possibility of re-entering CR if we discover the need for changes. McCool would prefer a more solid spec before entering CR to reduce the likelihood of such circling back
lmedini asks about packaging of web applications
McCool: this is something that could be incubated in the IG
Dave notes that this relates to requirements for open marketplaces
we could have an IG task force on open market places that looks at discovery, packaging, licensing etc.
Matthias: the rechartered WG would focus on maintenance
Dave: we could have an AC review with very small addition if the IG wants to move a new work item over to the WG
The aim is to keep the lawyers happy
Kaz: there is an option for creating additional small WGs if we think that appropriate
Koster: too broad a charter could be counter productive
McCool: our immediate priority is to freeze the specs and develop the test suites
<kaz> Matthias: is everybody happy with this plan?
<kaz> (no objections)
<DarkoAnicic> iot.schema.org CG Charter: https://github.com/iot-schema-collab/intro-materials/blob/master/wg-charter.md
mjkoster comments that he wants to focus on commonalities not features of interest that are diverse across devices and domains
the objective is to develop a process for work on vocabularies
consensus driven, and a light license with minimal restrictions
Contacts: Koster, darko, and Danbri
Darko: tools could be something we need to work on
Koster: the CG needs to focus on vocabularies, but perhaps not tools
Dave: I would like to see some consideration on metrics and tooling for measuring an analysing adoption of vocabularies
Sebastian: I have something to report on that topic
Koster: the next step is to review the charter to see it matches our needs. We want to apply the charter to the WoT CG to take advantage of the large set of contacts
McCool: perhaps a CG name that is more specific to vocabulary development?
Matthias: what’s happening in the CG currently
Dave: nothing, but developers will be very interested in work on vocabularies
Matthias: there are arguments on both side
Koster: a survey could be helpful on the choice of name and to get feedback on the charter
Dave: a survey would be good , I got 75 lengthy responses to the one I did last year on behalf of the Open Data Institute on vocab development
you could announce it to the current CG members and try to reel them in for the new work
<kaz> [break until 4pm]
<kaz> scribenick: kaz
Matthias: would check the
schedule
... good to block several days
... one of the achievements was setting up the
infrastructure
Lagally: we can host the infrastructure
Matthias: everyone set up the
infrastructure reachable
... people meet again online
... discussion online/offline
... testing instances
... first week of Dec?
... any conflict, e.g., with OCF meeting?
Sebastian: not good for me
Matthias: proposal: 3-7 Dec. 2018
... conflicts: Sebastian, Toru
... let's cover several candidates
... Proposal: 10-14 Dec.
Kaz: maybe depends on the time as
well as date?
... do we need to do all the 3 slots?
Matthias: brought up node-wot on the
new eclipse site, etc.
... would envision something...
... on Monday, everybody on their timezone set up the
infrastructure
... also talked with Federico about VPN
... first need Web interface
... but need some configuration
Koster: Federico and I had some
discussion
... shouldn't be hard to set up the configuration
Matthias: multiple members will
login
... so multiple connections required
Koster: that's the goal anyway
Matthias: did you talk about concrete
timeline?
... e.g., 1 month?
Koster: yeah
... could work for that
Sebastian: question about tools to Ege
Matthias: test tools
... automatically send commands to the tool?
Ege: VPN, etc., shouldn't change the test results
Sebastian: good to have kind of
dashboard
... e.g., who/what is online
Lagally: want to test on the simulator
as well?
... would be useful
Kaz: wondering about proxy and
directory
... already included in the "infrastructure" part?
Matthias: regarding proxy, we don't
really need it given VPN
... should have joint call on Friday
... and feature table we discussed during the testing
session
Ege: can generate an initial
one
... based on the assertion list
Matthias: we should work for all the assertions for full coverage
Kaz: if we need a test but it is
not included in the spec
... we need to update the spec
Matthias: update test spec
... prerequisites, stimulus, expected results
... question abou thte basic plan?
Lagally: comment on "Monday"
Matthias: friday before to satisfy
JST
... Yamada-san, what about you?
Yama: ok
Toru: wondering about the spec to use
Matthias: this basic plan just mentions
"one week from Mon to Fri"
... we can pick up concrete date
... what about "Prerequisites"?
Ege: the name of the test bench is "WoT Testbench"
Lagally: and "TestThing"
Matthias: some problem with cases
... our current direction is camel cases
... we have to precheck
... new vocabulary to add as well
... playground to be updated based on the latest draft
Sebastian: TD to be fixed by the end of Nov?
Matthias: shows a big table of language
coverage
... this is not for our spec
... but number of implementations here
Sebastian: meaning of the colors?
<mkovatsc> As inspiration only: https://w3c.github.io/typography/gap-analysis/language-matrix.html
Matthias: we ourselves can decide how to use the colors
<mkovatsc> https://github.com/w3c/wot/blob/master/plugfest/2018-sept-online/preparation-TEMPLATE.md
Matthias: next our own test plan
... this list is not complete to cover our specs
... need to merge with actual test cases
... Sebastian, what about the TD spec?
Sebastian: by the end of Nov?
... deadline with what to do
... to generate a table on implementation results
... probably including a plan
... like preparation.md
Kaz: yes
... W3C WGs used to publish something like that as an
implementation report plan
Matthias: would suggest we start with
clarifying what to do first
... and then automate it
Kaz: +1
Koster: we should include information on the components of the testing environment, e.g., node-red, node-wot, ...
Kaz: +1
Matthias: please send detailed
implementation information to Matthias
... Koster and Ege ask Federico about F-Interop mechanism
... Sebastian pings Ege for playground
... Matthias/McCool work on the test spec
... regarding the date?
... probably we should organize a doodle again
Kaz: after making decision on the
basic date/time
... would be better to use a spreadsheet to manage the concrete
slots
Kaz: Tokyo, Japan hosted by
Keio
... checking with the Keio Headquarters
Matthias: when to enter CR then?
Kaz: Feb at the latest is the
suggestion
... and we can review all the provided reviews/comments on GH
at the f2f
Matthias: CR: ideally Jan, latest in
Feb
... failed if Apr
... (updates)
... ideally in Jan, recommended in Feb, latest in Mar, failed
if Apr
... would it be better to have f2f earlier?
... plan to freeze and ship CR at end of F2F?
Kaz: in that case, we don't have to stick with the option in March at Keio
Koster: could check within Samsung
Matthias: for member
representative
... who can check possible locations?
Koster: wondering about the cost
Matthias: meeting room, network,
catering
... but doesn't have to be provided other than the meeting
place
Koster: can check
Matthias: any possibility for Keio in Jan?
Kaz: need to check
Lionel: just fyi, Web Conf in May in San Francisco
Koster: how many days?
Matthias: we can skip openday this
time
... Sumsung (US or UK): Koster to check
... Siemens (US): Sebastian to check
... next
... 2nd WoT workshop
... had discussion with the W3C Management
... marketing event for specs
... would target May
... after publication to get comments
... may want to invite automotive companies as well
... possibly have a separate session on smart city and invite
the (expected) smart city BG
... purpose: promote W3C WoT RECs
... location:
... Web Conf in San Francisco in May
Kaz: would suggest we hold our workshop separately
Sebastian: +1
Matthias: could have a mini-workshop or a W3C track session there
<lmedini> WWW2019 workshop call: http://www2019.thewebconf.org/call-for-workshops
Sebastian: btw, having that possible satellite event under the "location for the wot workshop" section is confusing
Matthias: moves it to another section
of "satellite event"
... we should think about the program committee
... Sebastian Kaebisch, Michael Lagally, ...
... duration: usually 2 days
Sebastian: should set the date already
Kaz: it usually takes 6 months for preparation
Matthias: would check people's
potential conflicts
... 22-23 May 2019, Munich, Germany?
... note: AC Quebec on 7-9 Apr
Matthias: WoT Architecture
... new WD within 2018
Sebastian: good to finalize early since there are references from TD
Matthias: TD
... update for online plugfest
... close issues
... target freeze?
Lagally: some of the GH issues are
marked as "next iteration"
... would be better to use another label like "need more
discussion"?
(discussion about possible labels)
Matthias: will continue the discussion
during the main call
... thanks a lot for joining the f2f meeting
[wot f2f adjourned!]