Common LISP : The Language

Rating:
Summary: Perhaps the best computer language reference ever written
Review: "Common Lisp, The Language" (or CLTL) is an industrial-strength language reference for a somewhat esoteric computer language (in the view of most programmers today), so this tome is definitely not for the novice, nor for the faint of heart. However, if you are a true devotee of Common Lisp, then it is hard to imagine how you can escape this most sacred of texts. I own two dog-eared and heavily marked-up copies of the book, from which I have gotten my money's worth many times over. For years one or the other of these copies has been a permanent fixture on my desk, beside my keyboard. It is an invaluable reference for serious Common Lisp programmers.

However, as a previous reviewer pointed out, CLTL is strictly a reference, not a text. If you attempt to use it as an introductory text, you will hate both the book and the language, which will be your loss. To learn the language, I would recommend either "Lisp", by Winston and Horn, or "ANSI Common Lisp", by Paul Graham. After perhaps several years of serious Lisp programming, you will most likely find yourself studying the pages of CLTL, at which point you will appreciate what Guy Steele has succeeded in accomplishing in this slender volume of 1029 pages. Common Lisp is an enormous language, with over 800 built-in functions, many of which have complicated semantics and dozens of keywords that alter those semantics. Considering the daunting task of documenting this language, Steele deserves a medal. (In fact, the book has received various awards.)

Common Lisp was an integral part of several classes that I taught at Caltech for many years; I had students write compilers, interpreters, theorem provers, symbolic manipulators, numerical solvers, graph algorithms, etc. When you attack such a wide range of problems with a single language, you appreciate how rich Common Lisp is, and how well suited it is to all these tasks (yes, even numerical computation). But to get the most out of the language, it's necessary to tap into its more esoteric functions, which is where Steele's book is very handy.

I can think of few topics in the field of computer science that have as rich a history as the language Lisp. It's difficult to present a meaningful view of the language, especially in it's "Common" incarnation, without delving into some of that history. Steele does this exceedingly well in CLTL, although I can understand how it can be off-putting to some; it adds bulk to an already formidable tome, and at times seems to clutter up what ought to be a cut-and-dried presentation of syntax and semantics. However, unless you subscribe to the mystical view that Lisp was created by divine fiat (a theory that is gaining popularity), then you will inevitably have questions as to why things were done in one way and not another. The answers provide insight into language design (or at least the workings of the X3J13 committee), and at times a better mastery of Common Lisp. For those who do not care for such details, Steele sets the digressions off from the main body of the text, making them easy to skip. But I, for one, am happy that this information is recorded somewhere. (If nothing else, it keeps the creationists at bay.)

Like the mathematician Gilbert Strang, who manages to inject humor into the driest of mathematical journals, Steele has found ample opportunities to sneak bits of wordplay and irreverence into CLTL for comic relief. Not only does Steele enliven his program fragments with snippets of pop culture, as in

"(loop for turtle in teenage-mutant-ninja-turtles do..."

but all such references are assiduously listed in the index, which makes it a real hoot to glance through. Listed there are "Mozart, Wolfgang Amadeus", and "Michelangelo (artist)" as well as "Michelangelo (turtle)". We also find things like "goody two-shoes", "oranges, comparing apples with", "square peg in round hole", and numerous foods, including garbanzo beans, ice cream, orange flavor beef, pizza, and peppermint. Under "pasta" we find "see also macaroni". But my favorite index entry is "kludges", which directs us to pages 1 through 971; which is, of course, the entire body of the book, excluding index and appendices. Steele obviously decided to have a little fun, which is understandable considering how dry such books tend to be.

But, before you click this book into your shopping cart, you should realize that the complete text is available on-line, and for free. I'm not sure how Steele swung this with the publisher, but it's out there in the public domain. Finally, I should point out that there are a number of excellent free Common Lisp interpreters available for many different platforms. The best I have found is CLISP, which is maintained primarily by Bruno Haible through the GNU Project. It's reasonably complete and robust.

Happy hacking. May cons be with you.

Rating:
Summary: A Thorough Reference Guide to Common Lisp.
Review:

Pros:

Every single existing CL function is there (AFAIK), with rationale and explanation of some of the context of why/how it came about. Even if you're not a Lisper by trade, you'll get astonishingly many hints about how all of Lisp came to be. Even if what is described is the "Common Lisp" dialect of Lisp, you'll get as many rewards as hours you're willing to put in the study of this fascinating world. (I was taught Lisp some 20+ years ago and left it on the way-side for way too long. Now is the time to get serious about programming. -- I've written hundreds of thousands of lines of C, assembler, Java, (arg...) C++, all of which I consider a waste of time now. If only I could go back in time ... --

Cons:

I wish this single 1000+ pages book was split into two or more manageable volumes, that's my only gripe.

Rating:
Summary: A good source in combination with other texts.
Review: Considered outdated by some, this book by Steele helps me in a nurturing capacity for understanding IDL lisp (ICAD Design Language by KTI). When used in combination with books by Graham and others, a good reference work when attempting to find specific keywords and constructs to solve isolated coding problems. It may fall a little short on examples but this is expected due to the original purpose of the text. All in all, a must for your lisp library.

Rating:
Summary: Common Lisp : The Language by Guy L., Jr. Steele
Review: Delivered very quickly (2 days)

Rating:
Summary: The sad state of Lisp documentation
Review: I'm absolutely certain that CLtL's 4 star review average is indicative of some larger evil. I've been struggling with this book for too long now, and I can't take it anymore.

CLtL is one of the poorest examples of technical communication I've ever seen. Imagine being handed a 1000+ page Microsoft Word document, with the "Track Changes" option turned on. That's what it's like to read this book.

A lot of the prose rambles, with remarkably little content. Most of the time, the text sputters along, the flow will just get started, when it is interrupted by a change bar: "In 1988, ANSI voted to blah blah blah..." Reading this book is like riding the bumper cars at an amusement park. It is both visually and mentally jarring. And the examples? There are plenty of hackneyed examples, but almost no useful ones. Last night I ran across an example where the author flat out admits, in the text, that it is a useless and trivial exercise.

In summary, this book was written by Lisp experts, *for* Lisp experts. Newbies need not apply. This makes it even more remarkable as a bad example, in that it took Steele and others over 1000 pages to tell people something they already know. The bottom line? Aside from AMOP and Keene's excellent book on CLOS, there are *no* decent books for learning Common Lisp, the language. I've read almost all of them, including Graham's.

Make no mistake: Common Lisp is a great language, perhaps *the* most powerful language ever invented. But you sure wouldn't know that from reading this book.

Rating:
Summary: The sad state of Lisp documentation
Review: Readers should be aware that is is not the official specification of ANSI Common Lisp. This book was published before the standardization work was finished, and the final standard disagrees with this book on a number of issues.

Don't let that stop you from buying this book, though; it is an excellent read, contains a wealth of useful information, and is funny as well. Just make sure you use the standard (available freely on the web as the "Hyperspec") as your authorative reference.

Rating:
Summary: Differs from the standard
Review: Readers should be aware that is is not the official specification of ANSI Common Lisp. This book was published before the standardization work was finished, and the final standard disagrees with this book on a number of issues.

Don't let that stop you from buying this book, though; it is an excellent read, contains a wealth of useful information, and is funny as well. Just make sure you use the standard (available freely on the web as the "Hyperspec") as your authorative reference.

Rating:
Summary: The Bible of LISP
Review: Steele's book is a technical definition of Common LISP. For users with some experience in LISP programming and an experimental approach to computing, this book is a gold mine of information from -- practical to bizarre.

Rating:
Summary: Good reference
Review: This book is an excellent reference book on Common Lisp and will serve the experienced Lisp programmer well in that regard. The author has meticulously documented the features of Common Lisp and its relation with other Lisp dialects, such as MacLisp. Readers who know Lisp only marginally can also benefit from the book, for example computer scientists or logicians with a background in lambda calculus, or programmers with a background in functional or logical programming. Users of Mathematica, Reduce, or Maple could also use the book profitably, as it gives insight on the origin of some of the function calls and syntax in these high-level symbolic programming languages. The size of the book prohibits a per-chapter review, but some highlights of the book include the discussion on data types and scoping in the first two chapters. The author summarizes effectively the kinds of scope in Common Lisp. The program structure in Lisp, namely the organization of a program as a function call or a form is outlined in detail. It is this program structure I believe that gives Lisp its power and makes it a more natural language in which to program, at least from a purely mathematical standpoint. The author stresses that function application is the primary method for generating Lisp programs. In addition, the author shows in detail how a function in Lisp can compute several objects and return them; and here again, the approach taken by Lisp is much cleaner from a mathematical perspective than the one taken by other programming languages.

A very good overview of how Common Lisp represents numbers is also given in the book. The discussion is supplemented with a treatment of complex functions and many graphs are given illustrating their behavior, the graphs being generated by PostScript code by Common Lisp code. Also, there is a useful discussion of hashing in and how to implement user-defined structures in Common Lisp.

Also quite interesting is the discussion on the object-oriented extension to Common Lisp called the Common Lisp Object System (CLOS), which is based on generic functions, multiple inheritance, declarative method combination, and a meta-object protocol. The fundamental objects of CLOS are classes, instances, generic functions, and methods, and the author discusses each of these in detail. The use of CLOS has become important recently in the area of constraint programming and its applications.

Rating:
Summary: Syntax & Semantic Reference Guide
Review: This book should be called the "Syntax & Semantic Reference Guide for Common Lisp". It is not a primer on Common Lisp; for the most part the author spews information about the specification (which he was part of forming). This might be the best reference book on Lisp ever written, but don't attempt to try and learn the Lisp language from this text.