CoderMusings publishes in-depth systems programming tutorial series on low-level development — covering assembly language, compiler internals, binary analysis, and OS internals. Each systems programming tutorial series builds from first principles, with real assembly output, debugger sessions, and working code you can run yourself.
Assembly Series — Systems Programming Tutorial
A ground-up exploration of x86-64 and ARM64 assembly across Linux, macOS, and Windows. This systems programming tutorial series covers everything from writing your first syscall to building a working debugger from scratch. No prior assembly experience required — each post builds directly on the previous one.
- Assembly Hello World: A Cross-Platform Syscall Deep Dive — Write, assemble, and run Hello World using raw syscalls on Linux and macOS across x86-64 and ARM64.
- Windows Assembly Toolchain: The Native MASM Guide — Set up ml64.exe and armasm64.exe; understand the key syntax differences between AT&T and Intel.
- Assembly Hello World: Windows Edition (x64 & ARM64) — Build Hello World on Windows using both Kernel32 APIs and direct syscalls.
- x86-64 & ARM64 Calling Conventions Demystified — Master System V, Windows x64, and AAPCS64 parameter passing, register preservation, and stack rules.
- Stack Frames & Function Prologues Demystified — Trace exactly what happens to the stack on every function call across all three platforms.
- Executable File Formats: ELF, PE, and Mach-O Explained — Dissect the binary containers your OS actually loads and executes.
- Process Loading & Creation: The Life of a Binary — Follow a program from disk to first instruction, covering the OS loader, ASLR, and dynamic linking.
- Dynamic Linking & Relocations: How the GOT and PLT Work — Understand lazy binding, the Global Offset Table, and the Procedure Linkage Table.
- System Calls Demystified: 4 Essential Facts About the User-Kernel Bridge — How the
syscallinstruction works, kernel mode transitions, and cross-OS differences. - Build a Debugger from Scratch: Ultimate 3 OS Guide — Implement a working debugger using ptrace (Linux), task_for_pid (macOS), and DebugActiveProcess (Windows).
Compiler Internals Series — Systems Programming Tutorial
A complete systems programming tutorial series tracing the modern compiler pipeline using Clang/LLVM and GCC as reference implementations. Follows a C source file from raw text all the way to linked binary, with Godbolt Compiler Explorer examples at every stage. Culminates in building a working toy compiler from scratch in C.
- How a C Program Becomes Machine Code: The C Compilation Process Explained — Trace preprocessing, compilation, assembly, and linking with real GCC and Clang output.
- Compiler Lexer & Parser Demystified: How Compilers Read Your C Code — Hands-on with Clang’s
-dump-tokensand-ast-dumpon real C examples. - LLVM IR Tutorial: The Hidden Language Between Your C Code and Assembly — Master SSA form, basic blocks, and PHI nodes with real Clang IR output.
- The Ultimate Guide to Compiler Optimization Passes: Boosting Performance with -O2 — What constant folding, dead code elimination, inlining, and vectorization actually do to your binary.
- Compiler Code Generation: How LLVM Turns IR into x86-64 and ARM64 Assembly — Instruction selection, GlobalISel, and the backend pipeline explained.
- Register Allocation in Compilers: How Variables Fit into CPU Registers — Graph coloring, spilling, and rematerialization with real Godbolt examples.
- Linker Explained: How Object Files Become Executables (Static & LTO) — Symbol resolution, relocation records, static vs dynamic linking, and Link-Time Optimization.
- Write a Compiler from Scratch in C: Build a Working Toy Compiler — Hand-written lexer, recursive descent parser, and x86-64/ARM64 code generator in C.
Browse all Compiler Internals posts →
About This Systems Programming Tutorial Series
Every systems programming tutorial series on CoderMusings shares the same design principles: all code is tested and working, tool versions are pinned, and explanations cover not just how but why. We prioritize reproducibility — you can follow every post step by step on your own machine. For quick reference material to complement these series, see the Resources section.