15:00:24 <RRSAgent> RRSAgent has joined #wot-arch
15:00:24 <RRSAgent> logging to https://www.w3.org/2021/03/11-wot-arch-irc
15:01:15 <kaz> Meeting: WoT Architecture
15:01:33 <kaz> present+ Kaz_Ashimura
15:02:16 <kaz> Agenda: https://www.w3.org/WoT/IG/wiki/WG_WoT_Architecture_WebConf#March_11th.2C_2021
15:02:50 <mlagally> mlagally has joined #wot-arch
15:03:00 <sebastian> sebastian has joined #wot-arch
15:04:56 <kaz> present+ Daniel_Peintner, Michael_Lagally
15:05:21 <kaz> regrets+ Michael_McCool
15:05:46 <Mizushima> Mizushima has joined #wot-arch
15:06:20 <kaz> present+ Sebastian_Kaebisch
15:07:09 <dape> dape has joined #wot-arch
15:08:27 <kaz> present+ Michael_Koster
15:08:41 <kaz> present+ Tomoaki_Mizushima
15:08:53 <mjk> mjk has joined #wot-arch
15:10:18 <kaz> zakim, pick a scribe
15:10:18 <Zakim> Not knowing who is chairing or who scribed recently, I propose Michael_Lagally
15:10:29 <kaz> zakim, pick a scribe
15:10:29 <Zakim> Not knowing who is chairing or who scribed recently, I propose Michael_Koster
15:11:24 <kaz> scribenick: mjk
15:11:29 <mjk> topic: agenda bashing
15:11:42 <kaz> -> https://www.w3.org/WoT/IG/wiki/WG_WoT_Architecture_WebConf#March_11th.2C_2021 Agenda
15:12:02 <mjk> ml: copy/paste from last meeting
15:13:14 <mjk> ...any other agenda items?
15:13:56 <mjk> sk: discussion on the new device profile issue#1771
15:15:02 <kaz> s/1771/71/
15:15:35 <kaz> topic: minutes
15:15:39 <kaz> -> https://www.w3.org/2021/03/04-wot-arch-minutes.html Mar-4
15:16:32 <mjk> ml: minutes approved
15:16:43 <mjk> topic: reference design
15:17:32 <kaz> -> https://github.com/w3c/wot-profile/issues/68 Issue 68 - Reference Device Definition for the smallest possible platform for HTTP / TCP / JSON
15:17:49 <mjk> ml: reviewing the discussion on the issue
15:18:22 <mjk> ml: assuming http, tls, and JSON
15:18:41 <mjk> ... assuming consume-only, what are the constraints?
15:19:17 <mjk> dape: there is also some work from Zoltan
15:20:00 <mjk> ml: there are a lot of details in the record
15:21:36 <mjk> ... 16K is a common size
15:22:22 <mjk> sk: what is a realistic size based on devices and consumer expectations
15:22:43 <mjk> ... using ESP module as an example device
15:23:39 <mjk> ... devices will have a specific purpose and know what kind of model it consumes
15:24:22 <mjk> ... the client will follow a specific information model
15:24:43 <citrullin> citrullin has joined #wot-arch
15:24:52 <mjk> ... what kind of constrained consumers are there in the plugfest?
15:24:53 <kaz> q+
15:25:04 <mjk> ml: maybe there weren't any
15:25:10 <kaz> present+ Philipp_Blum
15:25:22 <mjk> sk: not aware of any embedded TD consumers
15:25:53 <mjk> ml: so we could assume embedded devices use a built-in information model
15:26:24 <mjk> ml: reviewing use cases from issue #71
15:26:54 <mjk> ... Ben Francis comments from the last few days
15:26:56 <kaz> -> https://github.com/w3c/wot-profile/issues/71#issuecomment-792782567 Ben's comments
15:27:45 <mjk> sk: there is also a goal to find out how small devices can run HTTP, TLS, JSON
15:28:19 <mjk> ml: hesitate to get into the protocols, but we do make the assumptions about HTTP TLS, JSON
15:29:22 <mjk> ml: a lot of the platforms are embedded PC/linux class
15:30:36 <mjk> sk: characteristics of producers and consumers of TDs are independent of scale, could have only one or two features
15:30:43 <kaz> q?
15:32:01 <mjk> sk: the example platforms are all general purpose and can consume any TD
15:33:04 <mjk> ... constrained device consumers will only be looking for a limited set of features
15:33:17 <mjk> ... based on the device purpose
15:34:07 <mjk> ... then at the other end of the scale, embedded linux/PC there will be potentially very large TDs
15:34:29 <mjk> ml: I understand the point
15:34:31 <mlagally> q?
15:35:40 <dape> q+
15:36:06 <mjk> kaz: maybe we should consider the use cases without itermediariess
15:36:22 <mjk> s/ariess/aries
15:36:32 <kaz> s/ite/inte/
15:37:00 <mjk> dape: what is the consequence of not having the hard limits?
15:37:21 <kaz> s/intermediaries/intermediaries as the starting point, but would suggest we think about intermediary as well for the 2nd step for the use case scenarios/
15:37:36 <kaz> ack k
15:37:40 <kaz> ack d
15:37:59 <mjk> ml: there could be TDs that can't be processed on some devices
15:38:36 <mjk> dape: imposing the limit doesn't change the situation with the small device
15:38:42 <dape> ack dape
15:39:03 <mjk> sk: this seems to be a generic problem with the device being too small for the expected application
15:39:04 <kaz> s/without intermediaries/without intermediaries and concentrate on Things and Consumers/
15:39:23 <kaz> q?
15:39:48 <mjk> philip: TDs need to be validated and we don't know how to stream and validate TDs
15:39:58 <kaz> s/philip/philipp/
15:40:05 <mjk> sk: do we need to validate TDs on small devices?
15:40:35 <mjk> (thx kaz)
15:41:21 <mjk> m: assuming yes, you need to parse and validate
15:41:28 <mjk> s/m:/ml:
15:42:13 <mjk> ml: it may take separate passes but it needs to fit in the buffer
15:42:58 <mjk> ml: if the TD doesn't fit in the buffer, can you consume such a complex TD?
15:43:30 <citrullin> q+
15:44:38 <mjk> philipp: also prefer to not restrict the size, what about using a directory as a helper
15:44:55 <mjk> ml: we want to avoid needing any intermediaries
15:44:58 <sebastian> q+
15:45:02 <sebastian> ack ci
15:45:57 <mjk> ml: we need to restrict the TD size if we want to consume TDs on small devices
15:47:17 <mjk> sk: +1 the idea of an external helper that can work with client queries
15:47:52 <mjk> ... the client doesn't know what to do with most of the unrelated TD content
15:48:31 <mjk> ml: will the client ask the directory to limit the size of the TD?
15:49:16 <mjk> sk: more like it will only return the functions requested
15:50:05 <mjk> mjk: sometimes the client only needs the form that satisfies the interaction requested in a query
15:50:49 <mjk> ml: ideally all devices communicate with each other
15:51:14 <dape> q+
15:51:27 <mjk> sk: practically there will be some service point for queries and serving TDs, there is no peer to peer IoT today
15:51:32 <sebastian> ack se
15:51:51 <mjk> ml: so there may always be a gateway in our assumption
15:52:41 <mjk> ml: 2 classes of devices, small devices are not consumers
15:52:57 <kaz> (that's why I suggested we include intermediary for the next step :)
15:53:17 <kaz> q?
15:53:25 <kaz> ack d
15:53:45 <kaz> q+
15:53:52 <mjk> sk: there is always an assumption that there are bigger devices in the system
15:54:20 <mjk> dape: how does it help small devices to consume large TDs?
15:55:02 <mjk> mjk: maybe the directory could just return the form
15:55:24 <mjk> sk: you don't need to provide the full TD to the small device that knows what it wants to do
15:55:26 <kaz> (yeah, that's why I brought partial TD topic to the Discovery call on March 8 :)
15:55:29 <citrullin> +1 on partial TDs in directories
15:55:56 <kaz> q?
15:55:57 <mjk> ml: why couldn't the TD producer also do this filtering?
15:56:06 <mjk> sk: it could if we define it
15:56:55 <mjk> ml: to address dape, we can define graceful failure modes
15:58:00 <mjk> kaz: need to think about all entities, device, intermediary, consumer, directory, as a system
15:58:10 <mjk> mjk: need to drop now
15:58:17 <kaz> scribenick: kaz
15:58:19 <kaz> ml: right
15:58:43 <kaz> ... Ben also suggested we think about gateway
15:59:24 <kaz> ... if some of the entity handles TD, that guy need to be qualified to handle the TD
16:00:13 <kaz> ... some kind of guidelines or restrictions to be provided
16:00:27 <kaz> (Koster and Daniel leave)
16:01:26 <kaz> sk: if the TD with some specific size or bigger size which exceed the processable size of the entity, need some guideline
16:02:21 <kaz> ... good to see feedback from the scripting/discovery guys
16:02:53 <kaz> ml: (adds a comment)
16:03:08 <kaz> ... a consumer on a constrained device can check if it can proces the TD
16:03:12 <kaz> s/proces/process/
16:03:22 <mlagally> q?
16:03:24 <kaz> ... or get a partial TD when otherwise
16:04:06 <kaz> ... the size would be too large
16:04:41 <kaz> kaz: I already asked the scripting/discovery guys for opinions on Monday
16:04:56 <kaz> ... and they also wanted to know about concrete use case scenarios
16:05:01 <sebastian> I have to go...
16:05:16 <kaz> kaz: so this discussion today is going for the right direction :)
16:05:25 <kaz> s/I have to go.../(Sebastian leaves)
16:06:08 <kaz> topic: vF2F agenda
16:06:51 <kaz> -> https://www.w3.org/WoT/IG/wiki/F2F_meeting,_March_2021#Monday_March_22 Architecture day - Monday, March 22
16:07:32 <kaz> ml: (goes through the draft agenda)
16:08:00 <kaz> ... introductions
16:08:08 <kaz> ... terminology
16:08:16 <kaz> ... partial TD
16:08:39 <kaz> ... based on the input from the Discovery/Scripting TFs
16:08:55 <kaz> ... TD validation
16:09:05 <kaz> ... based on the input from the TD TF
16:09:08 <kaz> ... framing
16:09:21 <kaz> ... need inputs/proposals from the Discovery TF
16:09:28 <kaz> ... then ITU-T liaison
16:10:08 <kaz> ... that is not really an Architecture topic but a Use Case topic
16:10:45 <kaz> ... (put "ITU-T liaison" at the beginning of March 22 agenda)
16:11:16 <kaz> rrsagent, make log public
16:11:21 <kaz> rrsagent, draft minutes
16:11:21 <RRSAgent> I have made the request to generate https://www.w3.org/2021/03/11-wot-arch-minutes.html kaz
16:11:35 <kaz> zakim, who is on the call?
16:11:35 <Zakim> Present: Kaz_Ashimura, Daniel_Peintner, Michael_Lagally, Sebastian_Kaebisch, Michael_Koster, Tomoaki_Mizushima, Philipp_Blum
16:12:23 <kaz> ml: (puts the ITU-T use case summary MD to the agenda)
16:12:58 <kaz> @@
16:13:20 <kaz> ml: (and then put "30 mins" for the use cases session)
16:13:50 <kaz> ... (also "2h 20mins" to the architecture session)
16:14:14 <kaz> ... there are many architecture issues on GitHub
16:15:07 <kaz> ... 40 issues including the ones labeled with "terminology", "lifecycle", "discovery", etc.
16:15:27 <kaz> ... let's talk about discovery issues and accessibility issues
16:15:56 <kaz> ... (adds links for those issues to the agenda)
16:17:44 <kaz> s|@@|-> https://github.com/w3c/wot-usecases/blob/main/CONTRIBUTIONS/ITU-T-Use-case-summary.md ITU-T use case summary
16:18:40 <kaz> ml: (categorizes the agenda topics into "Discovery", Accessibility" and "Optional")
16:20:54 <kaz> ... (puts "10mins" to each sub sections of "Terminology", "Discovery" and "Accessibility")
16:21:14 <kaz> kaz: wondering if "10mins" for each topic would be really enough...
16:21:47 <kaz> pb: yeah, e.g., "partial TD" would take longer
16:21:53 <kaz> kaz: yeah, possibly
16:22:22 <kaz> mizu: btw, maybe we should check the diff between the FPWD and the current draft?
16:23:18 <kaz> kaz: maybe that could be summarized during the introduction session at the beginning
16:23:32 <kaz> ml: yeah, would include that point into the introduction
16:24:09 <kaz> ... regarding the time assignment, would give 20mins for Discovery collaboration
16:24:19 <kaz> pb: how many issues are there?
16:24:33 <kaz> s/there/there for "Terminology"/
16:26:41 <kaz> (12 terminology issues there)
16:26:51 <kaz> -> https://github.com/w3c/wot-architecture/labels/terminology terminology issues
16:27:20 <kaz> -> https://github.com/w3c/wot-architecture/pull/582 and PR 582 - WIP: Terminology update
16:28:35 <kaz> ml: (adds edits for the Profile session)
16:28:52 <kaz> ... device categolies and use cases
16:28:59 <kaz> ... canonicalization
16:30:10 <kaz> ... continue review/discussion of FPWD feedback
16:31:11 <kaz> s|... continue review/discussion of FPWD feedback|decision: one or multiple profiles?|
16:31:18 <kaz> ... proposed constraints
16:32:42 <kaz> ... (and assign some initial time to each topic)
16:37:14 <kaz> -> https://www.w3.org/WoT/IG/wiki/F2F_meeting,_March_2021#Monday_March_22 updated agenda for March 22
16:37:17 <kaz> [adjourned]
16:37:23 <kaz> rrsagent, make log public
16:37:27 <kaz> rrsagent, draft minutes
16:37:27 <RRSAgent> I have made the request to generate https://www.w3.org/2021/03/11-wot-arch-minutes.html kaz
18:31:21 <Zakim> Zakim has left #wot-arch