This is the text used by the author in an introductory programming course for humanists. The language taught is LISP. After a few dozen pages of conceptual material, the book proceeds through all of the elementary features of the languages. The chapter headings are EVAL Notation [S-expressions], Conditionals, Global Variables and Side Effects, List Data Structures, Applicative Operators, Recursion, Elementary Input/Output, Iteration, and Property Lists. There is no discussion of LABEL, arrays, garbage collection, or FUNARG. Appendices provide: a list of the differences among the major LISP dialects; a near-cookbook scheme allowing the book to be used with any of those dialects; and solutions to the exercises. The book is completed with a remarkably thorough index. The whole book is handsomely produced.

LISP is the oldest of the respectable computer languages, and its syntax and semantics are the simplest. Nevertheless, at first it seems bold to have selected LISP for an elementary course, especially one aimed at nonmathematicians. Where will examples and exercises be found? In my prior experience, most LISP programs had been either utterly trivial or staggeringly complex. I had seen a few examples in the middle ground (e.g., the perennial symbolic differentiator), but they were not of the sort to appeal to a nonprogrammer.

Middle-complexity examples are the author’s greatest contribution. He has come up with many, with the best of them posed as accumulative exercises. Some of the exercises produce interactive tools (e.g., a cryptographic aide), rather than closed solutions to particular problems. Many would be much more difficult in most languages other than LISP.

In a few places, the book could have profited from more careful editing. On p.58, for example, the author states that (A.B) is “not a list because its last cons cell doesn’t point to NIL.” On the very next page, a circular structure that has no last cons cell is referred to as a list. On p.81, where the book’s first transcript of a man-machine dialogue appears, there is no explanation of the underlining convention that is used to show which party to the dialogue typed what. The suggested solutions to Exercises 1 and 2 on p. 150 are by no means optimal, and an alternate approach -- using a simple list instead of a table, with the NEXT-STATE function implemented as

(DEFUN NEXT-STATE (X) (CAR (OR (CDR (MEMBER X STATE-TABLE)):9F :2FSTATE-TABLE))):9F -- should have been suggested. The chapter on recursion is written as a cloying fairytale, imitating the least desirable elements of the style of Douglas Hofstadter. The suggested solution to the LAUGH exercise on p.202, leads to the possibility of infinite recursion, which is admitted. The author neglects the opportunity to discuss programming strategy -- here, sustituting (LESSP N 1) for (ZEROP N) -- to avoid this sort of error. Appendix C appears to be directed to course instructors, but this is not made explicit, and the unexplained phrase “stack overflow” (p.283) will be mysterious to the novice. I carp. I niggle. If I were teaching elementary programming again, I would use this book.