 And the first speaker I would like to introduce is going to talk about Robust Software and Centric IoT. His name is Kasper Verde-Klund, and he comes from Toyota Web. Welcome Kasper. Can you all hear me? Yep. That is perfect. I only have 15 minutes, so I'll try to be brief, but it's a little bit essential what we're building down at the hardware moment. So I've been doing software platform for too long. Software platform is really abstraction layers that run other software on top. And probably the most well-known piece of software that I hand in is something I did with Google for a while. How many of you are familiar with that logo? It's a well-known thing now. Google Chrome. So we took a browser and we turned it into an application platform by making the software foundation for running applications on top much, much more robust and much, much faster, like a hundred times faster than what it was before we started. And it really changed how you could program and use the web browser as an application delivery platform. I'm not here to talk about JavaScript or Chrome. I'm here to talk about that title there. So Toyware is a small-style company. It started there a bit more than a year ago. We're now eight years working on the next generation software platforms for everything. We're going to tell you all about what that is and hopefully also about why that is. So Toyware is working in this space. This is an example of a kind of device that we can target. Lots of wires, lots of chips, lots of things in there. How many of you feel comfortable writing software for things like this? 20%. That's actually pretty high. In general, what we see is that very few people actually feel comfortable writing software for these things. It's hard, it's difficult, and it seems complicated for some reason. So usually, it's a kind of device that we look at. There are actually some growing up. They're getting to be what I call proper computers in a sense. They're network connected, a bit too small to run the next door, windows or micro-lets. But they actually support all the modern communication standards now. So you can actually have them engage in a proper dialogue with other network devices and have the right encryption and everything turn on. It doesn't have hardware support for and despite the isolation, which means it's hard to run things like this on top. So usually, people run any more primitive, real-time operating systems in these devices. They are quite powerful though. Here's an example of one. ESP32 comes with a half a megabyte of RAM, falling by the flash, and it costs around two dollars, even if you don't buy too many of them, to go to AliExpress and just order them. They're cheap and they're really good. So these devices are really fast. I mean, if you look at how fast they can execute code, they're like dual core 240 megahertz CPUs, much faster than the desktop machines that we used 15 or 20 years ago. So all that for less than two dollars. It's quite impressive. What's less impressive is the kind of tools that you usually use to develop code for these things. So the really tried and trusted tools in this area is a C compiler. That's the logo for the new compiler collection, which has a C compiler that's heavily used here, and a soldering iron. It's not super sort of high-tech, but it works and it's really what people use today. So what they do when they then develop is they find some chip like this and they start with that basically. Find the hardware, what do we need, how fast should it be, how much RAM do we need, and you go buy it. Then you find a real-time OS and you decide which one you like. Like free answers would be a good example of that and there are others too. So you choose that, then you write all your stuff and once you're happy with that you link it together with your OS. You transfer that whole thing to the image, as an image to the device. And you reboot it and with any luck it comes to life and it does everything you wanted. So there's probably a little bit of preying involved here as well. So there are a lot of things really sort of wrong with this picture in terms of how you do this, but this is really how it's done today. My least favorite part of this is probably this whole system image part that all the code on this device that does something for you is put together in one blob and transferred as a whole to this device. That's a real issue. Nobody would ever do that in a big service system. Say, okay, we'll write all the code in one blob, compile and link it all together and ship it as the only thing for a time machine and trust that everything works. That's not a modern way of doing things. We'd like to break it down a bit more. So for me that's the worst thing here. And in general there's not a whole lot to like about this I think. So I think this is sort of usually how I think of IoT development today. There's a lot of crying involved. A lot of pain. Some people are still actually developing really fantastic things with this stack but it's not pleasant. So I think the reason why you really cry is because the device you have and the way you use it doesn't really give you a way to update the code. It doesn't give you a way to run really sophisticated software on this thing even though the device actually can support this. You just don't do it. It's not really a generic and flexible solution you have. It's often tied to an application that you had in mind when you bought the device. And it's not a secure and sandbox environment for code you don't necessarily trust. Everything is compiled together, has the same privileges. So if there's an application problem in one part of your code it takes down the entire thing. It's not a super nice model to work in. And so building on that, it's not a fault tolerant system as a starting point. So working in this space, writing software in this space, it's just not super pleasant at all. And I think there are two sort of common things here. It's very hardware centric. That's what you buy. That's what you focus on. And it's also built on a fairly poor foundation I think. I don't know how many of you are familiar with building on poor foundations. It does happen out in the real world too, not just in software. It usually looks something like this. It's not a good idea to build on a poor foundation. In reality, the best thing you can have is have a really solid foundation and build fancy, interesting, weird things on top and maybe they'll still fall apart, but at least you have a common ground that actually works across these things. So this is the space we work in. I'm not quite sure why I ended up adding our logo there. It's not that we're trying to put more tigers on beaches, but we're actually trying to solve this by giving things a much better foundation and improving things in that space. So let me give you a peek for our solution in this space. This is actually it. It's very, very simple. At the core of it, we've changed pretty much nothing. We have a real-time OS, in this case, free RTAS. We have a TCP IP stack that we didn't invent, lightweight IP. And we pick standard components for TLS, encrypted communication, like embed TLS. But where the magic happens is really on top of that. We glue in a software abstraction layer, a virtual machine, if you will. We call it Toit and maybe you'll get an answer to why we call it that in the moment. But that's what we glue in. This is sort of the technology space we've been working in for a while. And JavaScript in a browser runs a virtual machine. Java on a server runs a virtual machine. It's time for IoT devices to also run a virtual machine. So we built that. On top, we actually run some system services. And this is where we hook up this system to the broader internet. So everything that communicates with this device goes through a managed set of services that runs on this virtualized machine. This gives us some advantages in terms of platform independence. So if you have a virtual machine, you can easily move this and replace the bottom layer here, the darkest color one, to be a Linux machine instead if you want to run it there or pick another OS. You have this sort of built-in platform independence. That means you can test your IoT code, not on a device, but somewhere else, and you get a chance to actually start with software functionality even before you buy a device and start sort of messing with that and figuring out how that should work. What's left here is actually, I think, where the pretty clever thing comes to life is that this model allows you to have independent applications running on top that can be versioned independently, updated independently, written independently. They're just like you would have on a proper operating system, if you will, support for having these isolated components, piece of functionality that runs separate from each other and still uses the same foundation. So this is sort of what we're building, a IoT platform that gives you robustness at the core but also gives you the ability to actually run software components that you didn't think of when you shipped your device, software components that need to be upgraded and sent out in a more fluid way. So this is much closer to what you have on a desktop machine that runs Linux or in a server data center where you also have lots of applications that get updated independently and sent out that way. And that's good. So the virtual machine itself is a software abstraction that builds on top of this fairly simplistic hardware and gives you essentially a new kind of machine. It's higher level. It gives you the ability to actually have programs that are more compact because they're represented in a byte coded format, not native code for some particular platform. But this independence allows you to upload one application written in a high level language and get it across a number of different devices, even if they don't share the same kind of CPU. There's nothing super novel about this approach in general. We've seen Java byte code conquer a good chunk of the world for many, many years. It's just kind of new to, I think, push this to these fairly small devices. So I'm going to give you a sneak peek for how it is to work with our system. So if you wanted to write some code for a particular device, you'd probably start out with a command line here and say, tell me which device I have available. In this case, it just prints a really, really long and annoying UUID for the device. We're working on adding some aliases for these things so you can name things in a more clean way. But for now, this is a unique name for a device. Once you have your devices here, connected through Wi-Fi or narrowband IoT or even Laura and things like that, you can actually start communicating with it and ask it to do things for you, just like you can on the computer you're sitting in front of. So for instance, here I can say, toyed run, give that long, long device ID and ask it to run Hello World on the device. So this is me sort of writing code here in front of you on a slide that runs on my developer machine but actually executes things on a small network connected device instead. So the middle part here is really just shows you what happens when you do this. It starts up a brand new process on the device with code that that device had never seen before. Gets that all compiled together as a small, completely separate component. We put it over there, start and flash that doesn't take up too much RAM and we run it and once we're done, we just stop that whole thing, remove the code and off you go. Of course you can have long running services there as well if you can upgrade but this ability to just try things out without breaking down the entire platform if you get it wrong is a really nice thing. So even if you might put bugs in your code and I think most of us probably will at some point, it doesn't take down the system at all. At the very low end of the slide, at the bottom here, you see the smallest kind of toy program in this case Hello World and it's indentation based. I would say Python had a weird step sung with Java or something. Language we're still working on how it should work to actually be super familiar and applicable but it has the right properties that it's easy to write high level code in it even when it comes to network communications and things like that. So this is all the code you're going to see in this presentation. And now I think it's time to actually smile and be happy because now you actually have a device well you maybe had the device before too but now there's reason to be happy because your device is now updateable and can run high level code that you can write. It's generic and flexible and it's not really tied to application even the platform allows your code on your Linux machine in your data center or on this device. Maybe most importantly it's the secure sandbox environment for code you do not trust doesn't have to be linked with the kernel doesn't have to have the same privileges as the kernel code to actually run on this and this gives fault tolerance and the ability to upload stuff that you didn't think of when you shipped the device. This is a robust foundation and it's much more software centric it's much more software first to get going with this. And we think this is the future for IoT development in a space where the devices are big enough to support this which generally mean 32-bit CPUs and upwards so we're not trying to target very very small 8-bit 16-bit microcontrollers but these are cheap and they're available and you could all build interesting stuff with a device like this with the proper platform in there. So the technology in a nutshell is take whatever small simple system that was there hardware, ReelsMOS built on top, providing software platform that allows you to add new devices and get them hooked up in a safe way with the right certificates to do encrypted communication secure and reliable over the updates of the entire system software including the virtual machine but more importantly perhaps software components, applications that are updatable and sandboxed individually. So let's say a teaser at the end we're also building support for actually writing software that is distributed in nature that runs across maybe 10 or 100 of these small devices and it's used for computing things but also for controlling processes. You could also say that it's just a new virtual machine a programming language and some management tooling for the Internet of Things or perhaps we're just building another app store in this case for your appliances not your phones. That's what I had.