The author of this book about Lisp and Scheme implementations has an unintrusive “hidden” agenda: he wants people to download and use his fast implementation of a restricted, object-oriented extension to Lisp/Scheme, called Meroonet. However, this only becomes clear in the final chapter, and it does not significantly affect the content of the previous ten chapters; Queinnec knows that the selling point for Meroonet is his expertise, so he does not compromise the quality of his discussion.

The range of the book is greater than one might expect. The first few chapters progress from a simple interpreter in a powerful language to a sophisticated interpreter in a restricted language, dealing smoothly with continuations and side effects. The author moves on to denotational semantics, and then goes back to interpretation, concerned this time with optimization. Then he discusses compilation in an abstract assembler, reflection, and the means and effects of introducing macros before evaluation. Next, he deals with compilation using C as the target language, before going on to discuss Meroonet.

The target audience includes third-year undergraduates and more advanced students who want to learn about implementing functional languages of the Lisp family. It also includes people who want to learn about compilation techniques in a more general sense, because much of what is presented is not restricted to the languages being implemented. Beyond these groups, the book is for people interested in language design who want to learn how apparently innocuous design decisions can have far-reaching and subtle effects on programming languages; these effects are illustrated by comparing different dialects.

This book reads well and is friendly, but is best taken in small doses; over a long session, the density of the material becomes tiring. It is well structured and progresses well, but each chapter after the first few involves an almost complete change of topic. This is welcome because the reader is worn out at the end of a chapter, so starting something new is rejuvenating. The book is long; there are 450 pages before the answers to exercises (which are good). It is full of Lisp/Scheme code, which makes it practical, but it is not a book to skim. The references are considerable; it draws on much of the French literature, as well as the English.

Kathleen Calloway’s translation (from French) is excellent; there are only a handful of insignificant errors in the first hundred or so pages, which are at least as good as the average English text. The error rate climbs somewhat after that, with a minor mistake every few pages, but the only significant error is a reference to a table that must have been changed between drafts.

I have not touched Lisp for quite a while, which made reading this book more difficult; on the other hand, I teach a final-year course in Haskell and Prolog in which a baby interpreter is used to illustrate programming language features and show how imperative operations can be embedded in a functional language through suitable modifications to the interpreter. I have also been interested for many years in language design and how apparently arbitrary design decisions can have drastic effects on implementation and understanding. Thus, I find the topics of the book fascinating, while I regret my lack of rapid fluency in the code provided.

This is a good, solid book. The writing is subtle, but clear. It is certainly worth reading for anyone in its three target audiences, though its appeal to other people is limited. It highlights a number of language design issues that are relevant to most programming languages in one form or another, though they are not often seen so clearly; this should make people think again about the virtues and weaknesses of their own favorite language.