15:00:02 <RRSAgent> RRSAgent has joined #wot-arch
15:00:03 <RRSAgent> logging to https://www.w3.org/2021/02/04-wot-arch-irc
15:00:38 <mlagally> mlagally has joined #wot-arch
15:02:25 <kaz> meeting: WoT Architecture
15:02:36 <kaz> present+ Kaz_Ashimura, Michael_McCool, Michael_Lagally
15:09:17 <Mizushima> Mizushima has joined #wot-arch
15:11:18 <kaz> present+ Tomoaki_Mizushima
15:12:32 <kaz> scribenick: kaz
15:13:18 <kaz> topic: Agenda
15:13:27 <kaz> ml: terminology discussion is the main topic
15:13:54 <McCool> McCool has joined #wot-arch
15:14:08 <kaz> Agenda: https://www.w3.org/WoT/IG/wiki/WG_WoT_Architecture_WebConf#Jan._28th.2C_2021
15:14:27 <kaz> (almost same as the agenda for last week :)
15:14:52 <kaz> topic: Prev minutes
15:15:05 <kaz> -> https://www.w3.org/2021/01/28-wot-arch-minutes.html Jan-28
15:15:30 <kaz> ml: (goes through the minutes)
15:16:01 <kaz> ... we talked about the APA meeting
15:16:09 <kaz> mm: created an issue about that
15:16:55 <sebastian> sebastian has joined #wot-arch
15:17:59 <kaz> -> https://github.com/w3c/wot-architecture/issues/578 issue 578 - Accessibility considerations of WoT architecture
15:18:23 <ryuichi> ryuichi has joined #wot-arch
15:18:46 <kaz> ml: let's approve the minutes themselves first and then talk about the accessibility topics later
15:18:49 <kaz> mm: ok
15:19:43 <kaz> present+ Ryuichi_Matsukura
15:20:19 <kaz> ... let me go through the APA minutes and pick up several issues from them
15:20:26 <kaz> ml: ok
15:20:38 <kaz> ... (and then goes through the prev Architecture minutes again)
15:21:10 <kaz> mm: there is a link for Discovery within the minutes
15:21:36 <kaz> ml: ok
15:21:55 <kaz> ... I'll take a note
15:22:28 <kaz> ... and then we had discussion on Profile
15:23:24 <kaz> ... max size, max number, etc.
15:23:43 <kaz> mm: we should see what's done for gigbee, etc.
15:23:56 <kaz> ml: yeah, should clarify some reference device
15:24:24 <kaz> ... e.g., a Raspberry Pi and even smaller one
15:24:36 <kaz> s/a //
15:25:14 <kaz> mm: yeah, what is the minimum environment for WoT
15:25:33 <kaz> q+
15:26:17 <kaz> kaz: could be a good topic for the expected liaison with Echonet
15:26:50 <kaz> ml: we need more detailed information on minimum/maximum expectations
15:26:57 <McCool> spec for constrained devices: https://datatracker.ietf.org/doc/rfc7228/
15:27:13 <kaz> ml: any concerns on the minutes?
15:27:26 <kaz> (none)
15:27:28 <kaz> approved
15:27:48 <kaz> topic: Accessibility
15:28:01 <kaz> ml: for Architecture?
15:28:10 <kaz> ... or more related to the other specs?
15:28:56 <kaz> mm: some of the points during the joint call were interesting
15:29:06 <kaz> ... two large categories of use cases
15:29:19 <kaz> ... developer use cases and user use cases
15:29:45 <kaz> ... multiple descriptions for multiple usages
15:30:00 <kaz> ... language negotiation as well
15:30:20 <kaz> ... bunch of developer use cases for home gateway
15:30:29 <kaz> ack k
15:30:31 <kaz> q+
15:31:01 <kaz> ... one idea is put requirements for i18n
15:31:30 <kaz> ... a few more things to be sought out
15:31:44 <kaz> ... metadata added by the directory
15:32:02 <kaz> ... a possible option is making it optional
15:32:33 <kaz> ... minimal requirements for TDs for only some specific languages
15:33:18 <kaz> ml: there are many things to do :)
15:33:38 <kaz> ... canonical representations to be contained
15:33:52 <kaz> mm: progressive approach for spec generation
15:34:03 <kaz> ... already have problem with language negotiation
15:34:36 <kaz> ml: the question in the terms of accessibility...
15:34:49 <kaz> ... what kind of implications there?
15:35:05 <kaz> mm: general idea is allowing progressive disclosure
15:35:20 <kaz> ... privacy would be also to be considered
15:35:36 <kaz> ... proposal on signing as well
15:35:51 <kaz> ... need to have some chained proof
15:36:07 <kaz> ... likewise, canonical forms
15:36:19 <kaz> ... when to do the canonicalization?
15:36:28 <kaz> ... when you compute the sign?
15:36:42 <kaz> ... part of the signing process?
15:37:11 <kaz> ... making it part of the process would be cleaner solution
15:37:37 <kaz> ... do we have things to be put?
15:38:00 <kaz> ml: basically, those are requirements
15:38:35 <kaz> kaz: yeah
15:39:01 <kaz> ... the APA guys mentioned the existing requirements document from their viewpoint
15:39:08 <kaz> ... so we should consider them
15:39:33 <kaz> ... also we should think about requirements for WoT accessibility from our own use cases viewpoint
15:39:36 <kaz> ml: ok
15:40:00 <kaz> ... (visits the wot-usecases repo and create an issue for that direction)
15:41:11 <kaz> -> https://github.com/w3c/wot-usecases/issues/95 wot-usecases issue 95 - Use case to motivate for Integrity Protection Requirement
15:41:35 <kaz> mm: possibly some use cases from the accessibility viewpoint
15:41:43 <kaz> ... e.g., smart city accessibility
15:41:48 <kaz> ml: yeah
15:42:03 <kaz> ... we've asked them to join the use cases calls already
15:42:06 <kaz> mm: right
15:42:33 <kaz> ... to have a 1:1 call would be also useful
15:42:51 <kaz> ... putting the basic ideas into an MD file based on the discussoin
15:43:13 <kaz> ... important to capture their points
15:43:17 <kaz> ml: yeah
15:43:28 <kaz> ... starting with 5-6 headlines
15:43:44 <kaz> q?
15:43:48 <kaz> ack k
15:43:49 <kaz> q+
15:44:32 <kaz> kaz: given the timing, inviting them to the vF2F as well would be also useful
15:44:55 <kaz> ml: let's invite them to the use cases call next week, and then see what should be done next
15:44:58 <kaz> ack k
15:45:12 <kaz> mm: ok
15:45:20 <kaz> ... would send a proposal to them
15:45:29 <kaz> ... starting with a 1:1 first
15:45:35 <kaz> ... then inviting them to the use cases call
15:45:55 <kaz> (and also to the vF2F as well :)
15:46:35 <kaz> ml: we should invite Gyu-Myoung from ITU-T SG20 as well
15:47:28 <kaz> topic: Profile
15:47:52 <kaz> ml: would like to talk about Profile next
15:48:30 <kaz> ... we've been reviewing comments for the FPWD
15:48:50 <kaz> -> https://github.com/w3c/wot-profile/labels/FPWD%20Feedback FPWD feedback for wot-profile
15:49:33 <kaz> ml: at some point, we might want to look into the actual devices, e.g., gateway and others
15:49:51 <kaz> ... we have to pick up typical examples
15:50:02 <McCool> https://datatracker.ietf.org/doc/rfc7228/
15:50:26 <kaz> mm: the above is a document on terminology for constraint devices
15:50:30 <kaz> ... Carsten is involved
15:50:41 <kaz> ... section 3 of the document says...
15:51:27 <kaz> ... classes of constrained devices
15:52:11 <kaz>      | Name        | data size (e.g., RAM) | code size (e.g., Flash) |
15:52:11 <kaz>      +-------------+-----------------------+-------------------------+
15:52:11 <kaz>      | Class 0, C0 | << 10 KiB             | << 100 KiB              |
15:52:11 <kaz>      |             |                       |                         |
15:52:12 <kaz>      | Class 1, C1 | ~ 10 KiB              | ~ 100 KiB               |
15:52:12 <kaz>      |             |                       |                         |
15:52:14 <kaz>      | Class 2, C2 | ~ 50 KiB              | ~ 250 KiB               |
15:52:50 <kaz> ml: would like to exclude class 0 and 1 here...
15:53:14 <kaz> s/here.../for WoT, though./
15:53:44 <kaz> mm: class 0 is almost some kind of controller
15:54:14 <kaz> ... don't see our classes would fit gateway devices
15:54:33 <kaz> ... so our expected devices to be added to this class definition
15:54:41 <kaz> ml: we could extend this class table
15:54:55 <kaz> mm: we could define class N
15:55:17 <kaz> ... additional definitions based on this table
15:55:55 <kaz> ml: what if we want to have a minimum class for HTTP connection
15:56:01 <kaz> s/connection/connection?/
15:56:19 <kaz> mm: pretty small devices can also handle HTTP connection these days
15:58:54 <kaz> ml: (searches for information on several small circuit boards)
16:00:02 <kaz> ... why don't we make the following our assumption...
16:00:20 <kaz> 448kb ROM, 520kb SRAM
16:00:30 <kaz> s/448/... 448/
16:00:42 <kaz> ... maybe we would be smaller later
16:00:50 <kaz> s/smaller/even smaller/
16:01:04 <kaz> ... but let's start with this
16:02:30 <kaz> mm: we should clarify our aspects too
16:02:45 <kaz> ... directly supporting WoT capability or not, etc.
16:03:15 <kaz> ... should we define a hub for predefined devices?
16:03:39 <kaz> ... should avoid a hub for small devices
16:03:59 <kaz> ... but should think about the WoT native devices
16:04:09 <kaz> ml: let me capture the discussion as a GitHub issue
16:06:27 <kaz> ... define a minimum device which can run a TCP/HTTP stack and consume/expose TDs
16:06:48 <kaz> ... working assumption: 512KB RAM / 512KB Frash
16:07:03 <kaz> ... this has been proven to be enough to produce TDs
16:07:29 <kaz> mm: we can also ask Fraunhofer and Mozilla about their devices
16:07:32 <kaz> ml: right
16:08:56 <kaz> mm: maybe our first class would have simple consumers/producers
16:09:19 <kaz> ml: which just consume a single TD
16:10:23 <McCool> https://www.juniper.net/documentation/en_US/nfv2.1/topics/reference/ccpe-servers-hardware-spec.html
16:10:30 <kaz> mm: should think about minimum memory requirements for Node.js, etc., too
16:11:43 <kaz> ... e.g., 260MB would be enough for cloud connection
16:11:58 <kaz> s/https/-> https/
16:12:19 <kaz> s/html/html minimum hardware requirements for node servers and servers
16:13:32 <kaz> ml: (adds that information to a GitHub issue for wot-profile)
16:14:00 <kaz> ... node.js requirement >64MB up to 256MB
16:15:06 <kaz> ... let me record the URLs of the related resources here
16:15:56 <kaz>                Terminology for Constrained-Node Networks
16:16:32 <kaz> s/               //
16:16:44 <kaz> s/Ter/e.g., Ter/
16:17:04 <kaz> ... (updates his comments on the GitHub issue)
16:18:28 <kaz> present+ Michael_Koster
16:18:39 <kaz> mk: possibly just process partial TD?
16:18:58 <kaz> ... you can get a form back
16:19:26 <kaz> mm: yeah
16:19:47 <kaz> ... directory service server might be smaller
16:20:59 <kaz> ml: a possible use case
16:21:28 <kaz> ... for single TD processor
16:21:36 <mjk> mjk has joined #wot-arch
16:22:12 <kaz> ... extracting pieces of the information from a single TD
16:22:42 <kaz> ... (adds descriptions on "Producer" and "Consumer" to the GitHub comment)
16:23:13 <kaz> mm: btw, until when can we have the discussion today?
16:23:23 <kaz> ml: need to leave in 7 mins...
16:23:51 <kaz> ... is this updated assumption reasonable for you?
16:24:04 <kaz> ... 512KB RAM / 512KB Flash
16:24:20 <kaz> mizu: no idea at the moment...
16:24:57 <kaz> mk: need to look into the recent situation with low-end devices
16:26:57 <kaz> ml: for the moment, let's think about 256KB RAM instead of 512KB
16:27:29 <kaz> ... note we need TCP / HTTP connection, and also Node capability
16:28:10 <kaz> mk: possibly TD got from a storage?
16:28:14 <kaz> ml: yeah
16:28:34 <kaz> q+
16:29:41 <kaz> kaz: thought these days even vending machines and electric power meters have those capability
16:29:58 <kaz> ... would see requirements for devices, e.g., by Echonet
16:30:03 <kaz> ml: yeah, would see
16:30:42 <kaz> topic: AOB
16:31:04 <kaz> mm: have not got any concrete definition for "fragments", etc., yet
16:31:07 <kaz> ml: ok
16:31:28 <kaz> mk: btw, is there anybody working on embedded WoT?
16:31:59 <kaz> kaz: we can ask Siemens guys as well
16:32:26 <kaz> ml: we should talk about that during the PlugFest calls as well
16:32:30 <kaz> [adjourned]
16:32:34 <kaz> rrsagent, make log public
16:32:40 <kaz> rrsagent, draft minutes
16:32:40 <RRSAgent> I have made the request to generate https://www.w3.org/2021/02/04-wot-arch-minutes.html kaz
16:33:25 <kaz> i|AOB|-> https://github.com/w3c/wot-profile/issues/68 resulted issue 68 for wot-profile|