The JVM vs. WebAssembly: An In-Depth Comparative Analysis

This session contrasts, in extreme detail, the Java Virtual Machine (JVM) and WebAssembly (Wasm), two platforms that have reshaped the landscape of software development. While their basic architecture of a "virtual machine" draws parallels, their design, intentions, bytecode formats, and future directions reveal considerable differences.

Differences in Intent and Bytecode Adaptations

We'll examine the underlying intentions behind the creation of the JVM and WebAssembly. While the JVM was initially designed to support the Java language, it has since accommodated other languages like Scala, Groovy, and Kotlin, and has been provided with implementations for dynamic languages like Ruby and Python. WebAssembly, on the other hand, was designed from the outset to support multiple languages, aiming to serve as a compact binary format for the web. We'll analyze how these intentions have influenced the way other languages have been adapted to their respective bytecode formats, by carefully examining the pain points found in JVM and Wasm implementations across the same source languages

Bytecode Differences, Implementation, and Control Flow

Here we will delve into the technical details of each platform's bytecode. While the JVM uses stack-based bytecode, WebAssembly uses a structured stack machine model. The implications of these different approaches will be discussed, with particular attention to aspects like performance, security, and portability. We'll also explore their respective implementations and control flow mechanisms through the use of detailed code examples, as well as high-level expositions.

Standardization Processes, Stakeholders, and Incentives

An important part of this talk will focus on the standardization processes of both the JVM and WebAssembly. While the JVM’s specification is controlled by Oracle, with community input through the Java Community Process (JCP), WebAssembly is an open standard developed by the World Wide Web Consortium (W3C). We'll discuss the various stakeholders involved in each process and explore the incentives that drive the evolution of these systems.

The Future of WebAssembly

We'll discuss the future direction of WebAssembly, touching on upcoming proposals such as garbage collection, and the Component Model. Additionally, we'll look at the development of runtimes like Wasmtime, the WebAssembly Micro-Runtime (WAMR), and GraalWasm, and discuss how these work to extend the reach of WebAssembly in new and interesting ways

JVM and the Universal Compilation Target

In our closing discussion, we'll tackle the common assertion that WebAssembly is "just the JVM again", and explore why the JVM didn’t quite become the universal compilation target it was often touted years ago. Factors such as the JVM's resource usage, security issues, specific design details have all played a part, and we'll discuss how and what WebAssembly has learned from these challenges.

This session's ultimate goal is to give attendees a detailed understanding of the JVM and WebAssembly, enabling more informed decisions in software development and a clearer perspective on the futures of these two technologies.