Customer Reviews

ANSI Common LISP

5 star:		(15)
4 star:		(10)
3 star:		(2)
2 star:		(2)
1 star:		(1)

 

 

Style: I'm embarrassed to admit that I laughed out loud at some of the jokes embedded in the code examples. The writing is clear and entertaining (why are Lisp books better in this respect than those of of other languages?).

Audience: This should probably not be the first programming book that you read, but it could easily be the second. Graham describes Common Lisp in detail, but assumes no prior knowledge of the language. This is a good book for people learning Lisp independently, for any application. Intermediate-level programmers will benefit from seeing Graham's Lisp style, which emphasizes building utilities to create a 'language' suitable for your problem.

Organization: The strongest point. Examples are keyed in well with the text: binary search trees in the data structures chapter, string substitution in the I/O chapter, ray tracing in the numbers chapter, etc. Okay, sure, there's nothing fancy there; obviously writers choose relevant examples. The impressive thing is how the examples are high-quality Lisp programs of the sort that might actually be used, even the ones from the early chapters (before the entire language is available). This is not the most common pedagogical approach, but it works here.

Possible shortcomings: There is nothing wrong with the problems per se, but most of them can be solved with very short programs. There are some great large-scale programs towards the end: an roll-your-own object system, an HTML generator, Lisp-in-Lisp; but on the other hand, you're on your own when the time comes to think of projects to try yourself.

As far as the reference section goes, it's okay, but why not just use the HyperSpec?

I think this book is terrific. It covers a great deal of ANSI Common Lisp, in a very concise way, and includes some well-chosen, realistic, medium-scale examples. The writing is clear, clever, and often amusing. Most of all, it really gets me excited about the language! Graham does a great job of explaining how all of the language features work to change your approach to programming, and debunking a lot of the myths you hear about the Lisp language.

This book is not for everyone; you ought to have experience programming before reading this book. It doesn't hand-hold, leading step-by-step. You will have to pause every few pages to collect your thoughts and try things out. One or two of the sample routines have bugs, at least in my printing. The book is *quite dense* compared to a lot of the 1000+ page language books you see. I think that is a strong point, as it is easy to carry around, even including a capsule reference to the language. Lisp is quite different in style from C/C++/Pascal, so you might experience some culture shock.

I find myself picking this book up and reading a page or two, like taking a "Lisp vitamin", even though I've been programming in Lisp for some time now.

This book's introduction to Lisp has changed my whole outlook on programming. I hate having to go back to any other language. I also recommend Graham's other book "On Lisp" as a sequel.

This book is a very good introduction to Lisp, as others have adequately explained. However, since it was first published the quantity of good free Lisp reading material on the web has increased. See <u>Practical Common Lisp</u> (http://www.gigamonkeys.com/book/) as an example. The $47 expenditure might not be necessary if you just want to learn lisp.

My main complaint is the binding on the book. I have not put this book under any unusual stress and the spine is already starting to fall apart after a few weeks of use. This unacceptable for reference book that I would like to use well into the future.

With only mild prerequisites in computer science and/or math, Paul Graham gently but quite fully introduces the rudiments of Common Lisp. This was my first Lisp book, recommended to me by a Lisp-fluent student in college when I had to learn the language for an AI class. While I then moved on to more referencial works, like Steele's _Common Lisp: The Language_, Graham is still a foundation for much of the basic grammar, structure, and reasoning behind the form of the language.

While Graham does delve into some interesting coding examples in the second half of the book, _ANSI Common LISP_ is not meant to replace a referential or exemplary book concerning the language. If you're looking for a more case-study sort of book, I suggest Norvig's _Paradigms of AI programming_ or Tanimoto's _Elements of Artificial Intelligence_. Both offer a wealth of examples that Graham rightfully omits in order to more broadly cover the fundamentals of the language itself.

If you come from C/C++/Pascal/Java this book is definitely for you. If you come from Forth, you're already accustomed to a fair part of what Lisp is about, this book will show you the missing bits. If you come from Python/Ruby/Perl, well, welcome!

Even though ANSI CL has two chapters (11 and 17) about OO programming, that is, for me, the least interesting part. Coming from Java/C++ I already know most of this stuff (the only important distinction being between message passing -- The Java/C++/Smalltalk way -- and generic function -- the Lisp/Dylan way.

What is truly amazing is chapter 15 (inference) which in exactly 10 pages, gives you a toy example (I needed about 30 minutes to type it in) that actually works, and opens your mind to this area that had been deemed, oh, so difficult and esoteric!

Not so in Graham's book.

Also, in a few pages, he is able to explain to you the fundamentals of ray-tracing, in a way that is simply luminous.

I own CLTL2, Winston & Horn and the new Seibel book. I'm sure glad I did add Graham's book to my collection. My only regret is that I took so long to discover it!

This was the first book I read about Common Lisp and it really made me excited about the language. The writing is engaging and the examples are first class. My only reservation would be Graham's comments about the loop macro, which put me off really trying to use and understand loop for some time. It was only by seeing examples of its use elsewhere (in particular, in code snippets posted to the comp.lang.lisp newsgroup) that made me re-evaluate the use of loop. It should be noted that Graham is not the only lisp programmer to have strong views about loop though.

In summary though - a great book. Just make your own mind up about loop.

Graham has a penetrating understanding of Lisp, so the text is lucid and easy to follow. Also, like Starr's report on Clinton, some of the best stuff is in the footnotes!

The book is small and the topic large, so some coverage of things is a bit thin. So what -- the Hyperspec is free.

The book is extremely practical, dealing with how to write programs and use the language. It is *extremely* handy to refer to while programming; this is not true of the Hyperspec. Hence this book is a must-have.

Also strongly recommended (especially if you don't know why Lisp is so wonderful) is "On Lisp", by Paul Graham. He shows the completely unmatched power of Lisp. Out of print, you can get for free on Graham's website -- go to yahoo to find it.

Don't get me wrong, I still think the book deserves 5 stars for doing a grade-A presentation of material --- topics are presented clearly and without fuss, and even examples are logically (but thoroughly) discussed, without the bludgeoning that typically accompanies code examples in introductory language texts.

One minor failing is that occasionally (I came across 3-4 instances) the author makes use of constructs in examples where they have not yet been presented --- it might have been intentional, as it forces the reader to get acquainted with the reference section, but it's a little disconcerting.

The macro section left me hungry for more (but that's what "On Lisp" --- available online for free from Paul Graham's website --- is for), and the package discussion was a little sparse (keywords were sort of confusing --- Practical Common Lisp, at http://www.gigamonkeys.com/book/, does a better job), but overall, a great read.

I have to agree with the other reviewer that I wish more substantial programming exercises were given. This won't be a problem for students who are using the book as a text in a Lisp-based course, obviously, but for self-study practitioners it would be icing on the cake.

I'm a programmer comming from a procedural and OOP background. Some features of Lisp are completely mind-blowing if not right out bizzarre. Even if you're not in the field of AI, Neural Nets, etc. This book teaches you how to use Lisp as a "common," all purpose language.
Grahams's style and exposition are bar-none. As some one already said, the examples might come across as simplistic or even trivial. But after realizing what the author was actually trying to accomplish, one realizes that the examples are actually quite fitting.
I tried (and returned/exchanged) three other Lisp books because they were either too broad and shallow or too specific. This book, however, has a great mix of breath/depth that makes the learning curve a bit more gentle and thus making this book (and more importantly, the language) accessible to anyone with a bit of programming background.
This book is among my must-buy-must-keep list of computer books. Highly recommend.

A good tutorial on the use of lisp as a "non-ai" mainstream programming language.
Give the history and a rich set of unique programming features lisp offers, it's sad that it's not used more often.
I rate this book alongside Touretzky's "a gentle introduction to symbolic computation"