01:45:56 <RRSAgent> RRSAgent has joined #edge-computing
01:45:56 <RRSAgent> logging to https://www.w3.org/2019/09/18-edge-computing-irc
01:45:59 <koalie> RRSAgent, make logs public
01:46:01 <koalie> koalie has changed the topic to: https://w3c.github.io/tpac-breakouts/sessions.html
01:46:06 <koalie> koalie has left #edge-computing
01:58:47 <shimazu> shimazu has joined #edge-computing
02:02:00 <yoshiaki> yoshiaki has joined #edge-computing
02:34:02 <yoshiaki_> yoshiaki_ has joined #edge-computing
02:45:07 <yoshiaki> yoshiaki has joined #edge-computing
02:52:05 <yoshiaki> yoshiaki has joined #edge-computing
03:01:59 <shimazu> shimazu has joined #edge-computing
03:59:59 <yoshiaki> yoshiaki has joined #edge-computing
04:31:41 <yoshiaki> yoshiaki has joined #edge-computing
04:34:44 <shimazu> shimazu has joined #edge-computing
05:16:45 <shimazu> shimazu has joined #edge-computing
05:17:38 <yoshiaki> yoshiaki has joined #edge-computing
05:34:23 <yoshiaki_> yoshiaki_ has joined #edge-computing
05:35:00 <yoshiaki_> yoshiaki_ has joined #edge-computing
05:36:44 <shimazu> shimazu has joined #edge-computing
05:41:16 <yoshiaki> yoshiaki has joined #edge-computing
05:43:29 <yoshiaki_> yoshiaki_ has joined #edge-computing
05:50:06 <yoshiaki> yoshiaki has joined #edge-computing
06:00:14 <yoshiaki> yoshiaki has joined #edge-computing
06:07:45 <yoshiaki> yoshiaki has joined #edge-computing
06:32:04 <shimazu> shimazu has joined #edge-computing
06:32:08 <yoshiaki> yoshiaki has joined #edge-computing
07:22:35 <sudeep> sudeep has joined #edge-computing
07:22:57 <sudeep> https://www.w3.org/2019/07/31-web-networks-PrinciplesForWebNetworks.pdf
07:24:56 <sudeep>   https://www.w3.org/2019/07/31-web-networks-TheviewfromtheEdge.pdf
07:31:36 <yoshiaki> yoshiaki has joined #edge-computing
07:34:52 <shimazu> shimazu has joined #edge-computing
08:27:29 <yoshiaki> yoshiaki has joined #edge-computing
08:27:33 <shimazu> shimazu has joined #edge-computing
08:28:11 <yoshiaki> yoshiaki has joined #edge-computing
08:31:20 <dontcallmeDOM> dontcallmeDOM has joined #edge-computing
08:31:41 <dontcallmeDOM> Meeting: Edge Computing for the Web
08:31:49 <dontcallmeDOM> RRSAgent, make log public
08:32:27 <nakakura> nakakura has joined #edge-computing
08:33:14 <Kangchan> Kangchan has joined #edge-computing
08:33:32 <dontcallmeDOM> scribenick: dontcallmeDOM
08:33:40 <yoshiaki_> yoshiaki_ has joined #edge-computing
08:34:13 <yos> yos has joined #edge-computing
08:34:53 <kimwooglae_> kimwooglae_ has joined #edge-computing
08:35:03 <dontcallmeDOM> DanD: we wanted to briefly introduce the concept of edge computing and how it relates to things developed alaredy in the cloud & networking space and how it may impact the Web
08:35:03 <xiaoqian> xiaoqian has joined #edge-computing
08:35:18 <dontcallmeDOM> ... I gave this presentation a couple of months ago to the Web & Networks IG
08:35:21 <hirata> hirata has joined #edge-computing
08:35:30 <Gooroomee> Gooroomee has joined #edge-computing
08:35:40 <dontcallmeDOM> ... if you're interested on the topic, check it out - we're tackling issues related to how to expose network features to the Web layer
08:35:49 <dontcallmeDOM> ... [slide the view from the Edge]
08:35:58 <dontcallmeDOM> ... [basic idea of edge computing]
08:36:09 <dontcallmeDOM> ... historically, functionality has been split between client and server
08:36:33 <dontcallmeDOM> ... this has gone back and forth depending on evolution of computing power available on device and the capacity of the network
08:36:41 <dontcallmeDOM> ... this has evolved over the past 3 or 4 decades
08:36:54 <dontcallmeDOM> ... what we have now is the introduction of a 3rd piece in the architecture
08:37:13 <dontcallmeDOM> ... adding to client and server the edge, which can sit anywhere between the two (if at all)
08:37:34 <dontcallmeDOM> ... it's close to existing concepts, CDN, proxy browsers
08:37:43 <dontcallmeDOM> ... but compared to those, these are for static resources
08:37:58 <dontcallmeDOM> ... The edge is both an architectural and a deployment question
08:38:08 <dontcallmeDOM> s/question/paradigm shift/
08:38:41 <dontcallmeDOM> ... from a developer perspective, the edge piece can both be the client and the server
08:38:53 <dontcallmeDOM> ... the edge is defined by the administrative boundaries
08:39:04 <dontcallmeDOM> ... and it is associated with the network and data center topology
08:39:19 <ymatsuura> ymatsuura has joined #edge-computing
08:39:26 <dontcallmeDOM> ... a lot of the elements that (from a network operator perspective) consitute the network can be virtualized
08:39:40 <dontcallmeDOM> ... most of our network is moved to IP which frees real instate in geographic footprint
08:40:02 <dontcallmeDOM> ... if you're familiar with central offices where switches used to be, they are now facilities that are closer to the user and can serve as data centers
08:40:15 <dontcallmeDOM> ... [use cases - a 3 dimension approach]
08:40:26 <dontcallmeDOM> ... you have to look at use cases through different lenses
08:40:50 <ktoumura> ktoumura has joined #edge-computing
08:40:51 <dontcallmeDOM> ... from a functional perspective, from a control & management perspective, from a location placement
08:41:30 <dontcallmeDOM> ... latency is definitely a key aspect since bringing functionalities to the edge help with reducing latency
08:41:39 <dontcallmeDOM> Michael: privacy would another requirement
08:41:58 <hfuji_> hfuji_ has joined #edge-computing
08:42:01 <dontcallmeDOM> DanD: this is not so much about requirements for edge apps as much as characteristics of apps that can benefit from edge computing
08:42:46 <dontcallmeDOM> ... Edge computing is also relevant now in the context of the deployment of 5G, with a disaggragation of functions in the network,
08:43:00 <dontcallmeDOM> ... network slicing can also create useful characteristics
08:43:08 <dontcallmeDOM> ... and a push to the edge among cloud providers
08:43:34 <dontcallmeDOM> ... An example on how this is relevant to the Web community
08:44:07 <dontcallmeDOM> ... assuming a Web app runs on the client that has a lot of workload on the client, you may want to find an edge node to shift your processing
08:44:38 <dontcallmeDOM> ... assuming a component has already been deployed in edge infrastructure - how would a client find it? how does it verify it satisfies the requirements for the appN
08:44:48 <dontcallmeDOM> ... how does it adapt to mobility circumstances?
08:44:52 <dontcallmeDOM> s/appN/app?/
08:45:04 <dontcallmeDOM> ... how does it adapt to congestion load on the node?
08:45:12 <dontcallmeDOM> ... this is mostly done as an agent to the OS at the moment
08:45:21 <dontcallmeDOM> ... WebApps could take advantage of these scenarios
08:45:53 <dontcallmeDOM> ... Assuming you've deployed your app on edge nodes e;g. in a cloud platform - how do you figure out the best one to find, how do you transition?
08:46:01 <dontcallmeDOM> ... this type of APIs might be worth exposing from the uA
08:46:04 <dontcallmeDOM> s/uA/UA/
08:46:17 <dontcallmeDOM> ... I don't know how this woudl be done, what security implications this would imply
08:46:26 <dontcallmeDOM> ... we want feedback and input on these questions
08:46:56 <jeff_> jeff_ has joined #edge-computing
08:46:58 <dontcallmeDOM> ... ETSI Multi-Access Edge Computing provides APIs at the infrastructure level
08:47:16 <dontcallmeDOM> ... incl network conditions, location - but this is for the app running on the edge
08:47:21 <dontcallmeDOM> ... it doesn't involve the browser per se
08:47:33 <dontcallmeDOM> ... Another initiative is the Akarino project from the Linux Foundation
08:47:53 <dontcallmeDOM> ... it's an integration open source project that provides blueprint integrated hardware and software for specific use cases
08:47:59 <dontcallmeDOM> ... e.g. IoT, RAN deployment
08:48:29 <takayud> takayud has joined #edge-computing
08:48:55 <dontcallmeDOM> Michael: there are many edge computing stacks under development
08:49:03 <dontcallmeDOM> ... In terms of use cases, there was browser offloading
08:49:16 <dontcallmeDOM> ... but there are also non-browser use cases, eg. orchestration
08:49:21 <dontcallmeDOM> ... some are compute-intensive, some not
08:49:36 <shimazu> shimazu has joined #edge-computing
08:49:38 <dontcallmeDOM> ... also questions around data movement is a consideration
08:49:49 <dontcallmeDOM> ... you gain in compute but raises the time to transfer data back and forth
08:50:03 <dontcallmeDOM> ... We have an existing thing in W3C that could be extended to support this
08:50:07 <dontcallmeDOM> ... for instance ServiceWorker
08:50:10 <dontcallmeDOM> ... or PWA
08:50:16 <dontcallmeDOM> ... Micro-services are also related
08:50:40 <dontcallmeDOM> @@@Baidu: the CDN is classical in network architecture
08:50:52 <dontcallmeDOM> ... we're exploring distributed networks, e.g. P2P CDN
08:51:02 <xiaoqian> s/@@@Baidu/QQT
08:51:04 <MasayaIkeo> MasayaIkeo has joined #edge-computing
08:51:10 <dontcallmeDOM> ... if a browser want to support a P2P CDN, it needs a P2P API
08:51:40 <dontcallmeDOM> ... how does the browser support a P2P network distribution system?
08:52:04 <dontcallmeDOM> DanD: to design P2P + edge, finding the peers is something you would want to do very quickly
08:52:17 <dontcallmeDOM> ... finding the closest peer to you shouldn't involved going out to a far away data center
08:52:41 <dontcallmeDOM> ... when you design a P2P artchitecture, instead of going peer to server to peer, you could query an edge piece to find that information
08:52:55 <dontcallmeDOM> ... that would be a way to leverage the edge in a P2P network
08:53:10 <dontcallmeDOM> QQT: if we find a peer node, how do we connect to it?
08:53:17 <dontcallmeDOM> ... some nodes doesn't support HTTP, just UDP/TCP
08:53:21 <dontcallmeDOM> ... e.g. bittorrent
08:53:30 <dontcallmeDOM> DanD: what you put on the edge is up to you
08:53:37 <dontcallmeDOM> ... you have your own application that runs on the edge node
08:53:47 <dontcallmeDOM> ... it hosts your piece of the app
08:53:50 <dontcallmeDOM> ... you make it work
08:54:03 <dontcallmeDOM> Michael: another way to look at it is the edge as a set of available functions
08:54:17 <dontcallmeDOM> ... the question becomes what protocols can be made available
08:54:24 <dontcallmeDOM> ... the browser is mostly client-server model
08:54:34 <dontcallmeDOM> ... whereas things-based projects are more peer-to-peer
08:55:12 <dontcallmeDOM> ... Instead of looking at edge from a full-stack perspective, we can also look at it from a more functional perspective
08:55:20 <dontcallmeDOM> DanD: for P2P, WebRTC could be used
08:55:31 <dontcallmeDOM> QQT: WebRTC brings too much for this
08:55:38 <dontcallmeDOM> Michael: WoT supports multiple protocols
08:55:48 <dontcallmeDOM> ... we have a scripting API but we don't have a deployment model for it
08:55:59 <dontcallmeDOM> ... I've been wondering if this would be a good place to put that
08:56:05 <dontcallmeDOM> QQT: WoT is closer to the edge
08:56:14 <dontcallmeDOM> Michael: we want to have an environment to run the code
08:56:38 <dontcallmeDOM> Sudeep: is the question how do we discover the edge and we can use WoT protocols to do that
08:56:44 <dontcallmeDOM> ... and once we discover the edge, how do we offload?
08:56:49 <dontcallmeDOM> Michael: discovery is one problem
08:57:03 <dontcallmeDOM> ... another is management: how do I install some code and control it at run time?
08:57:13 <dontcallmeDOM> ... another is a provisioning environment
08:57:21 <dontcallmeDOM> DanD: Akaraino may actually solve this
08:57:38 <dontcallmeDOM> ... Blueprints go higher or lower in the stack
08:58:01 <dontcallmeDOM> Michael: from a high level, what gaps can W3C help in this context?
08:58:04 <shimazu> shimazu has joined #edge-computing
08:58:25 <dontcallmeDOM> ... without looking at specific stacks, what is W3C strength? what is the gap? what is the problem we can solve?
08:58:40 <dontcallmeDOM> ... we have the Web developers community, a certain collection of APIs that we can evolve
08:58:47 <dontcallmeDOM> ... can they be expanded to account for the edge?
08:58:55 <dontcallmeDOM> ... we also need to under the business models
08:59:14 <dontcallmeDOM> DanD: one thing I do want to point out - I keep mentioning that an app would need to be edge-aware, not edge-dependent
08:59:24 <dontcallmeDOM> ... you need a fallback in case an edge node cannot be found
08:59:42 <dontcallmeDOM> Michael: there are various mechanisms that we could extend
09:00:02 <dontcallmeDOM> ... e.g. considering serviceworker: you could transparently pushing it to the edge if available; if not, fallback on client serviceworker
09:00:26 <dontcallmeDOM> ... another approach would be microservices: the server could push some of its microservices to the edge
09:00:39 <dontcallmeDOM> ... but that is no longer in W3C's scope
09:00:48 <dontcallmeDOM> DanD: if you want to push this to serviceworker, it would need to be partly transparent to the developer
09:01:08 <dontcallmeDOM> Michael: I think that's one option that should be considered and developed
09:01:27 <dontcallmeDOM> ... not clear if this would be fully transparent, or with an hint, or with more developer control
09:01:37 <dontcallmeDOM> SOng: it's not just about discovering the edge node
09:01:50 <dontcallmeDOM> ... how can a Web developer invoke some interface to do discovery, connection?
09:02:10 <dontcallmeDOM> ... based on my experience from an operator perspective, the edge computing will support most services
09:02:18 <Yoshi> Yoshi has joined #edge-computing
09:02:25 <dontcallmeDOM> ... for Web/HTTP requests, we need to speak with the infrastructure provider
09:02:33 <dontcallmeDOM> ... if not, there is no direct communication yet
09:02:46 <dontcallmeDOM> ... we need to get operators and device makers to support that - as soon as possible
09:02:55 <dontcallmeDOM> QQT: is there a way to access an edge node from HTTP?
09:03:18 <dontcallmeDOM> ... from the browser?
09:03:38 <dontcallmeDOM> DanD: Once you know where it is, you can use the browser HTTP stack
09:03:56 <dontcallmeDOM> QQT: but the edge node IP address can change all the time
09:04:42 <dontcallmeDOM> DanD: if I understand the requirement, you would try to find an edge node to find a local peer
09:05:12 <dontcallmeDOM> ... the edge node is an IP address
09:05:23 <dontcallmeDOM> ... to which you ask the best peer
09:05:32 <dontcallmeDOM> ... and then you shift your communications to it
09:05:40 <dontcallmeDOM> QQT: the results would provide some IP address then?
09:05:43 <dontcallmeDOM> DanD: right
09:05:57 <dontcallmeDOM> QQT: and we would use it to access to the edge node, with what protocol?
09:06:25 <dontcallmeDOM> ... HTTP? the problem is that we can't use HTTPS due to domain matching
09:06:39 <dontcallmeDOM> DanD: this isn't different from a deployment to the cloud
09:07:52 <dontcallmeDOM> Dom: but how do you map an IP address to a domain-based certificate for TLS?
09:08:03 <dontcallmeDOM> Michael: there is COmmunity Group that has been looking at this
09:08:11 <dontcallmeDOM> ... this has been bugging us for a while in Web of Things
09:08:28 <dontcallmeDOM> ... it's difficult to get support for this in browsers
09:08:58 <dontcallmeDOM> ... a local CA would work but can't work in browsers
09:09:14 <dontcallmeDOM> Dom: I don't think we have an answer to this at this time - it feels like a major challenge from a deployment perspective
09:09:53 <dontcallmeDOM> DanD: coming back to our broader discussion
09:10:08 <dontcallmeDOM> ... it would be interesting to look at what W3C could do
09:10:29 <dontcallmeDOM> ... with Michael's serviceworker approach, would this be like an edge browser after previous cloud browser?
09:10:40 <dontcallmeDOM> ... would we need to define what a client would look like?
09:10:46 <dontcallmeDOM> ... and what APIs it would expose?
09:11:03 <dontcallmeDOM> Michael: fwiw, I think this only solves a specific use case: browser offloading
09:11:23 <dontcallmeDOM> ... another issue is that serviceworker are very limited in terms of what APIs they can use
09:11:38 <dontcallmeDOM> ... for instance, having access to AI on the edge based on what is under development would be important
09:11:47 <dontcallmeDOM> ... ServiceWorker doesn't have filesystem support
09:11:52 <dontcallmeDOM> ... e.g. for persistent
09:12:48 <Chunming> Chunming has joined #edge-computing
09:13:00 <Chunming> present+
09:13:04 <Chunming> q?
09:14:09 <dontcallmeDOM> dom: cloudflare has a product with a serviceworker-based deployment for its cloud infrastructure
09:14:17 <dontcallmeDOM> ... which sounds interestingly similar to what we've discussed
09:14:32 <dontcallmeDOM> ... combined with the advent of Web Assembly on client/servers, lots of interesting opportunities
09:14:38 <dontcallmeDOM> ... although lots of unknowns
09:14:52 <dontcallmeDOM> DanD: one unknown would be to understand what features would be available to this "edge user agent"
09:14:58 <dontcallmeDOM> ... WebGL? WebML? others
09:15:33 <dontcallmeDOM> Michael: not sure if serviceworkers would have access to them
09:15:43 <dontcallmeDOM> Dom: maybe not now, but they could be adapted to new contexts
09:15:55 <dontcallmeDOM> Michael: WebAssembly can be thought as containers
09:16:07 <dontcallmeDOM> ... so this may be an opportunity for W3C to get into that space
09:16:28 <dontcallmeDOM> ... The other question is discovery - if I find a node, how do I deploy code to it?
09:16:44 <dontcallmeDOM> chunming: several years ago, W3C had generated a note about Cloud Browser architecture
09:16:56 <dontcallmeDOM> ... where a lot of the browser rendering was done in the cloud
09:17:19 <dontcallmeDOM> ... if we have edge in the middle, can we offload some of the browser tasks (e.g. time consuming calculation to the edge)
09:17:26 <dontcallmeDOM> ... e.g. to help battery, or better performance
09:17:44 <dontcallmeDOM> ... Another question - we heard of applications (e.g. AR or VR scenarios)
09:17:50 <ajitomi> ajitomi has joined #edge-computing
09:17:52 <dontcallmeDOM> ... currently all the rendering happens in the device
09:18:11 <dontcallmeDOM> ... but there are use cases where e.g. AI detection tasks would be running in the edge
09:19:09 <dontcallmeDOM> DanD: the cloud browser was mostly focused for set top boxes for media
09:19:25 <dontcallmeDOM> ... it was to offload the settop box to the cloud e.g. for the fancy navigation
09:19:31 <dontcallmeDOM> ... in the end, the idea is the same
09:19:48 <dontcallmeDOM> ... between cloud browsers, split browsers with user interactions, proxies - this was done e.g. 20 years ago by Opera
09:20:07 <dontcallmeDOM> ... they did caching, transcoding, mapping between technologies to save bandwidth
09:20:11 <dontcallmeDOM> ... the concepts are very similar
09:20:17 <dontcallmeDOM> ... they had a browser running in the cloud
09:20:37 <dontcallmeDOM> ... if you think of what properties you want to offload to the edge, you can start identifying what an edge ua would look like
09:20:46 <dontcallmeDOM> ... and then you have to juggle between where to run these APIs
09:21:22 <dontcallmeDOM> ... if you tackle this problem by looking at how to run Web technologies to the cloud (closer or further), the question is what can be run with what security considerations?
09:21:27 <dontcallmeDOM> ... e.g. how to ask user permission?
09:22:27 <dontcallmeDOM> Dom: I would start with simple e.g. offloading computing
09:23:44 <dontcallmeDOM> Dom: follow up could happen in the Web & Networks IG
09:24:08 <xiaoqian> RRSAgent, make minutes
09:24:08 <RRSAgent> I have made the request to generate https://www.w3.org/2019/09/18-edge-computing-minutes.html xiaoqian
09:24:20 <xiaoqian> RRSAgent, make log public
09:25:19 <dontcallmeDOM> ... otherwise, or when we're ready to experiment/prototype, we could move to a dedicated CG to play with ServiceWorker
09:25:31 <dontcallmeDOM> ... the IG is probably the right place to explore the overall landscape
09:25:45 <dontcallmeDOM> Michael: WoT would want a lot more and very different things from the edge
09:26:55 <dontcallmeDOM> Dom: agree, but we probably want to start with low hanging fruits
09:27:18 <dontcallmeDOM> Michael: for WoT, you would want to install persistent orchestration service - setting new functionalities, now moving things up or down
09:27:38 <dontcallmeDOM> DanD: if people are interested, please join us in the Web & Networks IG
09:27:52 <dontcallmeDOM> ... we'll work on clarifying that particular topic and identify concrete next steps
09:28:09 <dontcallmeDOM> ... it seems there are ideas, probably not clear yet but worth exploring
09:28:17 <dontcallmeDOM> RRSAgent, draft minutes
09:28:17 <RRSAgent> I have made the request to generate https://www.w3.org/2019/09/18-edge-computing-minutes.html dontcallmeDOM
09:33:21 <MasayaIk_> MasayaIk_ has joined #edge-computing
09:34:49 <yoshiaki> yoshiaki has joined #edge-computing
09:38:55 <yoshiaki_> yoshiaki_ has joined #edge-computing
10:06:29 <MasayaIkeo> MasayaIkeo has joined #edge-computing
12:22:01 <Chunming> Chunming has joined #edge-computing
14:49:36 <Chunming> Chunming has joined #edge-computing
15:05:36 <Chunming> Chunming has joined #edge-computing
15:16:25 <shimazu> shimazu has joined #edge-computing
15:54:53 <shimazu> shimazu has joined #edge-computing
16:28:49 <shimazu> shimazu has joined #edge-computing
17:37:05 <shimazu> shimazu has joined #edge-computing