<inserted> scribenick: zkis

Agenda discussion

<scribe> Agenda: release discussion, updates, discovery, implementation, testing, next calls.

Daniel: any other agenda points?

last meeting minutes

<kaz> July-20

Minutes approved

Next release

Daniel: People should take a look at the spec but people are on holiday. I thought about end of August.

Zoltan: I agree

Daniel: we should give 3 weeks for checking the spec

Zoltan: we can fix the ReSpec error by checking the cross-references
... end of August sounds good

Cristiano: for me too

Mizushima: I am on holiday in the end of August
... but no problem

Daniel: will write an email asking feedback until 24 August

Updates on read/write-multiple

Daniel: we should defer this removal a little more
... we can put a note these features are in danger

Zoltan: we can also decide to include only stable features in the spec, so remove it and re-add it when it becomes clear

Daniel: node-wot already has it and if people use it then we should give some time
... the TD task force has the same issue

Zoltan: we need a deprecation mechanism in node-wot

Cristiano: we could mark it in the TypeScript definition
... what about of differing from the TD on this?
... but we should synch with the TD spec
... the API version should be linked to the TD version

Zoltan: we could include properties with the API version and the TD version

Cristiano: we could also include it in the API doc
... so not only machine-readable, but also human-readable

Daniel: Cristiano please create an issue about this

Zoltan: does the TD spec have an official version number?

Cristiano: the spec has one

Zoltan: the TDs have a version, what is the rule there?

Cristiano: is that the ontology version there?

Daniel: we need to check that

Zoltan: vocabulary and ontology versions should define it

Cristiano: right, we need to discuss this in the TD call

Daniel: maybe there are other changes as well

Cristiano: as a developer I should be able to point to a page or a version

Zoltan: optimally we should be able to define a dependency in Node

Cristiano: will create an issue at the TD and also at Scripting

<scribe> ACTION: Cristiano creates issue for versioning on the TD and Scripting specs

Discovery

<kaz> July-20 Discovery minutes

Daniel: who was present on the call?

Cristiano: I was, taking the minutes
... maybe we should check the minutes
... presents the discussion from the Discovery call
... in the first version of the spec there are sections which use some conflicting words vs our usage of the same words
... we discussed that with Zoltan in github issue
... they use 2-phase discovery, 1. find the service, 2. use that service

Zoltan: the current API reflects IoT protocols discovery mechanisms, but not the WoT-specific 2-phase discovery

Daniel: the first phase is what is not supported in the current API

Cristiano: authentication is also in the loop

Zoltan: which should be pushed outside the API if possible at all

Daniel: we do have an issue to conveniently fetch a TD, which corresponds to the "direct" discovery

Cristiano: in the Discovery TF usage of the word direct refers to Directory

<kaz> WoT Discovery initial draft

Cristiano: we need more work on this, so we cannot make the Scripting changes right now

Zoltan: I agree, especially with phase 1

Daniel: so Cristiano and Zoltan are checking the Discovery TF works

Implementation

Daniel: if we publish the spec, we also need to update the implementation
... hopefully could find the time in August for this
... we need some help with testing

Cristiano: is that full end to end testing like Ege is doing, or just unit tests?

Daniel: I very much like the test suite that has a server running and will test a client against the API
... and gives a mark for the coverage

Cristiano: that scoring mechanism would be nice indeed, but it's quite difficult IMHO

Daniel: the issue number is 190

https://github.com/w3c/wot-scripting-api/issues/190

Daniel: it is difficult because we need both a server and a client

Cristiano: how do we test that a client consumes a TD in the right way?
... how do we check the correct behaviour of an implementation

Daniel: it's doable in JS and TS, but in a different language it's different

Zoltan: we could define a test spec and implementations could implement that
... in language-specific way

Cristiano: that would be nice, needs a lot of work

Zoltan: the algorithms in the spec should be clear enough that a test suite could be created from that

Cristiano: was thinking about the same point
... we could also refer to a reference implementation such as node-wot

Zoltan: so when in doubt how to implement, please check node-wot?

Cristiano: yes, something like that: check the spec and the reference implementation

Zoltan: indeed, and implementations should give feedback on the spec and also on node-wot
... I think we should first create tests in node-wot, and then see what can be generalized

Cristiano: should be like an integration test
... I wrote some tests like that on the Java implementation
... of another spec

Daniel: I will check with Ege

Cristiano: while we are implementing the new spec version, we could also think about how to test

Daniel: right

Next calls

Daniel: on August 3 neither Cristiano nor Zoltan is available
... so we skip next week

Zoltan: after August 10 it's fine for me

Daniel: I could give availability later

<scribe> ACTION: Daniel to send email for asking for spec feedback

Daniel: any other business?

adjourned