A Programmer’s Guide to x86-64 Assembly (Series Overview)

Welcome to my ongoing series on x86-64 assembly programming, designed for programmers who want to peel back the abstraction and understand how code really runs at the machine level.

Why should a software engineer care about assembly? Because understanding what's happening at the lowest level helps you write better code at every level. It sharpens your intuition about performance bottlenecks, compiler behavior, memory usage, and even security. Whether you're debugging a weird bug, chasing a perf regression, or just curious how high-level constructs boil down to machine instructions, assembly is the Rosetta Stone.

We start from first principles, covering bits, memory, and CPU instructions, and gradually build up the skills to read and write real-world assembly programs. Whether you're interested in systems programming, performance tuning, or just curious about what your compiler is really doing under the hood, this series is for you.

---

Published Posts

1. Understanding Computer Organization from First Principles
   Bits, memory, and the logic behind modern computing. A gentle dive into the foundations.

2. Binary Arithmetic and Bitwise Operations for Systems Programming
   Signed numbers, two's complement, masking tricks, and bit-level manipulations that matter.

3. The System-Level Foundation of Assembly
   How your code goes from main() to a running process, and where assembly fits in.

4. Building (and Breaking) Your First X86 Assembly Program
   A minimal working program from scratch, with no runtime or C library. Learn by breaking it apart.

5. Debugging X86-64 Assembly with GDB
   Hands-on debugging walkthroughs to inspecting registers, memory, and control flow.

6. Making System Calls in x86-64 Assembly
   How to interact with the operating system directly using syscalls without a C runtime.

---

Upcoming Topics

Here’s a peek at what’s planned for future posts (subject to change based on feedback and curiosity):

• Registers, stack, and calling conventions

• Memory addressing and pointer arithmetic

• Writing loops and conditionals in pure assembly

• Implementing functions and recursion

• A deeper dive into Linux syscalls (file I/O, process management, etc.)

• Mini-project: writing a simple command-line utility

• Capstone: building a minimal web server in assembly

---

You can subscribe to get new posts as they drop. I’m writing this series with care, making sure each part builds up your intuition as well as your skillset. Feel free to share, comment, or ask questions.