The Art of 64-Bit Assembly, Volume 2: Machine-Level OOP, Exceptions, and Concurrency

Advanced 64-Bit Assembly, Beyond the Basics 💻

Randall Hyde’s The Art of 64-Bit Assembly, Volume 2 picks up where the first volume left off, moving from fundamental instructions and data representation into the advanced topics that make low-level programming both challenging and powerful. This book is not a gentle introduction; it assumes you already understand basic x86-64 assembly and are ready to explore the deeper mechanics of modern software.

What This Volume Explores

Across eleven chapters and three appendices, Hyde examines the techniques that professional assembly programmers use to build robust, high-performance systems. The material progresses logically from powerful macro and Unicode string processing through advanced procedure design, then into concurrency, object-oriented programming, and exception handling.

• Advanced Macros: Learn to create reusable, flexible macro abstractions that reduce tedious repetition and improve code clarity.
• Unicode Strings: Work with character encodings beyond ASCII, a critical skill for modern international software.
• Transcendental Functions: Implement floating-point math routines such as sine, cosine, and logarithm at the machine level.
• Concurrent Programming: Understand threads, synchronization, and the low-level primitives that support parallel execution.
• Object-Oriented Programming with MASM: See how classes, objects, inheritance, and polymorphism can be constructed directly in assembly.
• Exception Handling: Build structured error handling mechanisms without the safety net of a high-level language runtime.
• Thunks and Closures: Create dynamic code constructs that enable late binding and functional programming patterns.
• Advanced Parameter Implementation: Gain finer control over calling conventions and parameter passing.
• Iterators, Coroutines, Generators, and Fibers: Explore control-flow abstractions that simplify complex state machines and cooperative multitasking.

Why These Topics Matter

Many programmers think of assembly as a relic of the past, but in domains like embedded systems, real-time software, and performance-critical kernels, low-level control remains essential. Understanding how OOP, exception handling, and concurrency actually work under the hood gives you deeper insight into compiler behavior, debugging, and optimization—knowledge that pays off even when you write in higher-level languages.

Practical MASM Focus 🛠️

All examples use Microsoft Macro Assembler (MASM), and an appendix walks through installing and using Visual Studio, the standard development environment for Windows assembly. The code is grounded in realistic scenarios, not abstract snippets, so you can immediately experiment and adapt the techniques to your own projects.

Who Should Read This Book

This volume is ideal for:

• Programmers who have completed an introductory assembly course or studied The Art of 64-Bit Assembly, Volume 1
• Developers working on performance-critical or embedded systems where low-level control is necessary
• Experienced coders who want a deeper understanding of how modern language features are implemented on x86-64 processors
• Hobbyists and students interested in the elegant machinery beneath their programs

Hyde’s teaching background and decades of industry experience make even the most complex material approachable, with careful explanations and a consistent focus on practical application.

From Concepts to Machine Code

Whether you are extending your low-level skills for professional work, deepening your understanding of computer architecture, or simply satisfying curiosity about how software really works at the hardware level, this volume offers a thorough, hands-on guide. Grab your digital copy and start turning high-level concepts into precise, efficient x86-64 assembly.