5 comments about Lisp in Small Pieces.

1. This is an excellent book on Lisp implementation. You'll get a lot out of it, whether you are interested in writing compilers and interpreters (for Lisp or any language) or whether you just want to see how Lisp works. It is the modern day successor to Allen's "Anatomy of Lisp".



2. An unexpectedly good book.

   If you're interested in implementation choices for Scheme and the Lisp family of languages, this is an amazing book. Its worth reading even if you never plan to implement a Lisp interpreter and just want to learn a bit of theory and history behind these languages.




3. I'm not a professional reviewer. But I program a lot, and for a living. After more than 15 years of experience in algorithm development and user interface design, to name some extremes, I get the feeling that "traditional" computer programming languages like C (C++, C#, Objective C) and Pascal (Modula, Oberon, ADA)
   and even oldtimers as Cobol and Fortran tend to develop, or rather mature, into languages getting closer and closer to Lisp, Algol, and their ultimate offspring, Scheme.
   This is not without reason.
   But although the many qualities of Lisp have long since been known in academia, they need time and, more important, good reference material, to find their way into the real world.
   Lisp programmers know the value of everything, but the cost of nothing, it is said. Christian Queinnec neatly fills the gap in our knowledge in a book that is a hard read because of the density of the content, but also a fun book because all the source is there (available through the Internet, of course) to experiment with.
   You will not only gain insight into the workings of your Lisp system. You will gain insight into the basic elements of computer programming languages and their reason for being, their implementation, and the benefits and costs they will bring you.
   All in all, one of the best books on Lisp I have ever almost, but not completely grokked.
   
   I sincerely believe that tomorrow's programming languages, whether they be called C** or Delphi 2010, will be closer to current Lisp than to current C or Pascal, and a way to efficiently implement these languages is available here and now.
   
   The book covers all standard material like direct interpretation, compilation towards a virtual machine using bytecodes, and compilation to C. New material is found in the chapter on macro's , a subject that has regained much interest of late. A broad variety of programming styles is used to illustrate all concepts.
   
   There is only one drawback to the book. It won't teach you Lisp, or Scheme. That is, unless you already know it.



4. This book is excellent. It is clear but not superficial at all.
   
   Queinnec explains from the basics of Lisp implementation (evaluation of S-expressions) to techniques for compiling into C. You will find very good advice on how to implement macros and continuations. If you want to implement Lisp, Scheme or any other language actually, buy this book!
   
   Also, there are exercises -- with answers! :-)



5. Nikoluas Wirth once said "language design is compiler design". This book is truly remarkable in providing a look behind the (LISP ) scenery. Everyone who write LISP progams should red it to get an understanding of the implementation and hence cost of the language features. Great reading!!!

5 comments about Successful Lisp: How to Understand and Use Common Lisp.

1. Ok it was on the web a lot and many people have a change to trace the errors and post suggestions, so this is a pretty well written and well polished product, i would recommend to beginner to intermediate programmer , typing is pretty compact so you could use it as a reference but for a A grade tehre should be good exercises.



2. Lisp (no it's not a speech impediment) is an old language. But in spite of all of the hype on the new languages like C, C++, and Java, there is still a need and a place for some of the old languages.
   
   FORTRAN, which is still heavily used by the scientific programmers, particularily with cluster computers and COBOL (remember all the stories of the Y2K problem); Lisp refuses to go away. For certain application areas (not the least of which is AI) Lisp is clearly the language of choice. Easily the most important (or well known) pgrogram written in Lisp or using Lisp techniques is AutoCad. This package which has the requirement to handle millions of separate parts in a design is an ideal application for using Lisp which lends itself well to such large projects.
   
   This is an exceedling well written book on the Lisp language. In the fifty-three pages of Chapter three, there is a twelve lesson tutorial on the language which gives the rudiments quickly and painlessly.
   
   Throughout the book there is discussion on not just the language but points on how Lisp might fit particualrly in selected applications.
   
   Great Book.



3. This is a nice book. Not a good introduction to programming, but a good introduction to Lisp. The text is clear, and covers the basics of Lisp. You'll still need other books for advanced techniques, though (check paul Graham's On LISP: Advanced Techniques for Common LISP).



4. I needed this for an AI course I was supposed to take in the fall. I kept reading this in spare moments and worked with the online compiler at school until I had fairly good handle on lisp.



5. Another Lisp geek heard from. I used this book in a Programming Languages course I taught (SUNY Potsdam, Spring 2008) and I loved it. Students learned Common Lisp from class lectures and this book and, given that they are successfully writing Lisp interpreters, they were well able to do so. The book begins with an introduction (Chapter 3, alone, is worth its weight in gold) and then moves on to advanced topics including compiling and memory management inside the Lisp system. Wade Hennessey's Common Lisp has more detail on the internals but this book is much more accessible.
   
   The writing isn't perfect and the motivation for all the powerful techniques provided by Common Lisp is sometimes thin. As a text book, the lack of problems can, itself, be a problem. But for learning Common Lisp, this book is both fun and, over all, successful.

5 comments about Object-Oriented Programming in Common Lisp: A Programmer's Guide to CLOS.

1. Keene covers CLOS thoroughly and clearly. A classic. Can't say much else. If you care about your LISP programming craft, buy this book.



2. You are going to get precisely what is advertised: a good guide to object-oriented programming in Common Lisp, no less, no more.



3. This is a nice "tutorial style" walk through much of the functionality of CLOS.

   It doesn't get into examples that are of _spectacular_ complexity, either in size or in difficulty of concept, but that strikes me as being just fine. The dialect of CLOS in use predates the final version that was released, so a few examples require a little modification to work with modern Lisp releases.

   If you're looking to get into the sophistication of redefining your own metaobject protocols, the MOP book is surely more suitable. But for most of us who just need to figure out what CLOS is good for, this book provides a very nice presentation of that.




4. Lisp is kinda hot again, Perl 6 will have multiple dispatch, Ruby's getting before and after methods, and Aspect Oriented Programming is still bubbling under in Java, so what better time to revisit the Common Lisp Object System and this slim volume from 1989? Unsurprisingly, objects in Lisp are implemented differently to the well-known object systems, even Smalltalk, so if you're into OO (and in particular AOP), check out CLOS.
   
   And this book is an excellent way to get acquainted with the features of CLOS. While the introduction suggests non-Lispniks can benefit from reading this book, I would strongly suggest you can read Lisp to make sure you understand what's going on. It's a quick read (about 220 pages, excluding the appendices), the language is unfussy and clear, and the concepts are simply explained.
   
   The hoary old shape example is used briefly (perhaps it wasn't as tired in 1989), but the two main examples used in the book is a simple locking mechanism for concurrency, and multiple inheritance based disk and tape stream classes. Both example do the job well of highlighting the unique flavour of CLOS. The metaobject protocol is touched upon only briefly, but there's more than enough of the standard object protocol described for you to be getting your money's worth.
   
   Other introductory books do cover CLOS (Practical Common Lisp has a good chapter), but this is a very nice standalone volume devoted to CLOS only. Well worth reading, object (and Lisp) fans.



5. This is a great book. It shows everything about CLOS (except the metaobject protocol, which is just mentioned but not explained in detail). The explanations are very clear and the author does every possible thing to make you understand all details (a bit too much for me, but that's a matter of taste).
   
   For anyone interested in OO programming in Common Lisp, this is an essential book.
   Even if you are interested in OO programming in general, this book covers a different approach, so it is nice for a comparison (in CLOS, methods do not belong to classes, and there are lots of interesting tricks that you can do that are not possible in other languages).

5 comments about Common LISP. The Language. Second Edition.

1. 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.




2. 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.




3. "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.




4. to enjoy this book, you must be aware of what it is and is not. it is not intended for learning lisp. it *is* intended for thoroughly documenting the language, and steele is perhaps the best writer alive in this field. his thoroughness, attention to detail, and copy-editing skills are nearly impossible to beat -- it's not a coincidence that he was chosen to write the standard for java, based on his work on this book.



5. This is *the* reference for ANSI Common Lisp. I wish it had some more examples, though. Sometimes I go to this book, find what I want, but need to check an example in some other book.
   But you need this one if you're going to use Lisp (it's also available for free, legally).

5 comments about Lisp (3rd Edition).

1. Keeping with the Pragmatic Programmers goal of learning a new programming language a year I have decided to learn Lisp this year. Over the last few months I have purchased many books on the topic. While this book was not the first book on Lisp I purchased, if I had to pick one book for the purposes of just learning the language this would be it. However, once beyond just initial stages, especially if you are already a programer like myself, then this book becomes less important. Which is fine because I don't think the purpose of the book was written for more advanced developers.



2. Whether your interest is learning a LISP dialect (new or old) or just a general interest in artificial intelligence, you can start with this book. The exercises are concise, clear, and useful in real-world applications. After all these years, there is still not a better primer. A must have for anyone interested in LISP programming.



3. This is a very nice introduction to Common Lisp. It is not advanced at all, and I feel like several things are missing from the book. For example, the chapter that introduces macros does not teach you how to deal with variable capture and other macro-related issues; The condition system is not explained at all; and all chapters from the first part of the book seem to be a bit superficial.
   
   Anyway, it's a fairly nice book, particularly for people who are totally new to Lisp.
   
   The second part of the book is something like an introduction to AI in Lisp (but "AI as it was in the 80's" -- not that it's bad, but lots of things happened in AI since then).



4. I have been through Gentle Introduction by Touretsky, ANSI Common by Graham, and Practical Common LISP ....all pissed me off. This book is what I have been waiting for, a BEGINNER BOOK, I am on chapter 3 and many of the concepts I have learned before are sinking in with this book. Lisp is fun and easy. I am using linux and vi editor with set: ai lisp option once I open vi. I load my definitions by launching clisp -i myfile.txt. There is a typo on p39 where the second both-ends definition should have LAST not REST. This made me blink until I realized it is a typo. Just above both-ends is defined correctly. It is obvious AFTER you see it let me tell you... lol The only other thing that is bad is that the right page text has a nice 2 inch space away from the book binding so it is easy to read. The left page reversed this and put the 2 inches of space on the outside away from the binding, so the text is right up against the book binding. If this is reprinted they should fix that.....hard to read many practice problems on left page since the text on the left page curves so hard toward the book binding since this is a huge tome.
   AWESOME BOOK!! COMMON LISP NEEDED IT!!



5. I bought this book interested in AI applications; I already knew LISP when I read it and I find it one of the best books for introduction to LISP. The text and samples themselves teach you how to learn.

3 comments about The Seasoned Schemer.

1. Dialogue style makes this book fun to read. Leitmotif of food examples keeps the tone light and the reader hungry. Have the number for pizza handy before you sit down for this book.

   Focuses on the use of functions in scheme, in an easy reading, enjoyable style. My only minor criticism is that the typographic conventions make the code hard to read. I realize that they serve a purpose, but it made the typesetting ugly.

   An admirable work, suitable for reading even if you already "know it all", just because of its approach to teaching.




2. This book is the second half of "The Little Schemer". It expects you to have mastered the previous volume, so it starts fast and picks up speed from there.

   It covers a lot of ground in a slim volume (just as in "The Little Schemer"). This book introduces the concepts of closures and call-with-current-continuation (among other things).

   As with "The Little Schemer", this book's strength is in its socratic instruction method. Lessons are written and illustrated as conversations between the reader and the instructor (in question/answer format). While this sounds strange, it is actually surprisingly effective as a means of learning the material. It might seem somewhat like rote instruction, but it can often frame foreign concepts in a rememberable fashion.

   Neither of these books require much in the way of background or familiarity with the material. They were created as a means of teaching non-programmers to program in Scheme. However, I think they hold value for trained programmers as well.




3. The Seasoned Schemer continues where the Little Schemer left off introducing local variables via let and it's variations including letrec. Set!, the syntax for changing a variables value is introduced. Continuations, as used for escaping from an computation and for going back to previous position in code are also introduced. There are less references to the accomplishments of famous computer scientists in this book than in the Little Schemer which I found to be disappointing. However, I greatly enjoyed this book and would recommend it to anyone wanting to increase their understanding of the Scheme programming language. Although scheme's vector data type is not introduced, I think you will have enough of an understanding of Scheme after reading this book to make substantial programs.

5 comments about ANSI Common LISP (Prentice Hall Series in Artificial Intelligence).

1. 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.



2. Common Lisp is a bit of a throwback. And so is this book, from 95. There is absolutely no graphics described for Common Lisp here. Not unlike Fortran, C or C++. Here you get a "pure" language, without all that user interface fluff. The lack of an update to this book in 10 years also reflects the stability of Common Lisp. Veterans of C or Fortran should recognise this.
   
   The language itself will be radically different to many readers, if they hail from a typical C, C++ or Java background. Very flexible and powerful. Plus, the code can be nicely compact. In some qualitative sense, you might say that Lisp has more expressive power than many other languages, per some unit length of source code.
   
   The numerous problems should be appreciated by the diligent reader. And they should be tackled.



3. Once you move beyond the very basics of Lisp this is a great book to have around. It has nice to the point examples of how to perform common and uncommon tasks in Lisp. In the back of the book there is a small description of the commonly used functions for Lisp. The brievity and size of the book plus the density of the material presented makes for a excellent book to have at your side while you are coding. I wouldn't recommend it for developers or anyone who has never seen Lisp code before but once you are beyond that stage it is an excellent bargin



4. Paul Graham does a great job of reminding readers in practical ways that designing programs means examining trade-offs of performance, memory use, and simplicity. I appreciate any computer science book that not only introduces a language but also drives the reader toward developing a thought process that will make them implement great solutions in any programming language.



5. This is not an introduction to programming book. Instead it describes how an experienced programmer can use CL. As such, it is very dense. Descriptions of new operators are part of the text, rather than displayed in figures (there is a good reference at the back). This keeps the book small though.
   
   Perhaps the most profound ideas in the book are bottom up programming (modify the language to add the commands you need), coding at the highest-level possible until the problem is well understood, and that code comments have cost:
   
   "Good code, like good prose, comes from constant rewriting...Interlinear comments make programs stiff and diffuse, and so inhibit the evolution of what they describe"
   
   As for downsides, I found the exercises for each chapter to be uneven. One asks us to create a function that returns a copy of a queue, later we're asked to detect car-circular lists, yikes.

5 comments about Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp.

1. I have no background in computer science or AI, but found myself needing to use Lisp for various creative and artistic purposes. I've spent a lot of money on books relating to Common Lisp, but I wish I had just gotten this one and Touretzky's "Gentle Introduction to Symbolic Computation." The particular strengths of this book are its detailed discussion of advanced topics, especially optimization, and the practical overview of current and historical AI topics through programming examples. Very clearly written.



2. The strength of this book is its combination of breadth and completeness: there is working code (well beyond the toy stage) of a large number of different AI systems that cover a large subset of what is commonly considered AI.

   The programming itself is rather basic, and very straightforward. In many places an advanced programmer would have avoided a global variable, unified code through the use of higher-order functions, had functions communicate through a shared local environment, created a lazy list, you name it.

   The author avoids most of these more advanced approaches in order to present the ideas behind the approaches without being sidetracked into programming technique issues, and that is the correct choice for this book. Even as it is, there is already the duplicity of teaching Common Lisp and teaching AI programming.

   That being said, the code in general is not bad at all, even though I wouldn't want my students to learn CL programming from it. The author has simply bent down to the level of, a good C programmer, and worked from there. His main intention being to teach AI programming approaches, he has spent much less time to raise the programming level of his audience.

   Knowing the author's level of Lisp programming, I can't wait to see a book by his hand on how to use abstraction as an organising principle in programming.




3. This book is equally excellent regardless of whether you wish to regard it as:

   a) A historical study of Artificial Intelligence, with USABLE examples of code, or

   b) A book presenting techniques for programming in Common Lisp.

   As a reference about Common Lisp, it is certainly lacking, but this is no great problem when both the Common Lisp HyperSpec and Steele's book are readily available in electronic form. It provides something more important: SIGNIFICANT examples, and significant discussions on WHY you would use various Lisp idioms, and, fairly often, discussions on HOW pieces of Common Lisp are likely to be implemented. Its discussion of an implementation of the LOOP macro, for instance, provides a very different point of view than the "references" to LOOP. (Contrast too with Graham's books, which largely deprecate the use of LOOP.)

   From an AI perspective, it is also very good, providing WORKING SAMPLES for a whole lot of the historically significant AI problems, including Search, PLANNER, symbolic computation, and the likes.

   It would be interesting to see parallel works from the following sorts of perspectives:

   - The same sorts of AI problems solved using functional languages (e.g. - ML, Haskell), to allow contrasting the use of those more modern languages. Being more "purely functional" has merits; such languages commonly lack macros, which is something of a disadvantage.

   - The use of CL to grapple with some other sorts of applications, notably random access to data [e.g. - databases] and rendition of output in HTML/SGML/XML [e.g. - web server].




4. This book has been called "The best book on programming ever written". I'd have to agree--it is certainly the best that I've ever read.
   
   William Zinsser said, "The essence of writing is rewriting" and the same can be said for writing computer programs. Norvig's book presents this process--how the limitations of a program are overcome by revision and rewriting. What sets Norvig apart as a writer is that, amazingly enough, he can write about debugging (the most dreaded part of computer programming) and make it a fascinating read!
   
   Lisp has been getting a higher profile lately because of essayists like Paul Graham and Philip Greenspun; in particular, Greenspun's Tenth Rule of Programming which states: "Any sufficiently complicated C or Fortran program contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp." So, should this book be read as an exhortation to return to Lisp as the preferred programming language?
   
   Paradoxically, I think not. One third of the way through the book, Norvig shows us how to implement Prolog in Lisp. From then on out, most of the AI techniques he presents either directly use Prolog instead of Lisp (such as his excellent discussion of natural language processing using Prolog) or use Prolog as a base to build on (such as his discussions on knowledge representation).
   
   From this we can abstract what I'd like to call Norvig's Corollary to Greenspun's Tenth Law of Programming: "Any sufficiently complicated LISP program is going to contain a slow implementation of half of Prolog". I'm leaving out the "ad hoc", "bug-ridden" part of Greenspuns's law, because Norvig's programs are neither. But it is quite remarkable the degree to which, once having absorbed Prolog, Norvig uses Prolog as the basis for further development, rather than Lisp.
   
   Is this a book about Prolog then? Again, no. What is the take-away message? It is this: as our world becomes more and more complex, and as the problems which programmers are facing become more and more complex, we have to program at a higher and higher level.
   
   Norvig does not stop at just embedding Prolog in Lisp. He also shows us how to embed scheme as well. Excellent discussion on the mysterious call/cc function and on continuations.
   
   In a capsule review, it is impossible to really give an overview of a 1,000 page book like this one. But the scope and heft of the volume really needs to be commented on: the programs presented in this book are like basis vectors, the totality of which nearly span the space of programming itself. In no way should this be considered "just an AI book" or "just a LISP book". This book transcends language, time, and subject matter. It is a programmer's book for the ages.



5. "Paradigms of Artificial Intelligence Programming" is one of the best books of computer science that I have ever read. I put it up there in the pantheon with "Structure and Interpretation of Computer Programs". I have found more useful and mind expanding material in these case studies than I have in many other books on computer science. I highly recommend this book to anyone, even if they have never used Lisp.

5 comments about Practical Common Lisp.

1. I was a bit skeptical about this book, but decided to take a look anyway while I was learning Lisp. It turns out that it was the book where I always went when I wanted to understand some concept and see how it's used in practice.
   
   It also helped me see that Lisp is indeed a great language! I will definetely start using Lisp from now on.
   
   I do recommend this book to anyone willing to start learning Lisp.
   However, this is not an advanced book -- it's purpose is to help you get into the Lisp way of thinking and get you ready to start working on real projects. Later you can get others, like Sonya Keene's Object-Oriented Programming in Common Lisp: A Programmer's Guide to CLOS, and paul Graham's wonderful On LISP: Advanced Techniques for Common LISP.



2. I am a PhD student in Economics, and started using Common Lisp as the numerical programs I ran became more sophisticated (contrary to popular myths, the speed of modern CL implementations is in the same league as C and Fortran).
   
   This book is an excellent and detailed introduction into the language, it assumes no prior knowledge of Lisp and provides the reader with excellent foundations to build on. I especially like that Seibel doesn't only enumerate the language constructs, but explains which ones are preferable in certain situations and puts a lot of things into perspective.
   
   The book is available online, if you like it, I suggest that you get a hardcopy, it is a worthwhile investment.



3. This book is the best "learn a programming language" book I've read. It is a very readable book, with excellent pacing and a good mix of theory and practice. I have found this book to be very good for teaching myself Common Lisp, and highly recommend it to anyone who wishes to do the same.



4. I tried more than one book to start learning CL, this one puts together the language principles with really well chosen code examples. The result is that I read it in a shot, with an increasing interest and never being intimidated.
   
   After it I approached again the P. Graham's books and I finally found them really enjoyable.
   
   The only critique I think is worth to be reported is about the software working environment. I tried lispbox on windows, but it is outdated, it is ok to try the companion source code downloaded from internet, but nothing more.
   To start doing anything more serious I finally moved to linux, sbcl, emacs-cvs, and slime-cvs, it has been a pain. A few paragraphs on this topic would have been really helpful.
   
   Anyway, it is a great reading! My gate to the Lisp world as a code writer instead of as a book reader.



5. If you've been using lisp for years already, the value of this book is probably more on the minimal side of things (although I suspect even a seasoned lisper might find it useful from time to time). However, if you're trying to get a grip on the ins and outs of coding in lisp, this book is a great place to begin. I find the book well-written and well-organized. Perhaps the biggest plus is that the book isn't overly 'dumbed down' and goes into sufficient depth to enable one to move beyond simple exercises at the REPL.
   
   It is also nice to have a hard copy and the online version both available.

5 comments about Structure and Interpretation of Computer Programs - 2nd Edition (MIT Electrical Engineering and Computer Science).

1. I'm an undergrad who is currently taking an introductory class in C.S using the book as the primary textbook (actually, the only textbook). Sadly, I'm taking it with another class in computer architecture with heavy emphasis on system programming (a la C, MIPS). Like one of the reviewers having pointed out, the excessive zeal of pedantic and theoretical C.S has left the students clueless about the connection between reality and fundamental ideas presented in the book. The authors enforces a grand vision of solving problems independent of programming language. Sadly, this is not the case in practice (I have been trying to port some algorithms in the book into C, oh boy, what a frustrating experience). This vision has left me a very bad impression on Scheme (a good-for-nothing language invented by geeks to impress other geeks).
   
   Some people have said they liked the book. At the beginning of semester. I liked the book too, since programming in functional style is completely new to me (who major in C.S wouldn't delight at learning new thing). HOWEVER, the more I delved into the book while taking a computer architecture course at the same time (in which I have to design a complete 8-bit CPU from ground up, as well as doing a lot of low-level programming), the more I feel there are some fundamental issues with using Scheme (or any other functional languages for that matter) as a tool to interpret and design machines and programs. It just struck me as very odd to design a computer "recursively". How ironic that the book is called "STRUCTURE and INTERPRETATION of computer programs".
   
   I agree with some reviewers in here who bashed C in favor of Scheme. C is not a very good language, but C deserves praises. There are reasons why it has been around forever (both in academic and in industry), and at this rate, I don't see how any functional languages would emerge out of academics as replacement for C. The authors in book braggs that only Fortran has been surviving longer than Scheme, but besides surviving in the this textbook (which has been pushed down my throat by my school), I haven't seen Scheme anywhere else.
   
   This textbook reminds me of the Feynman series in Physics. A series which everyone talks about, but when it comes to reality, it's just best used as a supplementary to look up for reference and self-congratulate as being "smart" rather than the one used to teach and learn from.



2. This is the best book on programming I have ever met in my life and, most probably, will ever meet.
   It not only surprised me and made me think "Oh my god, how come I didn't think this way/about these so incredibly important things before?" dozens of times in every single chapter during every of my 3(in a row) readings of it but it actually changed the way I think about programs and the way I write them.
   The authors have a perfect sense of balance between complexity and importance: they never skip important things silently and they never dig too deep into dull subtleties, instead they point out the really meaningful points and either invent a solution before the reader's eyes or give clues that inspire the reader to work out the solution himself.
   
   The book does not teach most of the basic algorithms and data structures, like quicksort of graph path finding (except for several examples that fit well for the purpose of a particular chapter), it is not a programming reference: it is a manual on methods of computation: exactly what the title says. So, in case you have a pragmatic problem you can't just take the book and find a solution: I guess this is the reason for low ratings. But if you read the book thoroughly, you will definitely become an order of magnitude better programmer and that is much more important than knowing concrete algorithms.
   
   I also extremely highly recommend the same-named video course by the same authors at http://swiss.csail.mit.edu/classes/6.001/abelson-sussman-lectures/ : I first was intrigued and shocked with it and only afterwards saw and immediately bought the book. It is a pity I have not yet had time to watch all the lectures (I watched about a half).



3. So there I was, 18 years old, having been raised on a toxic stew of MS-BASIC, Apple II assembly and some MPW Pascal. My mind was poisoned. Everything I knew about programming was wrong. I read book after book on programming and CS, but none of them really seemed to make a real dent in my style.
   
   Enter SICP. In a few months, this book reshaped my concept of what it meant to program a computer. It does not spend time teaching a language; Scheme is presented precisely because its syntax and commands can be covered in about ten minutes, and its structure becomes absolutely transparent within a few days of looking at Scheme code. It does not spend time walking the reader through common coding tasks, as a Learn X In 24 Hours text might.
   
   SICP teaches the fundamentals of programming mastery. Abstraction, modularity, design paradigms, compilation and interpretation, and more topics are presented in a style which is exactly as simple as it can be, and no simpler. Scheme allows these topics to be covered without becoming mired in details which would otherwise plague the implementor.
   
   It will not show you how to write a GUI, scrape a web page, develop a social networking website or create a network server. It will, however, guide a dedicated reader through an exploration of immensely powerful programming technique, and it will prepare the reader to solve any problem in any language for the future.
   
   SICP is not a machine gun, putting power into casual hands. It is a light saber, rewarding discipline and practice with unstoppable capability.



4. If you disagree, hopefully you're thinking Knuth. But consider this: Knuth is a wonderful bestiary of important programs and proofs; SICP is about the very nature of programming and programs.
   
   If you're not thinking either, and no offense to K&R et al: Do yourself a favor, watch the videos. Sussman & Abelson are entertaining teachers. SICP is a difficult book, and seeing Sussman in a fez after the metacircular evaluator just... helps.
   
   But of course Graham's and Norvig's reviews are gems of their own.



5. Abelson and Sussman have created a masterpiece, a book initially written in the 1980s, and that still hasn't lost one bit of relevance. Everything it contains must, must be learned and understood by any aspiring programmer. It teaches algorithms and data structures, good programming style, provides some contact with large systems, experimenting with their implementation and modification. You will learn about functional programming, imperative programming, object-oriented programming in it. You will learn how to implement interpreters, compilers, arithmetic systems, simulators, a whole virtual machine in it, and much more.
   
   The exercises of SICP are essential to understanding. Looking back at the work I've done on the book, I don't think I would have understood it near so well without doing a lot of the exercises. There's only so much material that can be gained from reading. Getting your hands dirty with code is essential to true understanding. And the authors of SICP brought this concept to perfection, with their excellent exercises, that are an unreplaceable companion to the book. Although they're not 100% perfect, for the most part the exercises are very well thought out and tuned to aid understanding and practice writing parts of large systems.