Compiler construction

About the book

Wirth wrote this book as a working account of how source text becomes executable code. The subject is the compiler itself: the scanner that turns characters into tokens, the parser that checks grammar, the structures that hold a program's meaning, and the code generator that emits instructions. The book comes from a designer who built languages and their implementations, and it carries that practical orientation throughout.

Expect an emphasis on method over machinery. Wirth favors compact, readable designs and shows how a small compiler can be assembled from clear parts, so the reader sees the whole pipeline. The treatment connects formal ideas about syntax and semantics to the concrete data structures and routines that implement them.

The book belongs to the tradition of compiler courses that ask students to write one. Theory earns its place by making the implementation simpler, and the implementation exposes where the theory runs out. Readers who want a single coherent example to follow will find more here than in volumes organized as catalogues of algorithms.

How to read it

Approach the book as a construction project. Read with a language in mind, even a tiny one, and trace how each stage would handle it. The material rewards readers who keep paper nearby and sketch the data structures as they go.

The prose is economical and the examples carry much of the argument. Expect to reread sections where notation is dense, and expect the difficulty to come from connecting formal grammar to working code rather than from page count. Readers without prior exposure to formal languages should plan to consult a supplementary text on parsing.

Who it suits

This suits students and working programmers who want to understand what happens between writing source code and running a program, especially those who learn best by building. It also serves teachers looking for a compact, implementation-first model for a compiler course. Readers who already know parsing theory will find the practical assembly of a compiler the useful part.

Reading considerations

The book's treatment of optimization and target architectures reflects its period; modern backends and toolchains are outside its scope. Edition and language details vary across printings, so check which version you have before relying on page references.