The Art of 64-Bit Assembly Returns, Aimed at Your Runtime

Randall Hyde has been teaching people assembly since the mid-'90s, when The Art of Assembly Language circulated as a free 16-bit DOS text before No Starch turned its HLA-based descendants into print editions. The 2021 64-bit rewrite, The Art of 64-Bit Assembly, Volume 1, dropped Hyde's homegrown High Level Assembly for plain MASM and covered the x86-64 instruction set proper. Now Volume 2 — Machine-Level OOP, Exceptions, and Concurrency — lands August 18, and it hit the Hacker News front page this week on a preorder page alone. That's a signal worth reading correctly.

Because this isn't another "learn assembly" book. At 792 pages and $79.99, Volume 2 is about something rarer: how the constructs you use every day in C++, Python, or Rust are actually implemented once the compiler and runtime are done with them. Vtables and method dispatch. Windows structured exception handling. Closures and thunks. Coroutines, generators, and fibers. Synchronization primitives. That's the runtime layer — the machinery between your source code and the instruction stream — and almost nobody writes book-length treatments of it.

Reading assembly is the job now

The predictable HN objection showed up on schedule: compilers beat hand-written assembly, LLMs can explain any instruction sequence, why bother? It misunderstands what this knowledge is for.

Hardly anyone writes application assembly anymore, and Hyde isn't really pitching that. But an enormous amount of serious work involves reading it. Debug an optimized release build from a crash dump and there's no friendly source line — there's a register state, a mangled stack, and a vtable pointer that may or may not be garbage. Profile a hot loop and the answer to "why is this slow" lives in the generated code, not in your source. The entire Compiler Explorer culture exists because working engineers constantly need to check what the compiler actually emitted. And hand-written assembly isn't quite dead either: FFmpeg still writes its SIMD kernels by hand and considers the wins large enough that the project published its own assembly lessons to recruit contributors.

The AI angle cuts the opposite way from the skeptics' version. If an LLM generates or explains low-level code for you, you're the verification layer — and machine-level claims are precisely where plausible-but-wrong is hardest to catch. Several HN commenters made this point concretely: a model will happily produce a vtable layout that looks right and violates what the platform ABI actually expects. The less code you write by hand, the more your value concentrates in knowing ground truth the tools can fake. That's the layer this book covers.

There's also a simple scarcity argument. Instruction-set references are abundant — Intel's manuals, Agner Fog's optimization guides, a thousand tutorials. But how exception unwinding actually walks the stack, how a fiber switch saves and restores context, how inheritance turns into pointer arithmetic — that knowledge mostly lives in scattered blog posts, compiler source, and the heads of runtime engineers. Consolidating it in one edited volume is genuinely useful, even if you never open MASM.

The Windows problem is real

Now the honest caveat, which dominated the HN thread for good reason: this is a Windows book. MASM syntax, the Windows x64 calling convention, and — most restrictively — structured exception handling, which is a Windows-specific mechanism with no Linux counterpart. If your world is Linux perf tooling or an Apple Silicon laptop, a chunk of this material describes someone else's operating system, and x86-64 itself is no longer the only architecture that matters with ARM eating both the datacenter and the desktop.

Two things soften that. First, the concepts transfer better than the syntax: vtable dispatch, closure capture, and atomic-based synchronization work the same way in spirit under System V ABI on Linux; you're relearning calling conventions, not mental models. Hyde's companion site already ships NASM, Gas, and macOS translations of Volume 1's code, though nothing equivalent has been announced for Volume 2. Second, for one large audience the Windows focus is a feature, not a bug: reverse engineers, malware analysts, game-engine and anti-cheat developers, and anyone doing Windows crash forensics lives in exactly this territory. SEH internals are bread-and-butter knowledge in security work, and good written references for them are scarce.

Who should actually buy it

If you debug optimized native code, do performance work on x86-64 servers, or touch Windows internals and security, this is plausibly the only current book that walks the runtime layer end to end at the instruction level, and the preorder interest reflects that gap. Work through it next to Compiler Explorer — write the C++, predict the codegen, check yourself — and it'll sharpen instincts that no amount of prompt engineering replaces.

If you're Linux-first or ARM-first, it's a harder sell at $80. You'd be mentally translating constantly, and pairing Volume 1's free code translations with Agner Fog's manuals and FFmpeg's lessons gets you much of the way for nothing. My read: the book's thesis — that the runtime layer is where durable low-level value now lives — is exactly right, and its platform framing is about five years behind where its audience is heading. Volume 3 should be ARM. There's no sign one is planned.