The Art of 64-Bit Assembly, Volume 2 Machine-Level OOP, Exceptions, and Concurrency (Randall Hyde)（Z-Library）

【One-Line Pitch】 A hands-on guide that rebuilds the machinery behind modern programming—objects, exceptions, closures, coroutines, and threads—directly in MASM on Windows, so you can see exactly what the runtime normally hides. Read it if you already know x86-64 assembly and want to stop taking the hard parts on faith. 【Book Arc】 - **Opening (~0%–10%)**: Sets expectations and prerequisites, then moves into advanced macro programming and Unicode string handling—the tooling and text foundations later chapters depend on. - **Early (~10%–30%)**: Covers transcendental math via the FPU, advanced procedure mechanics (lexical nesting, static links, displays, parameter-passing schemes), and the start of concurrent programming with Windows threads and synchronization primitives. - **Middle (~30%–55%)**: The object-oriented core: classes, virtual method tables, method dispatch, inheritance, multiple inheritance and the diamond problem, plus a macro toolkit for declaring MASM classes. - **Late (~55%–80%)**: Exception handling—Windows structured exception handling, stack unwinding, and how exceptions interact with iterators and coroutines. - **Ending (~80%–100%)**: Higher-order and control-flow constructs: iterators, coroutines, generators, fibers, fiber-local storage, and the closing reference appendices. 【Key Takeaways】 - **The book is about programming, not optimization** (Early): Hyde explicitly defers optimization to a future volume; the goal here is understanding constructs, not squeezing cycles. - **Objects are just data plus function pointers** (Middle): vtables, the `this` pointer, and dispatch are built by hand, exposing what C++ compilers actually emit and what Windows expects. - **Exception handling is stack mechanics** (Late): SEH is installed and managed at the instruction level, making unwinding a concrete, traceable operation rather than a language feature. - **Concurrency needs real primitives, not abstractions** (Early): Critical sections, events, mutexes, semaphores, atomic instructions, the lock prefix, and memory fences are all presented directly. - **Higher-order behavior is achievable in assembly** (Ending): Thunks, closures, iterators, coroutines, generators, and fibers are implemented without resorting to HLL code. - **Unicode is where most code gets it wrong** (Opening): String handling is treated as a correctness problem at the byte level, not a library call. - **MASM macros are a language of their own** (Opening/Middle): Advanced macro programming and domain-specific macro languages are built from first principles, including the class-declaration macros. - **Prerequisites are real** (Early): The book assumes Volume 1 or equivalent MASM/Visual Studio fluency; examples build on prior library code. 【Reading Tips】 - Deep-read the OOP and exception chapters (Middle–Late); these are the conceptual payoff and the hardest to reconstruct from memory. - Skim the transcendental-function chapter if you don't need FPU math—it's self-contained and detailed. - Keep MASM and Visual Studio open; the listings are compilable and the build commands are given, so type and run rather than just read. - Treat the macro chapters as reference material you'll return to when building your own class or iterator macros. - Watch the typography conventions (registers in caps, logic functions vs. instructions) to avoid misreading prose as code. 【Coverage Limits】 The excerpts cover the table of contents, introduction, and front matter thoroughly, but do not include the actual body text of most chapters, so specific code examples and detailed explanations are not summarized here.