Practical WebAssembly (Sendil Kumar Nellaiyapen)（Z-Library）

【One-Line Pitch】 A hands-on tour of WebAssembly for web and Node.js developers who already know JavaScript and want to compile Rust (and C/C++) into fast, type-safe modules. It walks the full toolchain—from LLVM and Emscripten through WABT, Binaryen, wasm-bindgen, and wasm-pack—so you can build, bundle, and optimize real wasm. 【Book Arc】 - **Opening (~0%–15%)**: Sets up the "why" of WebAssembly—JavaScript's dynamic typing and unpredictable performance—and frames wasm as a statically typed, precompiled, near-native alternative. Introduces the toolchain landscape and how the book is organized. - **Early (~15%–35%)**: Builds compiler fundamentals: how compilers work (frontend/optimizer/backend), what LLVM IR is, and why nearly all wasm compilers sit on LLVM. Then introduces Emscripten/emcc and emsdk for turning C/C++ into wasm and asm.js. - **Middle (~35%–60%)**: Moves into the wasm module itself—text format (WAST), the binary format, and the sections (imports, exports, globals, start, memory). Covers the WebAssembly Binary Toolkit (WABT) and Binaryen for converting, validating, disassembling, and optimizing modules. - **Late (~60%–85%)**: Shifts to Rust: compiling Rust to wasm via rustc, Cargo, and wasm-bindgen; bundling with webpack, Parcel, and wasm-pack; and crossing the Rust↔JavaScript boundary (classes, closures, JS APIs, web APIs). - **Ending (~85%–100%)**: Optimization focus—shrinking wasm modules, understanding the memory model, sharing memory between JS and Rust, and analyzing module size with Twiggy (top, monos, garbage). 【Key Takeaways】 - **WebAssembly's core promise is predictable, type-safe performance** (Opening): because wasm is statically typed and precompiled, it avoids the runtime type assumptions that make JavaScript performance erratic—useful when you need consistent speed. - **LLVM is the shared foundation under almost every wasm compiler** (Early): understanding the frontend/optimizer/backend split and LLVM IR explains how Rust, C, and C++ all reach wasm, and why learning one toolchain transfers to others. - **Emscripten is the C/C++ on-ramp** (Early): emcc compiles C/C++ to LLVM IR and then to wasm or asm.js, with emsdk managing versions and runtime setup—key if your existing code is native C/C++. - **The wasm binary is structured, not opaque** (Middle): modules are organized into sections (imports, exports, globals, start, memory), and tools like WABT and Binaryen let you inspect, convert, validate, and optimize them. - **Rust is the book's primary language for authoring wasm** (Late): rustc, Cargo, and especially wasm-bindgen provide the practical path from Rust source to a usable wasm module. - **wasm-pack and bundlers make wasm shippable** (Late): wasm-pack plus webpack/Parcel handle the packaging and publishing work so wasm integrates into normal web build pipelines. - **The Rust↔JS boundary is where the real work happens** (Late): sharing classes, calling closures, importing JS functions, and reaching web APIs via wasm-bindgen, js-sys, and web-sys are the integration skills that matter. - **Optimization is a distinct discipline** (Ending): minimizing module size, reasoning about the memory model, sharing memory between JS and Rust, and profiling with Twiggy turn a working module into a fast one. 【Reading Tips】 - **Skim the compiler/LLVM theory if you only want to ship code**, but deep-read the LLVM IR section if you plan to write your own language frontend or debug compilation output. - **Treat the tooling chapters (WABT, Binaryen) as reference**: read once for orientation, then return when you need to inspect or shrink a specific module. - **Do the Rust chapters hands-on**—install Rust and Node.js first, and type the examples rather than copy-pasting, since the boundary-crossing code is where mistakes surface. - **Don't skip the optimization chapter**: memory sharing and Twiggy analysis are the difference between a demo and a production-ready module. - **Keep the book's GitHub repo open** alongside the text for the example code files. 【Coverage Limits】 This guide is synthesized from stratified excerpts covering the front matter, table of contents, and early-to-middle chapters; the later Rust, bundling, boundary-crossing, and optimization chapters are represented mainly through their headings, so specific code details there are not covered.