Wasm Hot Takes: Explore Controversial Proposals & Bold New Features | Ep22 | WebAssembly Unleashed

Key Concepts

• WebAssembly (Wasm): A binary instruction format for a stack-based virtual machine.
• Proposals (Phase 0-5): Stages of development for new WebAssembly features, ranging from initial ideas (Phase 0) to features considered complete but not yet merged into the specification (Phase 5).
• Tail Call Optimization: A compiler optimization that eliminates the overhead of a function call when the last action of a function is a call to another function (or itself).
• Extended Constant Expressions: Allows simple arithmetic operations on global variables during initialization.
• Typed Function References: Function references with explicit type signatures, enabling static type checking.
• Garbage Collection (GC) Proposal: Adds support for garbage-collected languages in WebAssembly.
• Multiple Memories: Allows a WebAssembly module to access multiple linear memory spaces.
• SIMD (Single Instruction, Multiple Data): A type of parallel processing where a single instruction operates on multiple data points simultaneously.
• Relaxed SIMD: A variation of SIMD that relaxes certain compute requirements for performance gains.
• Branch Hinting: A mechanism to provide hints to the engine about which branch is likely to be taken.
• JS String Builtins: Built-in functions for manipulating JavaScript strings within WebAssembly.
• Memory64: Support for 64-bit memory addressing in WebAssembly, allowing access to more than 4GB of memory.
• Threads: Support for multi-threading in WebAssembly, including atomics for shared memory access.
• JSPI (JavaScript Promise Integration): Allows WebAssembly functions to seamlessly integrate with JavaScript promises for asynchronous operations.
• Web Content Security Policy (CSP) Enhancement: Fine-grained control over the operations necessary to validate the WebAssembly object.
• Component Model: A system for composing WebAssembly modules into larger applications.

Phase Five Proposals (Considered Done, Not Yet Merged)

Tail Call Proposal

• Main Point: Enables tail call optimization, important for functional programming.
• Details: Oscar, a functional programming enthusiast, uses tail calls extensively. Pat mentions that LLVM-based languages don't often emit tail calls, limiting its widespread use.
• Implementation Challenges: Ensuring perfect implementation requires extensive production use and interaction with other system components like the register allocator.
• Quote: Oscar: "I emit a tail call every single place it is valid to do so."

Extended Constant Expressions

• Main Point: Allows simple arithmetic operations on global variables during initialization.
• Details: Enables initializing globals with values derived from other globals or imported globals using basic operations like addition and subtraction.
• Limitations: No control flow or complex operations like tail calls are allowed.

Typed Function References

• Main Point: Introduces function references with explicit type signatures.
• Details: Enables static type checking, preventing runtime traps due to incorrect function types. Supports basic WebAssembly types (I32, I64, F32, F64, V128 with SIMD).
• Benefits: Aids static analysis and improves safety by ensuring type correctness at compile time.
• Connection: Related to the garbage collection proposal, which introduces more complex reference types.

Garbage Collection (GC) Proposal

• Main Point: Adds support for garbage-collected languages in WebAssembly.
• Details: Enables languages like Java to run more efficiently on WebAssembly. Includes exception handling.
• Limitations: Doesn't allow dynamic modification of object types at runtime.
• Controversy: Debate over the definition of "garbage collection" and whether the proposal goes far enough. The proposal doesn't provide a specific garbage collector implementation.
• Quote: "Garbage collection is just another name for your mom telling you to clean your dang room cuz what do we live in? A barn."

Multiple Memories

• Main Point: Allows a WebAssembly module to access multiple linear memory spaces.
• Details: Important for the component model, enabling the composition of modules with separate memories.
• Use Cases: Primarily useful when interacting with other modules, not for standalone programs.
• Explanation: Addresses the limitation where a WebAssembly instance can only refer to one memory (either imported or defined).

Relaxed SIMD

• Main Point: A variation of SIMD that relaxes certain compute requirements for performance gains.
• Details: Allows hardware to use longer representations without rounding intermediate values, potentially improving performance.
• Considerations: May introduce non-determinism in some cases.

Custom Annotation Syntax in the Text Format

• Main Point: Affects only the text format of WebAssembly, not the core functionality.

Branch Hinting

• Main Point: Provides hints to the engine about which branch is likely to be taken.
• Concerns: Doubts about its effectiveness with modern computers. May lead to an over-reliance on hints, potentially complicating the specification.

Exception Handling

• Main Point: Enables exception handling in WebAssembly.
• Connection: Works with the garbage collection proposal.

JS String Builtins

• Main Point: Built-in functions for manipulating JavaScript strings within WebAssembly.
• Concerns: Primarily focused on JavaScript in the browser, potentially fracturing the ecosystem. May not be supported by all runtimes.
• Compromise: The proposal was modified to reduce the burden on non-browser engines.
• Quote: "If you have a web assembly information anywhere, you'd better have a full browser grade implementation of JavaScript strings."
• Component Model Impact: The component model may mitigate some of the fracturing concerns by providing a way to represent different string types.

Memory64

• Main Point: Support for 64-bit memory addressing in WebAssembly.
• Details: Allows access to more than 4GB of memory.
• Use Cases: Image processing (e.g., handling large DICOM files), Adobe Photoshop.
• Performance: Slower than Wasm32 due to the overhead of 64-bit pointers and bounce checks.

Phase Four Proposals (Standardization in Progress)

Threads

• Main Point: Support for multi-threading in WebAssembly, including atomics for shared memory access.
• Limitations: Doesn't include a way to create threads. Thread creation is left to external mechanisms (e.g., JavaScript in the browser).
• Usability: Usable on the web, but requires engine-specific magic to spawn threads.
• Atomics: Provides a memory model for shared memory access between threads.

JSPI (JavaScript Promise Integration)

• Main Point: Allows WebAssembly functions to seamlessly integrate with JavaScript promises for asynchronous operations.
• Benefits: Improves integration with JavaScript, making WebAssembly more usable for JavaScript developers. Reduces the need for workarounds like asyncify.
• Problem Solved: Addresses the issue where WebAssembly programs needing to perform IO had to return instead of calling into an import function.

Web Content Security Policy (CSP) Enhancement

• Main Point: Fine-grained control over the operations necessary to validate the WebAssembly object.
• Concerns: Content security policies are complex and often not used, making adoption difficult.

Conclusion

The discussion covers a wide range of WebAssembly proposals, highlighting their potential benefits, limitations, and controversies. The proposals aim to enhance WebAssembly's capabilities, improve integration with other technologies, and expand its applicability to various use cases. The speakers express varying opinions on the proposals, reflecting the ongoing evolution and debate within the WebAssembly community. The component model is frequently mentioned as a key factor influencing the design and adoption of these proposals.