What's your favorite book about Lisp?

I was curious what people thought was their favorite book about Lisp. I can't list everything in the poll, so if you have additional ones that I haven't mentioned, add them as a comment.

On Lisp is missing from the list

That's awfully hard, you know. I picked one, but there are at least 4 others I would consider essential

mmmk wrote:On Lisp is missing from the list

Ack! You're right. I typically don't think of it because I don't have and can't get a printed copy of it (still waiting for Paul to get something over to Apress to republish it, I guess... ). Anyway, yep, that's a serious omission. The polling module only lets you have 10 choices, though, so adding it would be tough. I have to admit that it's probably in my top 3, along with PAIP and Lisp in Small Pieces.

If not for Practical Common Lisp I never would've bothered with the language. It's a great book on many levels.

I'm working through ANSI Common Lisp as my holiday project. What it has over PCL is exercises, but the two books have different coverage of what is a pretty ginormous language.

I've found this site useful as a reference when I've finished my own solutions to the exercises.

I don't know if SICP could be classified as lisp book. Yes it does talk about lisp, scheme to be more precise. But it is more of a general computer science book as it uses scheme as a means to explain general concepts.

You might add "Lisp: A Gentle Introduction to Symbolic Computing" by David Touretzky, which is particularly good for beginners. However, "Practical Common Lisp" by Peter Seibel is what we give new hires at ITA Software when they arrive and don't know Common Lisp yet. I voted for that (despite my obvious interest in "Common Lisp: The Language", the first edition of which I am a co-author). If you know how to write software and want to learn Common Lisp, "Practical Common Lisp" is your best bet. See http://www.gigamonkeys.com/book/.

dlweinreb wrote:You might add "Lisp: A Gentle Introduction to Symbolic Computing" by David Touretzky, which is particularly good for beginners. However, "Practical Common Lisp" by Peter Seibel is what we give new hires at ITA Software when they arrive and don't know Common Lisp yet. I voted for that (despite my obvious interest in "Common Lisp: The Language", the first edition of which I am a co-author). If you know how to write software and want to learn Common Lisp, "Practical Common Lisp" is your best bet. See http://www.gigamonkeys.com/book/.

Yea, I should have added that disclaimer that you aren't allowed to vote for your own books. Employees and their immediate families are excluded and all that.

I'm actually split between ANSI Common Lisp and Practical Common Lisp. Frankly, I thought that ANSI Common Lisp was a bit more gentle introduction than Practical Common Lisp, but maybe that's because I read ANSI Common Lisp first. That said, they're both excellent, IMO.

Jacques Chester wrote:I'm working through ANSI Common Lisp as my holiday project. What it has over PCL is exercises, but the two books have different coverage of what is a pretty ginormous language.

I've found this site useful as a reference when I've finished my own solutions to the exercises.

I voted for ACL over PCL (although i like them both) for its style, exercises, and appendix B and D.

The one place where ANSI Common Lisp lacks versus Practical Common Lisp is with respect to CLOS. PG is not a fan of CLOS and doesn't really cover it. In contrast, Peter Siebel uses is heavily in PCL. That's one reason I recommend both to people. You'll definitely learn something from each.

Out of the books on that list, SICP is my favorite, but strictly speaking it is less 'about' lisp than those of the others I have read. My second choice is PAIP.

dlweinreb wrote:You might add "Lisp: A Gentle Introduction to Symbolic Computing" by David Touretzky, which is particularly good for beginners.

Seconded! It's a brilliant book for new-comers to Lisp without an extensive programming background. You can get it here:
http://www.cs.cmu.edu/~dst/LispBook/index.html

After which I would recommend following Nick Levine's lectures that guide you through ANSI Common Lisp and add a few more exercises and a project. Available here:
http://www.nicklevine.org/declarative/lectures/

findinglisp wrote:The one place where ANSI Common Lisp lacks versus Practical Common Lisp is with respect to CLOS. PG is not a fan of CLOS and doesn't really cover it. In contrast, Peter Siebel uses is heavily in PCL. That's one reason I recommend both to people. You'll definitely learn something from each.

Dito. Also, PCL is sometimes easier to comprehend than ACL, whereas I find that ACL in spite of being a little bit more "sophisticated" is worth reading it twice or maybe even three times.

I like both ACL and PCl but to be honest, for someone who wants to start learning Lisp, I recommend ACL. I feel that PCL is best suited for a person who already has some contact with the language. Even if that contact is not much! Both books are complementary to each other so using both at the same time to learn the language might be a good option. But my favourite Lisp book is still PAIP, perhaps because of the huge influence it had on me when I read it

skc wrote:I voted for ACL over PCL (although i like them both) for its style, exercises, and appendix B and D.

Agreed about ACL over PCL (as long as I'm remembering right and Appendix B is the Lisp in Lisp section).

Sadly, neither book address the pile of soup that is (loop ...). Each have a few examples. I'd like to be able to read (loop ...) calls even if I stick to (do ...) and (do* ...) when writing my own code. What's the best book/resource for learning about (loop ...)?

The HyperSpec. There's a pretty good description of loop's BNF. But I must admit that it takes some time to work through this page.

@findinglisp:
you can get the pdf of "On Lisp" and print it out yourself. Thats what i did, and it's worth it.

plutonas wrote:@findinglisp:
you can get the pdf of "On Lisp" and print it out yourself. Thats what i did, and it's worth it.

Yea, I have the PDF. I have read about 90% of it on-screen (airplanes, etc.). I haven't wanted to print it out to save the trees, and at the time I first started reading it, I heard that APress was going to reprint it. That would have been ideal, had it happened.

I picked The Art of the Metaobject Protocol simply because I learned more about programming from that book than any other I've ever read. I've read most of them (even CLTL2!) and they're all enjoyable. I'd have to pick Norvig's PAIP as my second.

My favorite is PAIP but from the list all are pretty good books.

findinglisp wrote:The one place where ANSI Common Lisp lacks versus Practical Common Lisp is with respect to CLOS. PG is not a fan of CLOS and doesn't really cover it. In contrast, Peter Siebel uses is heavily in PCL. That's one reason I recommend both to people. You'll definitely learn something from each.

OOP does not suit how I think at ALL.
Once he starts using it he loses me completely, so I stopped reading it.
A Gentle Introduction is pretty much all functional.

BTW, I grabbed an old copy (1984) of "Lisp: A Gentle..." for 11usd but is it worth it to spend another 25usd for one that fits the CL spec? I have the digital version, but I can never concentrate reading a digital book...

I'm surprised to see no mention of Successful Lisp here. I finished most of Practical Common Lisp, but found it somewhat hard going. Perhaps too much exposure and too much detail before I was ready and I wasn't doing much practical work. I paused at Chapter 24 and decided to go back to basics, which is when I started reading Successful Lisp. So far it seems to be composed of smaller, more cohesive chunks which makes it a pleasure for me to read (perhaps I'm just a poor reader, but that's another matter Or it may be because I already read most of PCL and am just more familiar with the stuff). It also makes it easier to manage on my PDA (I spider a (section of a) site with a program called Sunrise, which then converts and compresses the files into one smallish archive I can bluetooth to my Tungsten T3 and read whenever I'm idling/waiting/walking etc).

Also, Paul Graham's "On Lisp" has a html mirror, which some may prefer than the PDF/etc versions.

My favourite Lisp book is my copy of Lisp In Small Pieces, partly because it is signed by Kathleen Callaway and partly because it's the book I'd most like to have read entirely and fully grokked (and it's set using TeX, like all proper Computer Science books should be).

My favourite Lisp book that I've actually read is On Lisp, partly because I had to print & "bind" it myself and thus it felt like when I taped The Hitch-hikers Guide to the Galaxy off the radio as a kid, and partly because of Paul Graham's wonderfully demonstrative voice.

I also really like PAIP because it is, like On Lisp, clearly packed full of The Lisp Way. I hope to one day make it through to the end of the book, in time to steal a march on some of the next "new ideas" in programming.

To paraphrase THHGTTG:

Much has been written on the subject of Lisp, most of which stresses the many practical functions it can serve for the modern programmer.

Two seminal books are Peter Norvig's compendious tome Paradigms of Artificial Intelligence Programming, which is far too large to carry, but sits magnificently on fashionable coffee tables, and Paul Graham's handbook, On Lisp, an altogether terser work for masochists.

Of course the book from which I actually learned Lisp was ANSI Common Lisp and my indispensable reference is Practical Common Lisp.

Practical Common Lisp.

It won't get into deep/hairy/complex/advanced stuff, BUT it's something Lisp was needing badly: a book that is easy to read and focus on practical, real world problems. The Haskell community just got something similar with "Real World Haskell". Check google trends for "Lisp". You'll see that interest in Lisp grew since PCL was published. Even though Seibel and his book are not the only causes for the new interest in Common Lisp, his book certainly made a big difference.

Hi folks, about Practical Common Lisp I'm going through the book I'm currently reading chapter 13 and I wonder why this is considered to be a great book, so far it hasn't conveyed any original idea about programming and it seems to be just a boring list of lisp functions without going into any detail about them, but I'm only half way through the book so I hope it's going to get better ^___^

lukasjob wrote:Hi folks, about Practical Common Lisp I'm going through the book I'm currently reading chapter 13 and I wonder why this is considered to be a great book, so far it hasn't conveyed any original idea about programming and it seems to be just a boring list of lisp functions without going into any detail about them, but I'm only half way through the book so I hope it's going to get better ^___^

I felt kind of the same way when I was reading it. It just felt like an overwhelming snow of API specifics (especially the headaches with pathnames and the slightly excessive focus on CLOS IMO).

Currently I'm reading SICP (only in section 2.2 or something so far) and it's very enjoyable and enlightening - lots of opportunities and ideas about the power of higher-order functions and such. It's based on Scheme but that's ok by me.

Exolon wrote:

lukasjob wrote:Hi folks, about Practical Common Lisp I'm going through the book I'm currently reading chapter 13 and I wonder why this is considered to be a great book, so far it hasn't conveyed any original idea about programming and it seems to be just a boring list of lisp functions without going into any detail about them, but I'm only half way through the book so I hope it's going to get better ^___^

I felt kind of the same way when I was reading it. It just felt like an overwhelming snow of API specifics (especially the headaches with pathnames and the slightly excessive focus on CLOS IMO).

Currently I'm reading SICP (only in section 2.2 or something so far) and it's very enjoyable and enlightening - lots of opportunities and ideas about the power of higher-order functions and such. It's based on Scheme but that's ok by me.

Hi Exolon, glad to hear that so I'm not the only one thinking PCL is not a great book
I read the first 3 chapters of SICP and completed all the exercises from those chapters great book loved that
Check this out http://eli.thegreenplace.net/category/p ... lisp/sicp/

Personally I am finding chapter 24 in PCL to be almost impossible to understand. In comparison, I thought SICP was pretty easy until the latter half where it required a think-while-reading approach instead of just reading it like a novel and solving examples as they came up. Except the one where you had to make a nested table and the functions ended up like (set-car! (set-cdr! (set-car! (car (cdr (car lol)))) omg) rofl) -- that one was tricky to debug.

The problem for me is that PCL went from the early chapters:
a very easy this is a function to slightly more complex this is a macro which could one day be a function

to let's take a break and talk about lists, CLOS, conditions, etc. without gaining any real experience using the language or getting better with it

to now everything is suddenly written in macros that write macros (using hardly used macros at that point in the book such as with-slots and eval-when) which may be contained in classes that have inherited macros from other macro-generated classes..................................

At no point was it ever clear what code might actually be executed at run-time (or load time or compile time or interpreted time or fun time or wtf time). Now of course there is macroexpand-1 which I used as much as possible, and in the very beginning of the chapter it was fairly obvious what was going on. I in fact jumped ahead and wrote the macro to generate the first version of define-binary-class except for not knowing how to convert a symbol to a keyword. But after that the chapter gets pretty ridiculous.

Maybe there is like a 175 IQ requirement to use LISP, and I seem to have fallen short of it.

It could be just an entirely different way one must think. Perhaps instead of trying to figure out why the code works, I should just pretend the names of the functions do what they say they do and use them as one would have to use them. Maybe it can work by abstract magic. "So if this function that appends slot specifier names to other names that were inherited to get a list of every possible slot name in the inherited class, then 'of course' I would put the function as the first argument to with-slots if I want to be able to access every slot." ....

And that's just 1/10 of that one particular class-generating macro--a function that depends on about 5 other function definitions to do almost nothing:
Why the hell isn't there a built-in function/macro to list every slot in a class anyway? One could just append new names to (find-slots 'superclass) or some such.

I hesitate to progress further with this book when I still have to learn python, bash, perl, every new C++ and C# language feature from whatever came before .net to .net 9.2 or whatever it's at now, not to mention Haskell's template thing which is supposed to somehow compare to macros, just so that one day I might be able to be somewhat of a slightly qualified modern programmer (?) Of course, I don't have the slightest clue about the STL-equivalent for all of these languages, so at the end of the day I still can't write a single program that really does ANYTHING except games in C++ which is how I got started. The point is, PCL isn't helping and in fact is further diluting my ability to focus on learning something that might one day be helpful. It seems books in general are pretty passe and one should just use google to learn what function they need RIGHT NOW and go ahead and use it. Programs of the future will be written in a language learned on the fly! (if not present already)

I started out reading Practical Common Lisp, but I didn't really like his style of explaining things. Then I tried ANSI Common Lisp and I think it's great. It may be a little hard to follow for complete programming beginners but for people who have already programmed in other languages it's just right.

LDream wrote:That's awfully hard, you know. I picked one, but there are at least 4 others I would consider essential

The Common will simply be the best because it is where it all started. But I would agree to LDream that there are more that we like, not just one!

"Common Lisp: A Gentle Introduction to Symbolic Computing" by David Touretzky.

This is not only my favorite Lisp book, but my favorite programming book ever. I have been through quite a few books, but I have never encountered an easier book on programming. At first I couldn't tell if it is easy because of Lisp or the book, but as I went along, I think it is a combination of both. SICP is a bit too abstract for a beginner and PCL is pretty much practical for those that know how to program already. Touretzky's book is a good in-between. ANSI Common Lisp, isn't too bad, but some of his example codes aren't easy for a beginner. Also, there are no answers to the exercises (except an unofficial one online). Anyhoo, unlike most new Lisp people that were converted by PCL, Touretzky's book converted me to Lisp.

Keene's book is my personal favorite. It's not comprehensive, but it is extremely well done.

Would be handy if it also asked which we've read this questionare is biased toward the books that are read more. I only read PCL and part of SICP, i refrained from voting..

Seanner27 wrote:Personally I am finding chapter 24 in PCL to be almost impossible to understand. In comparison, I thought SICP was pretty easy until the latter half where it required a think-while-reading approach instead of just reading it like a novel and solving examples as they came up. Except the one where you had to make a nested table and the functions ended up like (set-car! (set-cdr! (set-car! (car (cdr (car lol)))) omg) rofl) -- that one was tricky to debug.

The problem for me is that PCL went from the early chapters:
a very easy this is a function to slightly more complex this is a macro which could one day be a function

to let's take a break and talk about lists, CLOS, conditions, etc. without gaining any real experience using the language or getting better with it

to now everything is suddenly written in macros that write macros (using hardly used macros at that point in the book such as with-slots and eval-when) which may be contained in classes that have inherited macros from other macro-generated classes..................................

At no point was it ever clear what code might actually be executed at run-time (or load time or compile time or interpreted time or fun time or wtf time). Now of course there is macroexpand-1 which I used as much as possible, and in the very beginning of the chapter it was fairly obvious what was going on. I in fact jumped ahead and wrote the macro to generate the first version of define-binary-class except for not knowing how to convert a symbol to a keyword. But after that the chapter gets pretty ridiculous.

Maybe there is like a 175 IQ requirement to use LISP, and I seem to have fallen short of it.

...

I'm relieved to see I'm not the only person who felt like this. Not just Chapter 24, but I can tell you from memory the exact page number - p. 324 - where my comprehension slowly grinds to halt and I'm left in a daze. I first started reading PCL over two years ago, and I've never gotten past this point, despite many attempts, and decided to go on to other books like SICP and "On Lisp."

I suspect that a lot of the material in PCL was not written from the beginning as instructional text, but rather adapted from code that the author had previously written for a personal project. And the adaptation was very poor, IMO. The whole chapter just dumps a huge load of complex code on the reader without ever actually showing how it works in action (until later chapters). It would be much better to start out with a simple defun'ed library, then show where it's inflexible, and go step by step, extending it (through macros, CLOS, tags, etc.) as needed.

A lot of material in PCL gave me the impression that the author just wanted to show off how cool he is, and unfortunately that makes for poor instruction.