Practical WebAssembly Explore the fundamentals of WebAssembly programming using Rust (Sendil Kumar Nellaiyapen)（Z-Library）

【One-Line Pitch】 A hands-on tour of the Rust and WebAssembly toolchain for JavaScript developers who want native-level performance without leaving the JS ecosystem. Best for readers who already write JavaScript and are curious how C/C++/Rust code becomes a sandboxed WASM module. 【Book Arc】 - **Opening (~0%–15%)**: Frames the problem — why WebAssembly exists, what it buys you over plain JavaScript, and who the book is for. Introduces LLVM as the shared compiler backbone behind every WebAssembly toolchain, with Clang as the working example. - **Early (~15%–35%)**: Gets you compiling. Emscripten and its SDK are installed and driven end-to-end, from a small C/C++ function to a runnable module in Node.js, including the binding file that translates values between JS and WASM and the optimization flags (-O1 through -Os) that trade compile time for binary size. - **Middle (~35%–55%)**: Moves to the module itself and the tooling around it. The WebAssembly text format and binary structure are unpacked, then WABT is used to convert between WAST, WASM, C, and JSON, with options like expression folding and the runtime scaffolding (traps, stack depth, memory checks) shown in generated C. - **Late (~55%–80%)**: Shifts into the Rust and WebAssembly ecosystem — installing the toolchain, writing Rust that targets WASM, and wiring it into JavaScript so the two languages cooperate in one application. (Excerpts do not cover the specific chapter contents here in detail.) - **Ending (~80%–100%)**: Closes on shipping and operating: debugging WASM, choosing the right optimization tools, and delivering performant applications. (Excerpts do not cover the closing chapters in detail.) 【Key Takeaways】 - **WebAssembly is a compilation target, not a language you write by hand** (Opening): it is statically typed, precompiled, and sandboxed, which is where its speed and small binaries come from. - **LLVM is the common denominator** (Opening): Rust, C, and C++ all reach WASM through LLVM, so understanding the compiler pipeline explains why the toolchain looks the way it does. - **Emscripten is the bridge from C/C++ to the browser** (Early): it produces both asm.js and WASM output, and its binding file handles the encode/decode translation between JavaScript values and WebAssembly values. - **Optimization flags are a size/speed dial you actually control** (Early): the excerpts show -O0 through -Os shrinking a WASM binary from roughly 13 KB down to about 2 KB, with compile time rising as you push further. - **The text format is readable, the binary is what ships** (Middle): WAT/WAST exists for humans; WABT's wat2wasm and wasm2wat let you move between the two, and wasm2c even emits C. - **WASM modules are validated before they run** (Early): decoding, validation, compilation, and execution are distinct phases, and type-checking during validation is what keeps the sandbox safe. - **Rust is the recommended authoring language** (Late): the book positions Rust's safety and concurrency alongside WASM's portability, with the ecosystem handling build and ship. - **Debugging and tooling are first-class concerns** (Ending): the stated goal is not just writing WASM but knowing which tool to reach for when optimizing or troubleshooting. 【Reading Tips】 - Skim the LLVM and compiler-theory material on a first pass; return to it when a build error or an unfamiliar flag confuses you. - Deep-read the Emscripten and WABT chapters with a terminal open — the value is in running the commands and inspecting the generated files yourself. - Treat the optimization-flag walkthrough as a template: reproduce the size measurements on your own code before trusting any rule of thumb. - If you already know Rust, move quickly through the language introduction and spend the time on the JS/WASM interop boundary instead. - Keep the binary-format sections as reference rather than memorization; you will consult them when debugging, not when writing application code. 【Coverage Limits】 This guide is built from stratified excerpts covering roughly the first half of the book plus the front matter; the Rust-specific and shipping/debugging chapters are only visible through the table of contents and blurb, so their concrete content is not summarized here.