Wasm I/O 2023

Wasm I/O 2023 / 23-24 March, Barcelona Let’s deep dive into the exciting technologies (new and old) that make it possible to run a WebAssembly module locally using Docker and containerd, and then in the cloud on a Kubernetes cluster. Bringing containers and WebAssembly closer will benefit everyone. WebAssembly can make use of all the existing infrastructure for building and delivering the workloads with the help of the OCI standard. And adding WebAssembly features to container orchestrators makes them a great choice for running workloads where performance and a small footprint is paramount. In this talk we will take a look at what it takes for a container runtime to be able to run a Wasm module, and the benefits of this approach including faster startup times, security guarantees, and easy integration into multi-tier services. This talk will also go over some history of the relation between containers and WebAssembly. I will go over the different ways one can run a WebAssembly module on the cloud (Kubernetes specifically), starting with krustlet and ending by showing the current iteration of the solution involving containerd shims that makes it possible to run a WebAssembly container locally or in the cloud.

Wasm I/O 2023 / 23-24 March, Barcelona Let’s talk about the history, current state, and future of Wasm outside of the browser. We’ll talk technical details and community effects that make this not just viable, but super valuable. And how it all ties together into a future that gives us the freedom to run code where and how we want to. WebAssembly outside of the browser doesn’t have a long history, but it does have a fascinating one. Early prototypes and projects led us down multiple paths which have now generally converged into a vision for the future which promises developments that haven’t been possible until today. But this isn’t a history lesson. We’ll get into what it is about core WebAssembly that makes it interesting outside of the browser. Then we’ll talk about more recent proposals and projects like the Component Model and WASI, as well as some core proposals and how they affect the world we’re moving into. Finally, we’ll talk about the emergent effects that arise from the community working toward a common goal and paint a picture of what we believe will be a better world for developers in the near future

Wasm I/O 2023 / 23-24 March, Barcelona Slides: https://speakerdeck.com/angelmmiguel/develop-serverless-apps-with-wasm-workers-server In this talk, we will explore how WebAssembly brings new benefits to the Serverless architecture and how to develop and run applications following this model with the Wasm Workers Server Open-Source project. You will learn how to create your first serverless application as Wasm modules! This architecture is not new. It allows you to focus on the business logic of your applications. You develop the functions that process users’ requests and return a result. These independent units compose services. Then, frameworks and providers connect these pieces so users can access them. WebAssembly is a natural fit for this model. The small binary format simplifies the distribution process. The ability to compile multiple languages into Wasm opens the possibility to mix and match them in the same project. The sandboxing and capability-based model ensures the functions are isolated without the cold start of other solutions like VMs and containers. [Wasm Workers Server](https://github.com/vmware-labs/wasm-workers-server) is an Open-Source project to develop applications following this model. It simplifies how to create and run serverless applications in different languages. All the functions, or workers, run inside the WebAssembly sandbox. After this talk, you will understand the benefits that WebAssembly brings to the serverless ecosystem. You will learn how to program your first application using Wasm Workers Server, by creating different functions in multiple languages.

Wasm I/O 2023 / 23-24 March, Barcelona As a developer, you may have heard about WebAssembly already: * as a Web developer, you may have learned how Wasm plugs into your own ecosystem * as a backend developer, you may know that it is somewhat similar to the .NET CLR or the JVM; * as a systems developer, you may know that it is a compilation target of your favorite C/C++ or Rust toolchain. Well, this talk is for all of you! Countless tutorials are available on the Web to build your first executable, but have you ever tried digging beneath the surface? Join me for this talk and learn more about the WebAssembly specification from the Upside-Down, lower-level perspective of a compiler enthusiast; and discover why more and more projects are making Wasm their sandboxed, memory-safe runtime environment of choice!

Wasm I/O 2023 / 23-24 March, Barcelona Slides: https://2023.wasmio.tech/docs/sessions/event-driven-to-automotive-wasmio23.pdf A showcase and discussion of modern event-driven architecture, extended through WebAssembly, which enables re-usable domain logic to be injected by the customers, from an infrastructure level, all the way through services and web applications, to embedded software in EV vehicles. A showcase of several projects delivered over the past few years, which utilise practical applications of WebAssembly at every level of a service’s architecture. This will begin with how we started applying WebAssembly at an infrastructure level by extending large scale clusters and applying zero-trust policies across complex systems using a single codebase. Moving into the service layer, we will discuss modern event-driven architecture, and then discuss how adding gRPC and WebAssembly not only provided our own teams with a richer toolkit, reduced effort, and an ability to extend their machine learning capabilities into the event-queue itself, but also enabled the services to be opened to third-party developers through rich, sandboxed, software development kits. Finally we will touch upon our work with using WebAssembly in the browser for optimizing machine learning tasks, in a privacy-preserving manner using federated learning, and then how we took part of this same work and applied it into upcoming state-of-the-art electric vehicles. Our discussion will cover why we made these decisions with the inherent risks, and also why we are continuing with WebAssembly, after the lessons learned through these processes.

Wasm I/O 2023 / 23-24 March, Barcelona Panelists: Saiyam Pathak, Daniel Lopez, Kate Goldenring, Shivay Lamba The cloud native community is garnering excitement around WebAssembly (Wasm). It offers a new way to package your application that provides secure memory isolation, portability, and quick start up times. Given the choice to package an application as Wasm modules or containers, which should I choose? Are the two technologies interchangeable? In this panel, discussion speakers will share their experience working with Wasm and their point of view from the cloud-native perspective. A blanket statement that “Wasm will replace containers” is a bold one. Instead, which use cases are best suited for Wasm workloads vs containers, and where do Wasm modules and containers best coexist? How should one go about orchestrating Wasm modules in the Cloud, whether with Kubernetes, Nomad, or a PaaS? The panelists will focus on these important questions which will greatly help the audience in understanding the landscape and assessing whether they could benefit from adding Wasm to their technology stack. The panel will dive into the benefits of the Wasm and container ecosystems, such as the tooling support, cold startup times, application size, and more. The panel will also address the maturity of Wasm, pointing out some of the current limitations that exist in server-side Wasm and its developer tooling. By the end of the discussion, the audience will have a good understanding of both the technologies and where they stand today. They will clearly understand the similarities and differences between Wasm and containers and their best use cases.

Wasm I/O 2023 / 23-24 March, Barcelona Slides: https://2023.wasmio.tech/docs/sessions/building-ephemeral-virtual-filesystems-wasmio23.pdf Many programs need filesystems, and a common approach for Wasm-compiled applications is to make the host filesystem available to the module. Why not the other way around? Let’s bring a virtualized filesystem to the WebAssembly module itself, and see what we learn in the process. The unix philosophy that “everything is a file” is a fundamental idea that powers platforms that run a huge amount of software today. If we want Wasm to be a deployment target for existing applications, we have to grapple with this fact and figure out how we intend to approach the problem of filesystems and filesystem-like entities in this new platform. The WebAssembly System Interface (WASI) takes the position of providing scoped access to the underlying host for these operations. However, what if we went the opposite direction? Why not bring a filesystem to the Wasm environment? This talk will describe what currently exists in and around this space, how WASI approaches the problem, alternatives, including Emscripten’s filesystem and wasi-vfs, and also a series of experiments for another idea of “ephemeral” virtual filesystems that are generated for specific modules depending on the needs of the application logic. I will walk through these various options, the experiments, and a path forward for this type of approach to interacting with filesystem entities in Wasm modules.

Wasm I/O 2023 / 23-24 March, Barcelona Slides: https://docs.google.com/presentation/d/1a33Ky1SScwJqtd3D46KhdE26nuNM3kJxaNIgcoahPcs/edit WebAssembly is improving native support for Kotlin and Dart. Learn about the "WasmGC" extension and how it will help developers write smaller and faster Web apps and share code across native platforms and the Web.

Wasm I/O 2023 / 23-24 March, Barcelona Slides: https://speakerdeck.com/thorstenhans/spin-it-jumpstart-your-wasm-journey-with-fermyon-spin Knowing about the potential and the impact of WebAssembly (Wasm) for serverless computing, we will dive deeper and see serverless Wasm in action. This talk guides you through patterns and practices for building serverless workloads with Fermyon Spin. Thorsten Hans addresses everyday developer tasks like routing, configuration management, and persistence. You’ll understand how to integrate Wasm into your distributed application architecture and interact with existing components. It’s time to jumpstart your WebAssembly journey and design distributed architectures for the next wave of cloud computing!

Wasm I/O 2023 / 23-24 March, Barcelona Slides: https://docs.google.com/presentation/d/1rTSabOdABy1dW4XGxemqpgMlqW4eviUFvD8uJvOGjz4/edit?usp=sharing This talk introduces libSQL: a fork of SQLite, and its support for dynamic function creation and execution directly via SQL, all powered by Wasm. It also covers how to implement and use a convenient library (libsql_bindgen) for compiling Rust code straight to Wasm, with automatic type translation. SQLite is a key piece of software for modern infrastructure. But while SQLite allows registering arbitrary user-defined functions via programmatic APIs, there’s no support for good old CREATE FUNCTION syntax for managing functions straight from SQL. This talk introduces libSQL: a fork of SQLite, and its support for dynamic function creation and execution directly via SQL, all powered by WebAssembly. libSQL is compatible with multiple runtimes, including Wasmtime and WasmEdge. The talk also covers how to implement and use a convenient library (libsql_bindgen) for compiling Rust code straight to Wasm, with automatic type translation.

Wasm I/O 2023 / 23-24 March, Barcelona Slides: https://noti.st/vikgamov/KJBdqP/a-technical-deep-dive-in-webassembly-for-kong-gateway Get ready for the ultimate API management experience! Discover the power of WebAssembly in Kong Gateway using WasmX. Learn how to build custom plugins for the latest in API management technology. Don’t miss this chance to learn from a Kong expert and take your API management to the next level! We all know WebAssembly is a game-changer in multi-language development, but have you ever wondered how to use it in your API gateway? Well, that’s where WasmX comes in. It extends Nginx to support WebAssembly in a way agnostic to virtual machines. Viktor Gamov, a principal developer advocate at Kong, will give you a sneak peek of the new support we’re adding to the Kong Gateway - the most popular open-source gateway, using WasmX, a project we’ve been working on here in Kong. Viktor will also talk about Proxy-Wasm, the emerging standard for gateway extensions using Wasm, which allows you to write filters once and use them in different gateways or meshes. In the end, we will touch on the performance aspects of WasmX and Kong Gateway.

Wasm I/O 2023 / 23-24 March, Barcelona Slides: https://docs.google.com/presentation/d/1u6DFpLF4NjCTkpELerWZQf49F_UmIWF_hCjvi2vhXRA/edit?usp=sharing WebAssembly (WASM) promises to run code in the browser from a binary (coded in Rust, Go, C, …) are fulfilled. Its qualities (speed, efficiency, security, polyglot) meant that WebAssembly could be run on a wide variety of platforms (other than the JavaScript VM) for many use cases, such as: Plugins for applications (for example, Zellij) Filters for proxies (for example, Envoy) User-defined functions for databases (for example ScyllaDB) Functions for FaaS (for example, Fermyon Platform) This is made possible by the WASI (WebAssembly System Interface) specification, which allows WASM code to be executed in various contexts. The execution of WASM modules by a Java application was until recently almost impossible or “acrobatic”, and this, even if GraalVM provides WASM support (too light and poorly or not documented). This gap is now filled by the Extism project, which allows writing WASM plugins in various languages for your Java applications. In this presentation, I will explain how to develop a Vert-x application with WASM plugins in Rust, Go and Zig. The first steps to develop a FaaS.

Wasm I/O 2023 / 23-24 March, Barcelona Slides: https://docs.google.com/presentation/d/1rM9x_XF7NKfJvG1uCdSSXcLowyZq-tUI1buHo83Dbvs/edit?usp=sharing Bacalhau (https://bacalhau.org/) is the distributed compute network from Protocol Labs (https://protocol.ai/), and open-source R&D lab building to radically improve the Internet. Bacalhau’s mission is to provide the next generation of serverless compute that can bring forth revolutions in decentralised science and distributed applications. Our goal is a global, updatable, resilient compute substrate that can run anywhere, on any device, without restrictions. WASM is the secret behind our new platform. We’ve leveraged the power of the InterPlanetary File System (IPFS) – a distributed data storage system – to build a global library of WASM tools and functions that can be run from anywhere, by anyone. Our system can automatically link together WASM modules from across IPFS, no matter where they are, and can update itself when new versions of modules become available. This all adds up to a global execution environment, running WASM, that ensures compute processing done by scientists and engineers today can be reproduced long into the future. In this talk, we’ll explain the vision and how the technology works, demonstrate the network in action and show how attendees can run their own WASM jobs on a distributed compute network without complex set up or technical challenges.

Wasm I/O 2023 / 23-24 March, Barcelona Slides: https://docs.google.com/presentation/d/1k-jxutQx0sqy7mW4Wg06Y3JmXLQCjM17mNReWyWgH1I/edit?usp=sharing&resourcekey=0-0CYXayoSrQpSCRVrjYCjgQ Support for garbage collection within WebAssembly (WASM-GC) will bring a host of new languages and frameworks to the web app space. Learn how the Dart and Flutter teams at Google are building on WASM-GC (among other upcoming standards) to bring richer, faster, more consistent applications to the web Until now, WASM-compiled browser applications have been mostly limited to systems programming languages – allowing a number of traditionally desktop experiences to run on the web. (Think AutoCad, PhotoShop, Google Earth.) The implementation of WASM-GC across WASM runtimes will bring a set of new languages and frameworks to an ecosystem dominated by C/C++ and Rust. The open source Dart and Flutter projects at Google have spent over a year adding WebAssembly as a target platform with the hope of improving application load time and interactive performance for Flutter experiences on the web. This talk will cover how WASM-GC expands the WASM ecosystem, some details on how Flutter and Dart approached migrating our existing JS-compiled web support to WebAssembly, and our hopes for a ecosystem that embraces WASM-GC across the browser and server to enable a more portable, secure, and interoperable future of computer systems.

Wasm I/O 2023 / 23-24 March, Barcelona Slides: https://wasmio-threads.netlify.app WebContainers is a Node.js-like runtime that runs entirely within your browser. Their development combines low-level hacking in (multithreaded) Wasm with a focus on delivering a reliable, functional platform. Let’s talk about how we built them, what we tried, what worked and what is yet to work! WebAssembly threads unlock a game-changing primitive for the Web and other targets. Workloads that require shared memory and parallelization can finally leverage the full power of the underlying platform. A much wanted addition to the spec that is now on its path to stabilization. Though this addition has been cooking as an experimental proposal for some time, that did not stop my team from exploiting its possibilities! We shipped WebContainers, a Node.js-like runtime that runs on your browser, years ago. The core of this engine and its performance characteristics are only possible thanks to threads, and to the versatility of the Rust ecosystem. In this talk, I’ll give you an overview of this new specification and how toolchains support it, how our use case is unique, and the bumps that we found along the road to production: what we’ve tried, what worked and didn’t work - and what is yet to work!

Wasm I/O 2023 / 23-24 March, Barcelona So, what does it mean to have maturity in software and systems? I will talk about the end-to-end WASM software lifecycle, from writing and compiling code & debugging pre-production errors, all the way to deploying systems with WASM and observability of production systems. What to do when WASM in production fails? How do you debug issues in code you don’t have the source of? How can we prevent these kinds of common issues from even happening in the first place? I will also talk about what it means to be a team of SREs, Ops, Engineers, etc. who are now tasked with maintenance of a system that has an embedded runtime or otherwise executes WASM code. This operational mode is more like being an “operating system” compared to an “application”, and how we all need to think like the teams at AWS/GCP/Azure whose services run our applications. Dylibso is building the operational tools for teams taking WASM into production, and I will showcase a couple of these products which address CI, security, quality, and resource management. I will announce our founding team as well as funding, open source projects, along with what the future holds for taking WASM seriously and bringing a level of maturity to the ecosystem that we are all looking for.

Wasm I/O 2023 / 23-24 March, Barcelona Slides: https://2023.wasmio.tech/docs/sessions/database_apps_in_webAssembly_springio23.pdf Wasm has emerged as a secure, portable, lightweight, and high-performance application runtime for cloud-native workloads such as microservices and serverless functions. However, the standard Wasm sandbox does not readily support database connections. The Wasm community has created several solutions to address the diverse use case scenarios for database applications. There are three important approaches. - Use host functions, such as Spin framework and the upcoming component model framework, to handle database connections outside of the VM and expose the data through APIs to Wasm guest apps. - Support existing database client libraries and drivers in Wasm guest apps through WASI-like socket APIs. - Embed the Wasm VM into a data pipeline and exchanged data with the Wasm guest app through shared memory space. Each of these approaches has pros and cons. In this talk, we will present examples of Wasm apps connecting to MySQL, TiDB, and Redis, databases. We will also discuss database UDF and ETL use cases built on Wasm functions.

Wasm I/O 2023 / 23-24 March, Barcelona Slides: https://2023.wasmio.tech/docs/sessions/wasm-blocks-procedural-modeling-with-micro-webassemblies-wasmio23.pdf This talk is about a crazy experiment where a DOM/DAG of nodes in a graphics application have been implemented as small Wasm modules, leading to an executable procedural model that can be streamed for an interactive experience. See it in action in interactive graphics editing and maps applications! Webassembly has become a robust tool for building client-side applications, and has recently made large advances on the backend as a tool for running distributed workloads. What about the data that lives in those applications though? In graphics editing applications, typically a DOM-like structure exists in-memory, and more interactive applications similarly store a Scenegraph/DAG of nodes. Recent advances in the graphics field involve procedural modeling techniques, essentially replacing the output of complex graphics operations with the steps to recreate the output. There are many proprietary mechanisms for doing this, but Wasm’s secure-by-default model is very compelling for the execution of arbitrary code from distributed sources. This leads to an experiment where procedural graphics nodes are compiled to Wasm (both cached, built-in functions, and user-authored nodes). They are then executed at runtime to see if we can run a massively parallel DAG in near-realtime. Applications are then shown, both of a map that can stream in procedural tiles, as well as in an interactive graphics editing application for sharing nondestructive edits. Hear some of the lessons learned from this demo, including how this technology could scale, and how it could benefit from initiatives in the Wasm ecosystem like the Component Model in the future.

Wasm I/O 2023 / 23-24 March, Barcelona Come for the async; stay for the bidirectional, reactive streams. WasmRS brings RSocket inside WebAssembly to deliver high-performance, asynchronous streaming on standard WASM. Current WebAssembly needs layer upon layer of care and consideration before you can use it in real-world applications. Jarrod has been adding, removing, and refining layers for years as he’s seen WebAssembly hit new limits. WasmRS is the latest iteration at ironing out major pain points with WebAssembly in real-world, high-performance situations. Use asynchronous, reactive streams complete with automatic fragmentation and back pressure as naturally as you would in native code. All with standard WebAssembly. This talk will show you how to build a streaming WebAssembly module in under ten lines of code. We’ll build a small wasm module that can handle gigantic files or remote streams without breaking a sweat and finish with a visual demo of wasmRS powering browser graphics.

Wasm I/O 2023 / 23-24 March, Barcelona Slides: https://docs.google.com/presentation/d/1A1EZDXgEG4lf5xZjBjRlP4SjvXZCCnJXJ1hGlIJvaVQ/edit A common use case for WASM is plugins. But setting up the infrastructure for hosting WASM plugins is tedious, and the experience of writing WASM plugins is often far from developer-friendly. fp-bindgen aims to solve these challenges for Rust developers by generating the runtime and plugin bindings. fp-bindgen is developed as an open-source project: https://github.com/fiberplane/fp-bindgen It’s goal is to make it as easy as possible to develop full-stack plugins (WASM plugins that can run in both a server-side environment and a browser) for Rust developers. Unlike wit-bindgen (a comparable bindings generator), fp-bindgen is opinionated in that it uses Rust data types as its source of truth for the plugin API. This makes it so that Rust developers don’t need to duplicate their data types to an external schema format. From those Rust data types, it can generate a Rust server runtime, Rust plugin bindings (to be used by plugin authors), and a TypeScript runtime for running the same plugins in the browser. Another difference between fp-bindgen and wit-bindgen is that fp-bindgen uses Messagepack for serialization, which allows more flexible extension of data types without breaking plugins that use an older version of the plugin API.

Wasm I/O 2023 / 23-24 March, Barcelona Slides: https://2023.wasmio.tech/docs/sessions/the-world-of-wasi-wasmio23.pdf WASI Preview2 is the name for the next major iteration of the WASI Command APIs in development, including WASI filesystem, and now also including WASI sockets. Based on the new Wit IDL, they offer much better bindings for non-C-like languages, much better virtualizability, and establish some important infrastructure for future WASI evolution. And, they have much more complete documentation, including some demos that you can run yourself to see how everything works. I’ll talk about the new features and design changes and show off some demos! WASI HTTP and WASI Cloud are two families of WASI proposals in development that show how WASI is about more than just POSIX APIs. I’ll talk about these new APIs, and I’ll discuss Worlds, and the infrastructure we’re building to all users and embedders to use just the APIs they need for their use cases. And finally, I’ll discuss the future of WASI. The Component Model gives us powerful new tools for composability, virtualizability, typed interfaces, and more. What will it look like as we built out more of the System Interface with these tools? I’ll give a brief tour of the future as it looks like with these tools in hand!

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.

Wasm I/O 2023 / 23-24 March, Barcelona Spin is an open-source runtime for WebAssembly microservices. It has built-in functionality for HTTP, but what if you want to handle other kinds of event - timers, say, or queues? In this code-oriented talk, I’ll show how to extend Spin to turn it into the serverless substrate of your dreams. Spin provides microservice developers with a very simple environment. Rather than needing to involve themselves in infrastructure, they need only write a module that conforms to a WIT (Wasm Interface Type) declaration, and Spin handles the rest. For the common case of Web-based microservices, which are triggered by HTTP requests, Spin has all the infrastructure built in. But serverless environments such as AWS Lambda or Azure Functions provide a much wider set of triggers - queue messages, blob storage events, or database table writes. Fortunately, Spin’s extensibility model allows you to plug in additional triggers, and even to write your own. This talk dives into the workings of the Spin trigger system, walks through the process of building a custom trigger, and discusses some of the patterns and considerations for doing so.

Save the date and meet the WebAssembly community: 21-22 March 2024!