Type S-expressions and press Enter. The book teaches by doing — so do!
Click each commandment to explore. These are the heuristics that make recursion tractable — like Pólya's problem-solving strategies, but for code.
The book's signature move: follow a function call by call. Watch member? peel the list like an onion. 🧅
(define member?
(lambda (a lat)
(cond
((null? lat) #f)
((eq? (car lat) a) #t)
(else (member? a (cdr lat))))))
Chapter 9's masterpiece: deriving recursion from nothing. Click each step to see the code evolve. 🍝 (Like building spaghetti from flour.)
Chapter 10: Scheme interpreting Scheme. The strange loop that would make Hofstadter proud. Click a node to see how it works.
Can we write a function that decides if any function halts? The book proves: no. Walk through the paradox.
From the simplest atom to self-interpreting code, in 200 pages:
This is the most elegant programming book ever written. Through nothing but questions and answers — a Socratic dialogue about lists — Friedman and Felleisen smuggle in the deepest ideas in computer science. You arrive thinking about (car '(a b c)) and leave understanding why some problems are undecidable and how a language can interpret itself.
The food metaphors aren't decoration. They're pedagogical: by using peanut butter, jelly, and spaghetti as data, the book keeps abstraction grounded. You never forget that these are just things in lists.
The Ten Commandments are genius. Like Pólya's heuristics for math, they give you handles for thinking about recursion. After this book, you don't fear recursion — you see it.
car, cdr, cons, null?, eq? — five primitives, and you get a self-interpreting language.
Five stars. No hesitation. This book respects your intelligence by never telling you the answer — it asks you questions until you discover it yourself. That's not just good pedagogy. That's love.
🥜 Now go make yourself a peanut butter and jelly sandwich. You've earned it.