Browse Books

Reviewer: Dario A. Giuse

The introduction of the Common LISP language definition in 1983 suddenly moved the language from the realm of AI research into the mainstream of the computer industry. The former confusing state of affairs was replaced almost overnight by a well-defined language standard and a widely available software platform, which has made possible the development of a new sector of the computer business. One of the four books reviewed, Steele's Common LISP: the language, made it all happen. This is the original definition of the language, and even today it represents the definitive language reference. The impact of this book on the development of the LISP language has been tremendous. Many people in the computer science arena feel that this has been one of the few truly fundamental works of the last several years. Steele's book is an extremely accurate specification of Common LISP, and as such it is indispensable for any user of the language. It does not, however, provide a gradual introduction to the language, and is in fact extremely technical and sometimes abstruse for a novice. This is where the other three titles come into play. All three are meant to provide an introduction to the language; they assume only high-school level familiarity with some mathematical concepts, and work their way gradually to the more complex material. In spite of differences in the treatment of the material and in the coverage of the language, I am happy to note that all three provide a good introduction to Common LISP and basically fulfill the role they have chosen. It is slightly unfortunate that none of these books is, by itself, a complete tutorial for the language (such a book, if it ever gets written, would have to be substantially larger than any of them), but the three taken together do come close to providing a comprehensive overview of the language and an introduction for readers with little or no previous programming experience. While some basic material is covered by all three books, each one branches off in a slightly different direction when it comes to more advanced topics. In these areas there is little actual overlap among the three titles, so duplication is not a real concern. One could build an ideal mosaic of the advanced features of the language by reading the three books in sequence. Brooks This book covers the basic aspects of LISP as a programming language and emphasizes its use as a language suitable for both algorithmic and artificial intelligence applications. It is fairly comprehensive as far as the fundamental concepts of the language, which represent the bulk of the work, but is light in its treatment of the more advanced features. The ideal audience would be undergraduate or graduate students who are being exposed to LISP for the first time and do not necessarily have a strong programming background. A single quarter or a full semester would be appropriate to cover the material in this book. The major emphasis of the book is along the traditional lines of LISP development, and list processing takes up a large fraction of the total. This material is covered effectively and in logical progression. The presentation, however, seems too biased toward list processing, which admittedly was the core of traditional LISP programming but has lost much of that central role in Common LISP. I was disappointed to find that more modern concepts (like the concept of sequence, of which lists are a special case) are not touched upon, even though they play an essential role in all modern Common LISP programs. Other central concepts, like the generalized SETF form, are introduced only in chapter 11, at which point the reader would undoubtedly already be accustomed to the more obsolete constructs presented earlier. An exception to the general bias toward introductory concepts is the in-depth treatment of macros and of building embedded languages and interpreters. This discussion, which is descriptive and well-detailed, contains information on an advanced topic that is not found in the other three books. Of the three tutorial books, this one is more oriented to beginners with little or no programming experience. Its coverage of advanced topics is lighter than the others, and its great emphasis on list processing gives it a slightly more old-fashioned flavor. The treatment is always very clear and progressive, however, and this would be a fine text for an introductory course in LISP programming. The book is very easy to read and provides good examples throughout. The typesetting is satisfactory. Steele As mentioned in the introduction, this is the work that started all the excitement in the LISP community. The Common LISP design was born out of an unlikely convergence of intellectual talents from academia and industry, but the book nonetheless carries a strong flavor of unity and cohesiveness, not to mention a good dose of wit and humor that often comes through in unexpected places. This is the most detailed and yet enlightening computer language specification I have seen, and I remember reading original versions of the manuscript with a sense of awe for the breadth and depth of its conception. Even after five years, the book still carries that sense upon first reading. This does not make it easy reading, however: Common LISP: the language is not, and was never meant to be, a tutorial or introductory book. It jumps right into the matter, and is laced with a variety of cross-references, forward references, and extremely detailed specifications from the very first page. It assumes a great familiarity with programming systems from the very beginning, and in some cases it assumes that the reader is already familiar with even the more esoteric features of the LISP language. In spite of this admitted lack of introductory material, this is an indispensable reference for anyone who is interested in the language. My suggestion to newcomers has always been to read through the book once, cover to cover, simply to get the flavor of the language and the amazing variety of constructs and concepts that underlie it. The next step is to start using the language (typically with the aid of a tutorial book like the three described in this review), and to refer back to Steele as soon as a new topic is entered or a new need is discovered. As they become more and more familiar with the language, people find that they spend less and less time with the tutorial texts and more time with this book. In conclusion, this is a must-have textbook which should be on the bookshelves of all computer scientists, whether they are directly involved with LISP programming or not. Tatar This book, an introductory text, is explicitly designed as a companion to Common LISP: the language. Of the three tutorials reviewed here, this is the one that best gives a real feeling for the true power of the LISP language. The section on traditional LISP constructs is lightest, and the book moves quickly on to more complex material. The book covers a lot of material, much of which is advanced, and would be suitable for a two-semester course with appropriate classroom expansions of some of the more conventional material. I found the overall structure very well balanced and the book thoroughly enjoyable. Some of the more modern aspects of the language (such as sequences, structures, and lexical closures) are discussed in more depth than in the other two tutorial books, but the book's special strength is in showing why LISP is the language of choice for artificial intelligence work. The gem here is the description of a toy expert system named Otto. This description, which occupies a whole chapter, includes both an enlightening discussion of the system (a backward-chaining dual expert system) and the complete listing of the program. The text analyzes the most important aspects of the system and puts it into perspective, explaining how the features of Common LISP make it suitable to the different requirements of artificial intelligence. The program listing is first introduced through its main functions, each of which is discussed at length, and then is shown in its entirety. The code is well written and nicely commented. In conclusion, this is the book I would recommend to someone who wanted to own only Steele's work and one introductory textbook. More than the other two books in this review, it shows some of the unique features of the language and their practical impact on building real systems. The typesetting is satisfactory and the progression through the material is logical. The general level is slightly more advanced than that in the other two books, but it is still appropriate for readers with no previous exposure to LISP. Yuasa and Hagiya This is also an introductory text, more similar to Brooks's book than to Tatar's. It, too, covers the basics of the language in depth, assuming essentially no previous programming experience from the reader. Except for a slightly different order of presentation of the basic material, the general tone is quite similar to the other two books. Some advanced topics are introduced early on, such as symbols and packages, and the text avoids excessive emphasis on list processing. Control structures are covered satisfactorily. The general flavor of the book is slightly more `hands-on', but this does not adversely affect the logical progression of the presentation. Lexical closures are explained at length and in a clear fashion. Of the three tutorial books in this review, this is the one which expands less in the direction of advanced topics; I would say that the main contribution is the discussion of the programming environment, which includes a description of the module structure. This is to be expected from authors who were the implementors of an important version of Common LISP. The section that shows sample LISP programs is less satisfactory than the one in Tatar's book: part of the problem might be the choice of examples, which are all oriented to interactive applications and are therefore inherently more difficult to explain to a nontechnical audience. The code is less well commented, and the overview of the programs is at a level which would make it difficult for novice readers to really grasp what is going on. The typesetting is extremely accurate; there are essentially no typos.