On LISP

About the book

On LISP is a book about Common Lisp and, more pointedly, about macros. Paul Graham argues that a Lisp programmer can write utilities that behave like new parts of the language, then use those parts to shape a program around its domain. The book's central term for this is bottom-up programming: build small, reusable layers first, then write the application in the vocabulary those layers provide.

Macros sit at the center, alongside the machinery a working Lisp programmer needs to use them well: functions, closures, evaluation, and the design habits that keep generated code readable. Graham writes as a practitioner addressing other practitioners, with an emphasis on technique and judgment. Formal semantics get little attention.

Because the book is tied to Common Lisp, its examples and idioms belong to that language and its standard. Readers coming from other Lisp dialects or from languages with macro-like facilities will find the ideas portable but the code less so. The book is best read as an argument about program structure, illustrated through a particular language.

How to read it

Approach the book with a Lisp environment open. The material rewards typing examples and modifying them, because macro behavior is easier to see than to summarize. Read the early conceptual sections closely, then treat later material as a set of patterns to test against your own code.

The difficulty is uneven. Some passages move quickly through code that assumes comfort with Lisp syntax and evaluation rules. Others are more discursive and reward slow reading. Expect to reread sections once you have tried the examples; the book's value accumulates over repeated passes.

Who it suits

This suits programmers who already write Lisp and want to move beyond using the language as given toward designing their own abstractions. It also suits readers interested in macro systems and metaprogramming who can translate the Common Lisp examples into their own setting. Anyone weighing how much structure to build before writing application code will find the bottom-up argument worth engaging, even where they disagree.

Reading considerations

The book is anchored in Common Lisp as it stood in the early 1990s, so some idioms and library references may feel dated, and code may need adjustment in current implementations. Readers outside the Common Lisp world should expect to do translation work. Test the bottom-up approach against a real codebase before adopting it wholesale; macro-heavy design carries maintenance costs that the book's enthusiasm can understate.