This is the third revision of the well-known The little Lisper [1], by the same authors. The book’s main purpose remains the same: to teach the reader to think recursively. To achieve this goal, the authors use Scheme, a small and extremely powerful language derived from Lisp.

Scheme allows the building of programs by aggregation of previously defined functions and lends itself to the building of abstractions with great flexibility. This feature is used in the book itself--the authors build new concepts from previously defined ones or by inductions formed from examples. Scheme’s relatively small set of primitives makes this approach feasible.

The book is divided into ten sections and an intermission. In chapter 1, the basic structures--atom, list, S-expression, car, cdr, cons, and eq--are presented incrementally. The five rules of Scheme are established: the law of car, the law of cdr, the law of cons, the law of null, and the law of eq.

Chapter 2 explains the details of list processing along with the conditions that must be checked when recurring on a list of atoms, numbers, or S-expressions. In chapter 3, the authors present the list constructor, cons, and its use in direct and recursive list constructions.

Chapter 4 presents arithmetic and logical operations on numbers and lists of numbers. Chapter 5 builds the set abstraction using list as the basic representation. The basic set operations are implemented on the previously defined list operations.

Chapter 6 presents the use of help functions to abstract from representations instead of dealing directly with them. Chapter 7 resumes chapter 5’s focus on set abstractions, but uses the terms “set” and “subset” instead of “list” and “sublist.” The operations used (such as member and insert) are now redefined in terms of these abstractions. Association lists (a-lists), relations, and functions (one-to-one functions) are introduced.

Chapter 8 starts climbing the mountains of abstraction, showing how we can abstract patterns commonly present in functions using new functions and higher-order procedures. Chapter 9 contains the pick of abstractions in the book, recursion on higher-order procedures.

Chapter 10 features an introduction to metalinguistic abstraction. The authors show (superficially) how to construct an interpreter of a variation of Scheme using the Scheme interpreter.

In the “Intermission,” the authors suggest some related readings, including The seasoned Schemer (the sequel of this book) [2] and some classics, such as Hofstadter’s Gödel, Escher, Bach [3]. The index is organized by function. I found it useless, considering the organization of the book, which enforces the sequential reading of each section.

This is an excellent introduction to computing, programming, and recursion as a way to solve problems. It confronts us with the elegance, simplicity, and beauty of programming. Especially suitable for students with no programming skills, it will also be enjoyable for the programming expert. The book’s length makes it suitable for a short introductory course.