15:06:09 <RRSAgent> RRSAgent has joined #wot-arch
15:06:09 <RRSAgent> logging to https://www.w3.org/2021/01/28-wot-arch-irc
15:06:21 <Mizushima> Mizushima has joined #wot-arch
15:06:21 <kaz> Meeting: WoT Architecture
15:06:39 <kaz> present+ Kaz_Ashimura, Daniel_Peintner, Michael_Laglly, Michael_McCool
15:06:49 <kaz> Chair: Lagally
15:07:28 <kaz> Agenda: https://www.w3.org/WoT/IG/wiki/WG_WoT_Architecture_WebConf#Jan._28th.2C_2021
15:10:00 <kaz> present+ Tomoaki_Mizushima, Michael_Koster
15:10:12 <kaz> topic: Agenda
15:10:30 <kaz> -> https://www.w3.org/WoT/IG/wiki/WG_WoT_Architecture_WebConf#Jan._28th.2C_2021 proposed agenda
15:10:42 <kaz> ml: terminology discussion, etc.
15:10:55 <kaz> mm: would like to briefly report back from the APA call
15:11:18 <kaz> present+ Cristiano_Aguzzi
15:11:39 <kaz> topic: APA report
15:11:43 <cris> cris has joined #wot-arch
15:11:50 <kaz> @@minutes
15:12:10 <kaz> mm: kind of related to the discussion on the "human readable information"
15:12:33 <kaz> ... also discovery on progressive disclosure
15:13:00 <kaz> ... related to limited bandwidth of UDP
15:13:13 <kaz> s|@@minutes|-> https://www.w3.org/2021/01/27-rqtf-minutes.html APA joint minutes|
15:13:30 <kaz> mm: accessibility for the end users and the developers
15:13:46 <kaz> ... could select your purposes
15:14:00 <kaz> ml: sounds like we need discussions on requirements
15:14:12 <kaz> mm: would put them together
15:14:23 <kaz> ... related to discovery, etc.
15:14:27 <benfrancis> (Apologies I can't make the architecture call today due to a conflict)
15:14:29 <kaz> ... so how to write up them?
15:14:52 <kaz> ... maybe need documentation for horizontal use cases
15:14:54 <kaz> +1
15:15:07 <kaz> mm: could you please create an issue?
15:15:13 <kaz> ... or I can do it right now
15:15:15 <kaz> ml: good
15:15:28 <kaz> s/... so how/mm: so how/
15:15:30 <kaz> q?
15:15:35 <kaz> topic: Prev minutes
15:15:51 <kaz> -> https://www.w3.org/2021/01/21-wot-arch-minutes.html Jan-21
15:15:57 <kaz> ml: (goes through the minutes)
15:16:14 <kaz> ... FPWD feedback for wot-profile
15:16:34 <kaz> ... made a resolution on the common data model
15:17:05 <kaz> regrets+ Ben_Francis
15:17:14 <kaz> zakim, who is on th call?
15:17:14 <Zakim> I don't understand your question, kaz.
15:17:29 <kaz> ml: any problems with the minutes?
15:17:31 <kaz> (none)
15:17:34 <kaz> approved
15:17:46 <kaz> s/zakim, who is on th call?//
15:17:51 <kaz> zakim, who is on th call?
15:17:51 <Zakim> I don't understand your question, kaz.
15:17:54 <kaz> zakim, who is on the call?
15:17:54 <Zakim> Present: Kaz_Ashimura, Daniel_Peintner, Michael_Laglly, Michael_McCool, Tomoaki_Mizushima, Michael_Koster, Cristiano_Aguzzi
15:17:56 <kaz> s/zakim, who is on th call?//
15:18:49 <kaz> topic: WoT Architecture terminology - Partial TD
15:19:23 <kaz> -> https://github.com/w3c/wot-architecture/pull/576 PR 576
15:19:35 <McCool> (move earlier) documentation issue created: https://github.com/w3c/wot-usecases/issues/93
15:19:44 <kaz> ml: first of all, changes from the FPWD
15:19:48 <kaz> ... merged
15:19:58 <kaz> ... then "Partial TD" definition
15:20:26 <kaz> -> https://github.com/w3c/wot-architecture/pull/577 PR 577 - Partial TD definition
15:20:54 <kaz> q+
15:21:27 <kaz> mm: partial TD can omit some of the TD mandatory elements
15:22:31 <kaz> kaz: we should clarify which part could be omitted
15:22:41 <kaz> ... based on our purposes and should show examples
15:22:56 <McCool> q+
15:23:00 <kaz> ack k
15:23:02 <kaz> ack m
15:23:09 <kaz> mm: right
15:23:26 <kaz> ca: there is some example from the scripting api draft at the bottom
15:23:43 <kaz> mk: partial TD doesn't validate a Thing
15:24:02 <kaz> ... should provide some validation mechanism for them
15:24:11 <kaz> kaz: yeah
15:24:44 <kaz> ml: that would be a request for the Scripting API
15:25:08 <cris> q+
15:25:17 <kaz> ... would propose we merge this PR 577 itself, and then add further improvement later
15:25:20 <kaz> ack c
15:25:34 <kaz> ca: do we have any other use cases for "partial TD" ?
15:25:41 <kaz> q+
15:25:43 <McCool> q+
15:25:54 <kaz> q-
15:26:13 <kaz> ml: we'd like to know what is the actual use case of the Scripting API as well :)
15:26:16 <kaz> kaz: +1
15:26:37 <kaz> mm: some TD based on the fragment as well
15:27:11 <kaz> ... btw, what about the "TD fragment"?
15:27:22 <kaz> ml: let's close this PR for "partial TD" first :)
15:27:26 <kaz> mm: ok
15:27:41 <kaz> ml: (merged it)
15:28:38 <kaz> ... (then visit the merged definition within the wot-architecture/index.html)
15:28:51 <kaz> ... (and add some tweaks)
15:29:04 <kaz> .... "it is not required to contain all the mandatory elements"
15:29:22 <kaz> ... "an example usage of a partial td is in..."
15:30:19 <kaz> topic: Architecture - TD fragment
15:30:30 <kaz> ml: do we have any definition for "TD fragment"?
15:30:49 <kaz> mm: could do a PR right now for discussion...
15:31:05 <kaz> ... would mention discovery use cases
15:32:21 <kaz> mm: fragment doesn't have concrete structure
15:32:52 <kaz> ml: do we have any concrete definition?
15:33:09 <kaz> mm: valid JSON corresponds to internal elements of the TD model
15:33:28 <kaz> mk: we can talk about SHAPES as well
15:34:22 <mlagally> https://github.com/w3c/wot-architecture/issues/453
15:34:32 <kaz> mm: there is some definition within the comments in Issue 453
15:34:44 <kaz> -> https://github.com/w3c/wot-architecture/issues/453#issuecomment-760290680 the comment within Issue 453
15:34:58 <kaz> [[
15:34:59 <kaz> TD Fragment =
15:34:59 <kaz> substructure of the data model of a TD.
15:34:59 <kaz> It is a valid object structure that can be validated syntactically against the TD datamodel defined in chapter 5 of the TD spec, however im may omit some context that allows full validation.
15:35:00 <kaz> Note: In JSON represention it must be a valid JSON however could be just an inner structure omitting outer elements, curly braces etc. As a use case the TD fragment is useful for Discovery results returned by a JSON-Path query.
15:35:02 <kaz> Todo: McCool to provide a link to the Discovery spec
15:35:04 <kaz> ]]
15:35:22 <kaz> (some more discussions)
15:36:31 <kaz> mm: adding a link to the discovery spec is easy
15:36:37 <kaz> ml: let's start with this
15:36:59 <cris> q+
15:37:02 <kaz> ... (add tweaks to wot-architecture/index.html for that purpose)
15:37:07 <kaz> ack m
15:37:56 <kaz> cris: thinking about if it's TD fragment is a kind of TD
15:38:14 <McCool> we should use this to refer to WoT Discovery.  But also, a direct URL is not a good idea, it should be a reference (and Scripting ref in Partial TD should also be a reference)
15:38:17 <McCool> https://www.w3.org/TR/wot-discovery/
15:38:35 <kaz> cris: if we're talking about discovery that should be a TD
15:38:57 <kaz> (some more discussions)
15:39:34 <kaz> q+
15:39:38 <kaz> ack c
15:40:12 <kaz> mm: one requirement is validation method by JSON Schema, etc.
15:41:04 <kaz> ml: (adds some more tweaks to the definition of "TD Fragments")
15:41:17 <kaz> mm: gave a comment on reference above
15:41:33 <kaz> ... and chapter title of the specs to be mentioned there
15:41:43 <kaz> ml: ok
15:42:08 <kaz> ... (reads the initial definition within wot-architecture/index.html)
15:42:51 <kaz> s/above/above (@@move McCool's comment here)/
15:44:42 <kaz> -> https://www.google.com/search?q=json%20fragment Google search results for "JSON fragment"
15:45:13 <kaz> [[
15:45:14 <kaz> A JSON fragment is a JSON that does not have an Object or an Array as the root. If you do need the ability to encode JSON Fragments, you can change the jsonString function to handle the fragment cases in a different way: The function now encodes JSON fragments as simple strings.
15:45:15 <kaz> ]]
15:45:51 <kaz> kaz: maybe we can borrow part of the definition of "JSON Fragment" as well, can't we?
15:45:56 <kaz> mm: interesting
15:46:10 <kaz> ml: let's close this edit here on wot-architecture/index.html
15:46:13 <kaz> kaz: ok
15:47:16 <kaz> ml: (creating a pullrequest based on the discussion so far)
15:47:49 <kaz> ... adding "TD Fragment" definition as proposed in arch call 2 weeks ago...
15:48:12 <kaz> ... kaz, you might want to create an issue for the "JSON Fragment" definition part
15:48:14 <kaz> kaz: ok
15:48:29 <kaz> -> https://github.com/w3c/wot-architecture/pull/579 resulted PR 579
15:49:25 <kaz> topic: WoT Profile - Max nesting of elements
15:49:33 <kaz> -> https://github.com/w3c/wot-profile/pull/65 wot-profile PR 65
15:49:44 <kaz> ml: (visits the preview)
15:49:58 <kaz> -> https://pr-preview.s3.amazonaws.com/w3c/wot-profile/pull/65.html preview
15:50:04 <kaz> ml: ok to merge it?
15:50:07 <kaz> (no objections)
15:50:10 <kaz> merged
15:50:50 <kaz> topic: WoT Profile - Max size of a Profile-compliant
15:51:03 <kaz> -> https://github.com/w3c/wot-profile/issues/66 wot-profile Issue 66
15:51:52 <mjk> mjk has joined #wot-arch
15:51:55 <mjk> q?
15:51:57 <kaz> ml: 65000 bytes as the limit?
15:52:09 <kaz> cris: was also thinking about 60000 bytes or so
15:52:25 <kaz> q+
15:52:52 <kaz> mm: 32000 could be also enouh
15:52:58 <kaz> s/enouh/enough/
15:55:53 <kaz> kaz: would be better to provide a mechanism to change the limit
15:56:07 <kaz> ... I'm OK with putting 32k or 64k as the default limit value, though
15:56:24 <McCool> q+
15:56:27 <kaz> ack k
15:58:39 <McCool> ack m
15:58:53 <McCool> q+
16:00:49 <kaz> ... some small devices could have less than 32k-byte memory
16:01:07 <kaz> ml: it would require more than 32k-byte memory to process TD
16:01:12 <cris> q+
16:01:43 <McCool> ack m
16:01:49 <kaz> kaz: I'm not sure if 32k-byte memory is the unique threshold...
16:01:56 <McCool> q+
16:02:28 <kaz> ml: (adds a note: smaller devices don't ned to buffer the entire TD but just can pares it sequentially with a much smaller buffer.)
16:03:00 <kaz> cris: a Thing Directory might accept only a limited size of TD
16:03:05 <mjk> q+
16:03:13 <kaz> ack c
16:03:16 <kaz> ack mc
16:03:36 <kaz> mm: always should be user-configurable
16:04:04 <kaz> ... one option is accepting only a core profile
16:04:21 <kaz> mjk: we don't really have a future view
16:04:38 <kaz> ... one possibility is having a link
16:04:59 <kaz> q?
16:05:01 <kaz> q+
16:05:09 <McCool> q+
16:05:20 <kaz> ... a simple TD might be smaller than 32k
16:05:39 <McCool> ack mjk
16:06:29 <kaz> kaz: maybe I should have been clearer
16:06:55 <kaz> ... for the "core profile" or anything for smaller devices, having 32k or 64k as the limit is fine
16:07:25 <mjk> q?
16:07:33 <kaz> ... but the TD itself should have a capability to define the limit and the limit value for the "core profile" could be 32 or 64
16:07:35 <kaz> ack k
16:07:42 <McCool> ack m
16:08:17 <kaz> ml: would suggest we continue the discussion on this issue 66 on GitHub
16:08:28 <kaz> ... and revisit it next week
16:09:00 <kaz> topic: WoT Profile - Max number of objects
16:09:11 <kaz> -> https://github.com/w3c/wot-profile/issues/67 wot-profile Issue 67
16:09:21 <kaz> zakim, who is on the call?
16:09:21 <Zakim> Present: Kaz_Ashimura, Daniel_Peintner, Michael_Laglly, Michael_McCool, Tomoaki_Mizushima, Michael_Koster, Cristiano_Aguzzi
16:09:33 <kaz> present+ Ege_Korkan
16:10:01 <mjk> q?
16:10:27 <kaz> mjk: do you have any concrete number in you mind?
16:10:39 <kaz> ml: maybe around 200-300
16:10:50 <kaz> q+
16:11:05 <kaz> ml: what did we see during the PlugFests?
16:11:15 <kaz> ek: we expose the devices
16:11:27 <mjk> q+
16:11:34 <kaz> ... rarely see more than 10
16:11:54 <kaz> s/10/10 properties and actions/
16:12:07 <kaz> ... but the total number is not problematic
16:12:31 <kaz> ml: are you talking about the range?
16:12:39 <kaz> ... e.g., 10-30?
16:12:45 <mjk> q?
16:12:48 <kaz> ca: was also thinking about that
16:13:17 <kaz> ... the range of 10-30 is fine
16:14:43 <Ege> Ege has joined #wot-arch
16:14:47 <kaz> kaz: if the restricted device can process the objects one by one, maybe multiple objects can be also processed
16:15:03 <Ege> an example can be this popular RPi HAT: https://pythonhosted.org/sense-hat/api/#sense-hat-api-reference
16:15:11 <kaz> ... so we should consider "maximum number to be processed at once" as well
16:15:21 <kaz> ml: ok
16:16:20 <kaz> kaz: of course I can agree to have a "recommended number", though :)
16:16:37 <kaz> mjk: discussion by zigbee as well
16:16:56 <kaz> ... typical zigbee cluster has 20-30 affordances
16:17:19 <kaz> ... may have a bunch of messages (e.g., hundred of)
16:17:36 <kaz> ... modbus devices have 128 registries
16:18:06 <kaz> ... 200-300 would make sense
16:18:10 <kaz> ml: maybe 256?
16:18:28 <kaz> ... or 250?
16:19:10 <kaz> q?
16:19:12 <kaz> ack k
16:19:14 <kaz> ack mj
16:19:47 <kaz> mjk: a little bit cautious...
16:20:29 <kaz> q+
16:20:49 <kaz> ml: where is this limit to be considered?
16:21:30 <kaz> ... we're talking about some microchip
16:22:35 <kaz> ... why don't we pick some reference device
16:22:51 <kaz> q?
16:23:36 <kaz> ... e.g., Arm Cortex MO with 16k RAM
16:24:28 <kaz> kaz: +1
16:24:29 <mjk> ack mjk
16:24:42 <kaz> ... we should clarify what device to be considered here
16:24:50 <kaz> ... e.g., TV set or vending machine
16:24:52 <kaz> ack k
16:24:58 <kaz> ml: yeah
16:25:17 <kaz> ... we don't have to put everything on the memory, though
16:26:23 <kaz> ml: can get rough estimate of the data size as well
16:26:33 <kaz> ... 8 bytes for name, 8bytes for value
16:27:05 <kaz> ... 2048/(8+8) = 128 elements, possibly
16:27:23 <kaz> -> https://github.com/w3c/wot-profile/issues/67#issuecomment-769204617 updated comments to Issue 67
16:27:42 <kaz> rrsagent, make log public
16:27:51 <kaz> rrsagent, draft minutes
16:27:51 <RRSAgent> I have made the request to generate https://www.w3.org/2021/01/28-wot-arch-minutes.html kaz
16:28:16 <kaz> topic: WoT Profile - Events are loosely constrained
16:28:33 <kaz> -> https://github.com/w3c/wot-profile/issues/67 wot-profile Issue 67
16:28:42 <kaz> s/67/42/
16:28:46 <kaz> s/67/42/
16:28:53 <kaz> ml: let's talk about this issue next week
16:28:58 <kaz> ek: ok
16:29:08 <kaz> ml: need to close the call now today...
16:29:36 <kaz> ... if anybody has any concrete idea on PlugFest TDs, please let me know
16:29:40 <kaz> [adjourned]
16:29:47 <kaz> rrsagent, draft minutes
16:29:47 <RRSAgent> I have made the request to generate https://www.w3.org/2021/01/28-wot-arch-minutes.html kaz
18:25:21 <Zakim> Zakim has left #wot-arch