The Common LISP Object System (CLOS) is an object-oriented system that is becoming a part of the Common LISP standard under the auspices of the ANSI committee X3J13. Chapter 8 of this book, which occupies 66 pages, is actually adapted from X3J13 Document 88-002R.
The first seven chapters contain a discussion of the more important concepts and constructs in CLOS. Chapter 8 is a detailed description of all functions and variables in the CLOS programming interface, in the style of Guy Steele’s Common LISP manual [1]. Appendix A contains the code of a complete graphical application, with a brief description of the more interesting CLOS constructs it uses.
Overall, I found the book rather disappointing. The best part, in my opinion, is chapter 8, which was basically produced by the X3J13 committee. This part is extremely technical, in the style of the Common LISP manual, but it is a well-organized and useful working tool. The first seven chapters are meant as an introduction and a clarification of the concepts in chapter 8. Unfortunately, I found the first seven chapters disorganized.
Chapter 1 provides a simple introduction to the main concepts of object-oriented programming and a glimpse into some of the most important CLOS constructs. This introduction is well written and easy to understand, but unfortunately, it is extremely brief. No mention is made of the many significant object-oriented programming languages and paradigms; the authors do not attempt to place CLOS inside the considerable object-oriented culture. The language is presented in complete isolation, and readers who are familiar with languages such as C++, Smalltalk, Flavors, or Simula will find no discussion of the similarities to and differences from CLOS.
Chapters 2 through 7 explain in detail several technical points of CLOS, but the discussion is not organized from easier to more difficult. It may not be possible to disentangle this material (the authors acknowledge the difficulty at the beginning of chapter 2), but I would have appreciated a greater effort in this direction. As it is, it seems that each chapter is endlessly referring to something that will be explained later. This style leaves the reader with the sense that something is missing, even at the end of the book. A few topics are also treated in a cryptic manner. Figures 3.1 and 3.2, for example, use completely different conventions even though they deal with exactly the same topic; Figure 3.1, in fact, is confusing and is not explained in the text.
The book uses a good number of examples, which are useful in clarifying some of the more technical points. In many cases, however, the examples seem contrived, in the sense that much simpler Common LISP mechanisms would have sufficed. It might have been better to use one large application as an example, developing it throughout the book; the application in Appendix A, for example, could have been used.
The book is clearly meant for experienced Common LISP programmers, and in fact assumes that the reader already has a thorough understanding of object-oriented programming in a LISP environment. The book does not contain any exercises. The writing style is clear, and the typography is generally good. All examples are actual running code. The index is good.
In short, the book is fragmented and does not provide a logical, progressive introduction to the many intricacies of the CLOS language. Other published material, such as the January 1989 special issue of Lisp and Symbolic Computation, provides a clear introduction to CLOS and to some extent overlaps the contents of this book. Perhaps my greatest complaint is the failure to justify why certain things are the way they are, and to compare the salient features of the language to those found in other object-oriented languages. The absence of any reference to the rich object-oriented literature (aside from the CLOS literature itself) is proof of this failure.
