Rating: 
Summary: concise and fast paced introduction
Review: 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"
Rating:
Summary: Organization could be tweaked
Review: 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.
Rating:
Summary: Graham Understands Lisp
Review: 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.
Rating:
Summary: A useful and clear exposition of the language
Review: I found this the most useful of all the LISP texts for training. I think it has the right balance of detail and overview. Although it omits some details, I am more confident than I am with other texts that this book will help the aspiring programmer rise above the level of "toy" code. This book and 'Paradigms..' by Norvig make an excellent pair. Graham is one of the better expositors on his subject. Worth reading even if you "know it all".
Rating: 
Summary: A good book for insights into python features
Review: I read the first few chapters of this book before losing interest. My general feeling is that it is a good source to get some insights into where python features like lambda functions come from. As to fully learning LISP, my own personal opinion is don't bother unless you are an ivory tower academic or computer person with an abundance of spare time who likes to collect programming languages like people collect stamps or coins or whatever. Those of us in the real world solving real programming problems need a rich set of built-ins (python socket, OS, modules etc.)
and want to steer clear of LISP's arcane syntax. So in conclusion: good book for learning about some programming language design principals in general (and python more specifically), but don't plan on using LISP for real-world applications.
Rating: 
Summary: Not focused very well
Review: I was kind of disappointed in this book. I was hoping to get a definitive definition of the language, but this book doesn't do that. It has a list of functions in an appendix, but these have somewhat vague definitions. This means that you are forced to try them on your version of Common Lisp and hope that your version got it right! This is not a first book on programming. Overall it seems to focus on selling Lisp as a viable implementation language; yet tries to cover everything in the language, which means that almost everything gets inadequate coverage. Experienced programmers may find that parts of the book are going over stuff that they already know (if you've ever seen any version of Lisp before) and not very thorough on the aspects of Lisp that make it unique, and thus only moderately convincing at selling Common Lisp as a mature language ready for serious development in more traditional settings. So I can't say that I'd recommend it to either beginners or experienced programmers...
Rating:
Summary: Lisp as an efficient, general-purpose language
Review: 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?
Rating:
Summary: Good Book. Pricey. Bad binding.
Review: 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.
Rating:
Summary: A great introduction to lisp - with some reservations
Review: 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.
Rating:
Summary: Very readable
Review: Very readable. Nice managable chapters of 20 or so pages each.
| 
