This book teaches the T programming language, stated to be a “particular implementation” and a “superset” of SCHEME, which, in turn, is a dialect of LISP. SCHEME, and therefore T, are modern LISP variants with lexical scoping, and as such they fit better with presently accepted practices for good programming than the older, dynamically-scoped variants. T includes such features as macros, structures, object-oriented programming, and debugging tools. It has a compiler and an interpreter with the essential feature of identical semantics in both, which is often missing from LISP.

The text covers T in depth and explains programming issues such as recursion, iteration, local vs. global reference, strings, I/O, etc. The well-thought-out problems on interesting topics such as spelling correction, cryptography, lazy array space allocation, workspace editor, database management system, etc. are particularly pleasing. Many problems have solutions. The book appears to have been produced by a desktop publishing system, and on some pages the print is slightly faint; but, in spite of this, it has a clear and readable appearance. Details are given for obtaining the T system.

The least satisfying aspect of the book is a slight vagueness of purpose that seems to pervade it. For example, the Preface discusses the role of teaching programming in introductory computer science courses, yet it also states that the book is not an introductory programming text; it seems to imply that, if used for an introductory course, the students’ prior informal contact with programming will be enough. Subsequent examination of the book itself, however, does not bear this out. This is a substantial book, and although it covers all necessary material, it progresses too fast for students with such limited preparation. Another example is the statement that the first part teaches “those aspects of T found in most LISP implementations” and the second covers the T language in particular. The changeover is stated to occur at chapter “7:.F:6WWp2”] To be fair, however, a lot of the responsibility for this seems to lie with the subject rather than the author. LISP is notorious for inconsistencies between versions and the degree to which detailed knowledge of the inner workings is needed to understand many features. Just about nothing from the first seven chapters, for example, works unchanged on our LISP system. Some differences are cosmetic, but others go deeper. There is thus an inherent vagueness in the task that the author has set for himself. Aware of the problem, he includes code for modifying the LISP variants, SCHEME and Common LISP, so they behave more like T; but the book is still not suitable for studying any other LISP variant.

The author is thorough in his coverage and does not shirk from his duty as a LISP author to address the deeper issues raised by the topics discussed. He includes such topics at the end as “EVAL exposed,” optimization, and (a chapter on) the implementation of T. A pleasing feature is the author’s tendency to give a number of variations for solving a problem and to point out the differences between them. Occasionally, however, the difficulty of the material is underestimated and issues are overlooked. The most serious case concerns LISP’s “dotted pair” notation. This is introduced in Chapter 2 as a notation for indicating a variable number of arguments to a function, and given as the example “(+ . numbers).” It would thus appear to be a metanotation used in the text to indicate an allowable language form. The chapter summary then causes confusion by claiming “T uses a dot . . . to indicate an expression argument which may occur zero or more times” (note: “T uses,” not “This text uses”). In the next chapter, a picture of the storage of a dotted pair in memory is given without comment. Gradually the alert reader comes to understand that T has the power to act as its own metalanguage and that the user can create his or her own language forms involving variable arguments by using a dotted pair. Any unsupervised and unforewarned reader could spend a lot of time puzzling this issue out.

An annoying stylistic defect is the way in which new features are introduced, first in an example and later in an explanation in the body of the text; one tends to skip back and forth looking for explanations, as the examples cannot be followed without them. The book seems to have been reviewed mainly by others already “in-the-know” regarding T. In spite of these problems, the material still comes across well. The overall impression is that of an author who knows his subject, tells it all with enthusiasm, but sometimes falls a little short in the pedagogy. The Index is better than average (although, like most, it misses many references); and the Table of Contents is excellent, as it lists all examples as well as section headings. This is not a light book, and it needs to be studied rather than read. There is a lot of valuable material packed within the book’s 425 pages. Although the less capable reader will need some extra assistance, everyone who wishes to seriously study T really should have this book.