Writing a C Compiler Build a Real Programming Language From Scratch (Nora Sandler)（Z-Library）

【One-Line Pitch】 A hands-on project book that takes you from a bare-bones C compiler to a working x64 code generator, one feature at a time. Best for programmers who learn by building and want to demystify compilers without a formal course. 【Book Arc】 - **Opening (~0%–15%)**: Sets up the project and mental model — the four compiler passes, a minimal end-to-end pipeline, and the test suite you'll use to validate every later feature. - **Early (~15%–35%)**: Builds the front end and basic codegen for integer expressions — lexer, recursive-descent parser, precedence climbing, TACKY intermediate representation, and x64 assembly emission for unary, binary, logical, and relational operators. - **Middle (~35%–55%)**: Adds program structure — local variables, semantic analysis and variable resolution, if/conditional expressions, compound statements and scopes, loops, functions with calling conventions, and file-scope declarations. - **Late (~55%–80%)**: Expands the type system beyond int — long, unsigned, floating point, pointers, arrays and pointer arithmetic, characters and strings, dynamic memory allocation, and structures. - **Ending (~80%–100%)**: Turns a correct compiler into a faster one — optimizing TACKY programs, register allocation, plus appendices on debugging assembly with GDB/LLDB and code-emission tables. 【Key Takeaways】 - **Build incrementally, validate constantly** (Opening): Each chapter adds one feature on top of a working compiler, backed by a test suite — the core learning loop is implement, test, repeat. - **A clean multi-pass pipeline beats a monolith** (Early): Lexing, parsing, TACKY IR generation, and assembly generation are separated so each stage stays tractable and debuggable. - **Parsing precedence is a real design decision** (Early): The book contrasts grammar refactoring with precedence climbing, showing why the latter scales better for expression-heavy C. - **An intermediate representation pays off** (Middle): TACKY lets you handle control flow, short-circuiting, and later optimizations without tangling them into assembly generation. - **Semantic analysis is where C's rules live** (Middle): Variable resolution, scopes, type checking, and linkage are treated as distinct passes — essential for correctness beyond syntax. - **Calling conventions are the hardest practical hurdle** (Middle): Understanding the System V ABI and stack layout is what makes real function calls and libraries work. - **Types multiply complexity** (Late): Pointers, arrays, floats, and structs each force revisiting earlier passes — a lesson in how language features ripple through a compiler. - **Optimization comes last, deliberately** (Ending): Constant folding, dead store elimination, and register allocation are introduced only after correctness, mirroring real compiler development. 【Reading Tips】 - **Code along, don't just read**: The book is pseudocode-based by design; pick an implementation language early and keep the test suite green as you go. - **Deep-read Part I**: The minimal compiler and operator chapters establish patterns reused throughout — skimming here makes later parts painful. - **Treat functions/calling conventions as a checkpoint**: Slow down on the System V ABI section; it's the most common place readers get stuck. - **Skim optimization if time-limited**: Part III is valuable but separable — you can return after you have a correct compiler. - **Use the appendices actively**: The GDB/LLDB debugging guide is worth consulting the first time generated assembly misbehaves. 【Coverage Limits】 Excerpts are dominated by front matter and the table of contents; chapter-level detail on specific algorithms and worked examples is thin, so this guide maps structure and themes rather than deep technical content.