The Architecture of 64-Bit Assembly: A Practical Guide to x86-64 Registers, Memory, Instructions, Calling Conventions, and Low-Level Systems Programming (Engineering)

Ever stared at a program that's mysteriously slow, crashed with no clear reason, or "worked on my machine" and not the next one — and wished you could actually see what your computer was doing instead of guessing?

That's the gap this book closes.

Every piece of software you've ever run, no matter what language it was written in, eventually becomes a sequence of raw instructions executed by a processor. Most programmers never see that layer. They write code, trust the compiler, and move on. That's fine — until the day it isn't. Until the bug that only shows up under load. Until the interview question about how a function call actually works underneath. Until you need to understand why a piece of security research works the way it does, or why your "optimized" code isn't actually faster at all.

This book is for the moment you decide you're done guessing.

The Architecture of 64-Bit Assembly is a complete, practical walkthrough of how modern 64-bit processors actually execute the code you write — built from the ground up, with no assumption that you've touched assembly language before. You'll start with the basics: how a source file becomes a running program, how binary and hexadecimal actually work, and how negative numbers are represented at the hardware level. From there, the book moves steadily into registers, memory addressing, the core instruction set, and the mechanics of function calls — the exact things every higher-level language is quietly doing on your behalf, every single time you run a program.

But this isn't a dry reference manual. Every chapter is built around real, working code you can actually assemble and run yourself, using free, widely available tools. You'll write programs that talk directly to the operating system. You'll build a linked list by hand, using nothing but pointers and raw memory. You'll implement your own simplified memory allocator and compare it against the real thing. You'll write a minimal bootloader and watch it run in an emulator. You'll profile actual code, measure where the time really goes, and fix it — not because a tutorial told you to, but because you finally understand why it was slow in the first place.

Here's what makes this book different from a lot of what's out there: it doesn't stop at syntax. It connects assembly language to the things you'll actually use it for — reading disassembled code when you're debugging something serious, understanding how security vulnerabilities like buffer overflows actually happen at the register level, working with SIMD instructions for real performance gains, calling assembly routines directly from C, C++, and Rust, and reasoning about concurrency and atomic operations the way systems engineers actually do.

By the end, you won't just know what a register is. You'll be able to open a debugger, step through a function you've never seen before, and tell me exactly what it's doing — and why.

Who is this book for?

A dedicated look at security-relevant topics: how memory corruption vulnerabilities actually happen, and the specific hardware and software protections built to stop them

Hands-on chapters on debugging, profiling, and optimization — using real tools, on real code, with real measurements

Four complete, worked case studies: a bootloader, a memory allocator, a performance-optimization walkthrough, and a side-by-side comparison of how two different compilers translate the same code

A full appendix section for ongoing reference — instruction tables, register charts, calling convention comparisons, and a glossary you'll actually come back to

This is the book I wish someone had handed me when I first realized that "the compiler handles it" wasn't a good enough answer anymore. If that sounds like where you are right now, you're in the right place. Let's go see what your computer has actually been doing this whole time.