List of videos

Wasm I/O 2023 / 23-24 March, Barcelona Slides: https://2023.wasmio.tech/docs/sessions/javy-creating-a-toolchain-for-running-javascript-on-webassembly-wasmio23.pdf How to run JavaScript on WebAssembly is not obvious. Javy is an open source toolchain for running JavaScript on WebAssembly that has contributions from developers at multiple companies. Shopify also had to find a way for the WebAssembly modules produced by Javy to be small enough to work efficiently with our infrastructure. This talk will unpack how Javy uses tools like QuickJS, Wizer, and Binaryen to translate JavaScript input into WebAssembly modules. Additionally, it will cover how we are able to use Wasmtime’s linker, WebAssembly’s multi-memory proposal, and part of the canonical ABI introduced in the component model to enable Javy to create WebAssembly modules that have a size less than 100 KB.

Wasm I/O 2023 / 23-24 March, Barcelona Speakers: Francisco Cabrera & Yu Jin Kim Slides: https://docs.google.com/presentation/d/1jzd2fXQ_yX9N1WGcP9OzJ_BBwSCLV-MF/edit#slide=id.p1 Kubernetes on the edge is becoming increasingly popular for orchestrating workloads closer to where the data is located to reduce costs and latency. However, the edge usually consists of IoT leaf devices that are too small, too old, or too locked down to run Kubernetes on their own (i.e. IP cameras, thermometers, humidity sensors). Contrary to cloud Kubernetes deployments, being at the edge also means having to deal with more constrained resources for your workloads running on clusters deployed on hardware. While containers are great for running workloads, they have high startup costs, bigger binaries and higher memory consumption. So how can these leaf devices be dynamically bridged to a cluster while being as efficient as possible with the available resources at the edge? This talk will go over how users can use AKS Edge Essentials with WASM workloads to deploy a cluster on “light” edge hardware (PC-class devices) and run Akri (a CNCF Sandbox project for exposing leaf devices as resources in a cluster), minimizing the footprint when connecting to these devices and utilizing them in your applications. The talk will include a demo where Akri-connected devices can be utilized in Slight (SpiderLightning) apps through a gRPC proxy running on an AKS Edge Essentials cluster. Benefits to the Ecosystem:  Modern solutions now span cloud to edge, but Kubernetes at the edge still has its challenges. The main challenge is that it is extremely resource-constrained. Leveraging existing hardware and running workloads with minimal footprint is crucial at the edge. Using WebAssembly significantly reduces resource consumption and increases the responsiveness of the cluster even on older, smaller hardware. AKS Edge Essentials enables deploying K3s or K8s clusters on devices that have memory as little as 4GB and compute as little as 2vCPU. With this resource-constrained cluster, the demo will showcase how to connect to leaf devices with extremely small footprint; by running Akri on a WASM instead of a container, we can make the OCI image 54 times smaller. As a result, the Akri devices can be utilized in Slight apps, consuming far less resources than if they were to be run on traditional containers.

Wasm I/O 2023 / 23-24 March, Barcelona Slides: https://webassembly-debugging-demystified.nanthakumar.ca WebAssembly is a low-level, binary format for web applications that is designed to be fast and efficient. It allows developers to write code in languages other than JavaScript, and then compile that code to run on the web. As with any software, debugging is an important part of the development process for WebAssembly applications. Debugging helps identify and fix issues in the code, ensuring that the application performs as expected and meets the desired requirements. Outline - Explain the DWARF debug file format and how to generate it. - Using browser developer tools: Most modern web browsers come with a set of developer tools that you can use to debug WebAssembly applications. These tools allow you to inspect the code, set breakpoints, and evaluate expressions. - Use debuggers and profilers: Debuggers and profilers are specialized tools that can help you identify and fix issues in your WebAssembly code. Debuggers allow you to step through your code line by line and set breakpoints, while profilers can help you identify performance bottlenecks in your code. - Use memory analyzers: Memory analyzers can help you identify and fix memory issues in your WebAssembly code. These tools allow you to monitor the memory usage of your application and identify any leaks or other issues that may be causing problems. Ex: Memory Inspector in Chrome - Use logging and monitoring tools: Logging and monitoring tools can be useful for debugging WebAssembly applications in production environments. These tools allow you to track the behavior of your application and identify any issues that may arise. - Capturing errors in production - Use Sentry’s SDK to capture errors. - Sentry has build a tool [wasm-split](https://github.com/getsentry/symbolicator/tree/master/crates/wasm-split) that can split a .wasm file into a debug information file and a final stripped .wasm file without debug information. Uploading the .debug.wasm file lets Sentry process native crashes and provide symbolicated stack traces of production errors.

Wasm I/O 2023 / 23-24 March, Barcelona Panelists: Ramon Huidobro, Philippe Charrière, Oscar Spencer, Sylwia Vargas As a community, we haven’t yet quite figured out how to make WASM sound approachable. We are how we speak - and currently, we sound arcane and complicated. This interactive panel will present opportunities for communal brainstorming on how to get more people onboard without running a whole workshop. It is a familiar scene: an experienced dev explaining WASM to newbies - the more they talk, the less their audience understands not only about WASM but about the Internet in general. Confusion ensues. With every minute passing, WASM sounds more and more like an arcane practice and not a technology one can actually learn. While it is important to know a technology well to be able to build with it and push its limits, it’s also important to be able to start learning it. Let’s talk about the learning roadmap of WASM which, if done right, can help not only new devs but also your low-technical PM or non-technical marketing colleague. This panel will be interactive - you will not only be invited to ask questions but also to brainstorm a better future for WASM education with us. As a community, let’s team up in WASM adoption!

Wasm I/O 2023 / 23-24 March, Barcelona Slides: https://seb.deleuze.fr/introducing-kotlin-wasm/ Kotlin is a modern, cross-platform, statically typed, general-purpose programming language developed by JetBrains. It targets JVM, including Android; JS; native platforms via LLVM, including iOS; and lately WebAssembly. Kotlin/Wasm is the new target and toolchain in the Kotlin family. It has a few special properties: - It compiles to Wasm directly without any additional layers, to compile as fast as possible, including incrementally in the future. - It uses experimental/fresh proposals like GC, Typed Function References, Exception Handling, and Stringref. In this talk, we will have a deep look inside the internal details of the Kotlin/Wasm technology stack, how the Kotlin code is compiled into WebAssembly and look in-depth at the generated code and its structure. We will discuss how the Kotlin/Wasm compiler handles the language features of Kotlin, such as classes, virtual and interface calls, coroutines, and others using fresh and experimental proposals like GC, Exception Handling, Typed Function References. We will also explore various use cases of Kotlin/Wasm: in the browser but also for server-side workloads with the WASI support for Kotlin/Wasm incubated on https://github.com/kowasm/kowasm, as well as the interoperability with the WebAssembly Component Model. ======================================= Video Chapters Intro 0:00 Kotlin 0:42 Kotlin/Wasm 2:42 The new Kotlin/Wasn compiler 4:11 Kotlin/Wasm deep dive 7:27 Classes & Interfaces 7:33 Strings & Stringref 11:44 Kotlin/Wasm applications today and tomorrow 13:48 Compose Multiplatform 14:09 Compose for Web with Kotlin/Wasm in Action 14:34 Debugging Kotlin/Wasm in browser 14:53 Introducing KoWasm 15:08 KoWasm Demo 18:32 WIT & Kotlin 21:53 Compose HTML Demo 23:09 IDEA: Fullstack rendering with Compose HTML and Kotlin/Wasm 24:10 What’s next? 25:35 Thanks & Question 27:44

Wasm I/O 2023 / 23-24 March, Barcelona WebAssembly (Wasm) is rapidly gaining popularity as a platform for building high-performance, low-overhead applications. However, running Wasm on the cloud has been a challenge due to a lack of standardization and security concerns. Enter wasi-cloud, a collection of WASI proposals that provides secure, standardized interfaces for running Wasm code on the cloud. In this talk, we will introduce wasi-cloud and its capabilities, show live demonstrations of Wasm apps running on Azure and wasmCloud, and explore the future possibilities for this technology. Join us to discover the potential of wasi-cloud and how it can shape the future of cloud computing.

Wasm I/O 2023 / 23-24 March, Barcelona Slides: https://2023.wasmio.tech/docs/sessions/fast-secure-deterministic-execution-on-blockchain-wasmio23.pdf Evolving the world’s economy through decentralization will require smart contract platforms to execute complex operations with low latency, and to be able to continue doing so throughout imminent periods of exponential growth. This was the design goal of MultiversX architecture - to create a dependable execution environment whose speed and costs remain constant under heavy load, which is able to scale with demand, and integrate new components with ease. For this we need the fastest virtual machine in the space, WASM is a must for this. Our discussion will cover the road of continuous innovation and optimizations in order to execute AMM swaps in under 0.06ms.

Wasm I/O 2023 / 23-24 March, Barcelona Slides: https://docs.google.com/presentation/d/1WIL0z5RQbP2GriMOFV5Z1A8q_grqxvk0san0CEjemRc/edit?usp=sharing Lunatic is a runtime for building distributed, highly concurrent systems with WebAssembly, and Grain is a programming language that makes getting up and running with WebAssembly a breeze. Combine the two, and you’ve got the easiest, most secure way to build scalable systems that absolutely anyone can have up and running in minutes. In this talk, we’ll cover the ins and outs of Lunatic, from its process spawning model to how it can run untrusted code, and ultimately build a full application that can withstand enormous amounts of traffic. You’ll walk away with a new set of tools for building for the web, as well as knowledge of how Grain can be used for practical, real-world computing.

Wasm I/O 2023 / 23-24 March, Barcelona Expanding the number of supported languages in WebAssembly will drive massive adoption and support from the mainstream developer community. WebAssembly empowers developers by allowing them to use the languages, libraries and tooling they already know and love within a safer, sandboxed environment. In this talk we will explore how programs written in interpreted languages can be executed within a WebAssembly sandbox, effectively reducing the number of security threats they are exposed to. We will show what are the common pitfalls that we will hit when executing programs in interpreted languages when their interpreter is running as a WebAssembly module. Companies build their applications in a wide set of languages. As time passes by, different languages and frameworks are introduced into the company tech stack. This increases the deployment complexity as well as management of those applications in the infrastructure. Virtual Machines and containers were created to fill this gap. You can run heterogenous applications on top of the same hardware. However, they came with their own trade-offs in terms of security issues, performance, and management overhead. With WebAssembly, you can compile different applications targeting the same binary format. Wasm modules are lightweight, simplifying running and transferring them. Thanks to its sandboxing and capability-based security features, wasm modules cannot access system resources by default. You can grant fine-grained access to resources such as filesystem or sockets. Expanding the number of supported languages in WebAssembly will drive massive adoption and support from the mainstream developer community. Several projects are emerging around this new promising technology although there is still not a clear route to the ultimate WebAssembly platform. Adoption by the community will be related to how easy it is to run existing software without modifications. All the work that we are doing in this scope is Open Source and our main goal is to contribute all changes to the upstream projects.