A Common Lisp Bookshelf(mozartreina.com)
mozartreina.com
A Common Lisp Bookshelf
http://mozartreina.com/lisp-bookshelf.html
33 comments
Keene's "Guide to CLOS" is good for understanding how CLOS was intended to be used. (Actually, since I read it, I use CLOS less, since I have a better sense of what it's good for.)
I came here to say this. Full text of title: Object-Oriented Programming in COMMON LISP: A Programmer's Guide to CLOS
Personally, I don't think Let over Lambda and On Lisp are super advanced or hardcore. I found On Lisp very readable not too long after I got rolling with Common Lisp (after quite a few years programming experience, though). Of course, both books have great concepts that still make me muse for a moment over the nature of code.
Unlike the author, I found Practical Common Lisp to be the lamp for my path into Lisp, and have no qualms about recommending it to other people.
Unlike the author, I found Practical Common Lisp to be the lamp for my path into Lisp, and have no qualms about recommending it to other people.
About "On Lisp" and "Lisp in small pieces", the author has the order backwards, "On Lisp" is a much easier book to apprehend, and deals with less advanced concepts. In "On Lisp" you'll learn how to leverage macros. In LISP you'll learn how to implement them.
Link to Second Edition [draft] of How to Design Programs:
http://www.ccs.neu.edu/home/matthias/HtDP2e/
http://www.ccs.neu.edu/home/matthias/HtDP2e/
Your link is to the current release of the book NOT the draft version as explained on the site...
"Note: this document is the current release of HtDP/2e. It is updated in conjunction with PLT software releases, roughly in sync with semester spans. It is thus well-suited for courses. In contrast, the current draft changes on a frequent basis; it should be consulted when people discover problems and/or errors in this document. If such flaws exist in both documents, please report them to the first author."
"Note: this document is the current release of HtDP/2e. It is updated in conjunction with PLT software releases, roughly in sync with semester spans. It is thus well-suited for courses. In contrast, the current draft changes on a frequent basis; it should be consulted when people discover problems and/or errors in this document. If such flaws exist in both documents, please report them to the first author."
Check the links for Chapters (< 8 n 13).
I really loved LoL! Might be a tad esoteric but gopes very deep into some very powerful and underused areas of CL.
SICP isn't Common Lisp, @momo-reina.
I included it because I felt it was too good to leave out despite the fact that it uses Scheme. Lisp in Small Pieces is also mostly Scheme, though some CL features are covered in detail (I was look for some excuse for it to make the cut).
I'll edit the post though and note those two things to avoid potential confusion.
I'll edit the post though and note those two things to avoid potential confusion.
Wow, I'm a little surprised. I took the _exact_ same path all the way up to PAIP. It's eerie to read your thoughts on a blog that isn't yours.
Anyway, the CLQR [1] is by far the most useful CL book I've found. It's small enough to print and bind yourself, and the pages on LOOP & the type hierarchy are just pure typography.
I recently finished Let Over Lambda (finished the first read-through, anyway), and I almost wish I had started with it. CL is the C of the lambda calculi, but it didn't 'click' until the final chapters of LoL. With a sufficiently smart compiler (and by compiler I mean sets of macros), CL can do damn near anything.
ANSI Common Lisp is a great book, too, but I found the chapters oddly arranged (chapters 12,13 need to come first, maybe).
[1] http://clqr.boundp.org/
Anyway, the CLQR [1] is by far the most useful CL book I've found. It's small enough to print and bind yourself, and the pages on LOOP & the type hierarchy are just pure typography.
I recently finished Let Over Lambda (finished the first read-through, anyway), and I almost wish I had started with it. CL is the C of the lambda calculi, but it didn't 'click' until the final chapters of LoL. With a sufficiently smart compiler (and by compiler I mean sets of macros), CL can do damn near anything.
ANSI Common Lisp is a great book, too, but I found the chapters oddly arranged (chapters 12,13 need to come first, maybe).
[1] http://clqr.boundp.org/
Thanks for the heads-up, I wasn't aware of CLQR. Will definitely check it out.
LoL is definitely one of the major highlights in my reading plan.
LoL is definitely one of the major highlights in my reading plan.
Practical CL (written with Java mindset) is a waste of time, compared to PG's ANSI CL which has more idiomatic, subtle examples. Then On Lisp, of course.
HtDP should go before SICP. HtDP2 is a much better reading than old HtDP. In both books exercises must be done.
PAIP is a decent reading, but mr. Norvig, it seems, dislikes macros and recursion and prefers strictures and loops.)
btw, all the books are "available" on piratebay, if you are not too strict or american.)
HtDP should go before SICP. HtDP2 is a much better reading than old HtDP. In both books exercises must be done.
PAIP is a decent reading, but mr. Norvig, it seems, dislikes macros and recursion and prefers strictures and loops.)
btw, all the books are "available" on piratebay, if you are not too strict or american.)
Practical Common Lisp is great. ANSI CL by PG is so so. For example PG explains CLOS without examples - instead he implements his own object-system. That's WRONG in a book about ANSI Common Lisp, but PG never liked CLOS anyway. CLOS plays an important part in many CL based software libraries. PG's book provides nothing more like an expanded dictionary for it and the pointless other object system can be forgotten instantly.
PAIP is one of the best books about programming ever. Generally loops are preferred over recursion in CL - it is not Scheme.
'Piratebay' pays also for the Lisp authors and encourages them to write books? Wonderful, let us know how it works.
PAIP is one of the best books about programming ever. Generally loops are preferred over recursion in CL - it is not Scheme.
'Piratebay' pays also for the Lisp authors and encourages them to write books? Wonderful, let us know how it works.
[deleted]
I had a few discussions with some guys at #lisp, they looked over some code I'd written that was recursion-heavy, and they were of the mind that since Tail-Call Optimization is not in the ANSI standard and therefore implementation dependent one should be careful when using them.
Now that totally changes if you're writing Scheme...
Now that totally changes if you're writing Scheme...
All non-toy CL implementations do TCO nowadays. http://0branch.com/notes/tco-cl.html
Anyway, it is worthwhile to practice writing recursive solutions (beginning with Scheme) to understand possible pitfalls in case of non-tail recursion, and then, proudly, switch to fixed-space looping techniques.)
Anyway, it is worthwhile to practice writing recursive solutions (beginning with Scheme) to understand possible pitfalls in case of non-tail recursion, and then, proudly, switch to fixed-space looping techniques.)
There are a few problems with TCO in Common Lisp:
* some platforms don't provide useful support (in the History it were some stack-oriented Lisp Machines, nowadays it is the JVM - see ABCL)
* there is no consensus how it should be invoked, how its effect should be reported by a compiler, how the user should be noted about limitations (example: LispWorks limits the number of variables), ...
* it is not a good fit with Common Lisp, since the language supports all kinds of dynamic constructs: dynamic binding, unwind-protect, ... It is not clear how this should interoperate with TCO in CL.
* it makes debugging more diffcult (backtraces, trace, ...)
* some platforms don't provide useful support (in the History it were some stack-oriented Lisp Machines, nowadays it is the JVM - see ABCL)
* there is no consensus how it should be invoked, how its effect should be reported by a compiler, how the user should be noted about limitations (example: LispWorks limits the number of variables), ...
* it is not a good fit with Common Lisp, since the language supports all kinds of dynamic constructs: dynamic binding, unwind-protect, ... It is not clear how this should interoperate with TCO in CL.
* it makes debugging more diffcult (backtraces, trace, ...)
These were the exact points raised at #lisp. They also tried to explain the CL idiom to a recursive problem which I don't really recall except the fact that I didn't understand it...
Yeah I've blown the stack more times than I can recall when using non-tail recursion. I do enjoy recursion, it seems like a clean and elegant solution, though I'm ridiculously preoccupied with writing non idiomatic code.
Pascal Costanza has an interesting opinion[1] on why TCO wasn't included in the ANSI standard.
[1]http://www.p-cos.net/lisp/guide.html
Pascal Costanza has an interesting opinion[1] on why TCO wasn't included in the ANSI standard.
[1]http://www.p-cos.net/lisp/guide.html
I actually found the Little/Reasoned/Seasoned Schemer series to be rather enlightening even as an experienced programmer (Little Schemer can seem a little basic at first but the principles it teaches are sound and applicable outside of Lisp programming as well).
Jao, author of Geiser, talks about the impact they had on his development in his post A Scheme Bookshelf[1]. Are there any CL equivalents?
[1]http://programming-musings.org/2007/01/31/a-scheme-bookshelf...
[1]http://programming-musings.org/2007/01/31/a-scheme-bookshelf...
The Little Schemer and Reasoned Schemer are tremendously fun reads. Little Schemer's writing and presentation style is the standard by which I compare all technical books now.
The books happen to use scheme as their teaching platform but the books are entirely about communicating the concepts that happen to be a part of scheme.
The way the Little Schemer teaches recursion is absolutely brilliant.
If I found myself teaching an intro programming class that would be a part of the curriculum as it is short and communicates the concept in a way that is inescapable while not being dry whatsoever and can be entirely read in a few short settings at most.
By the way, I know from personal experience that at least the majority of the books listed in Jao's scheme bookshelf can be readily worked through in a Common Lisp that supports full TCO, which according to an article from 2011 (http://0branch.com/notes/tco-cl.html) is at least
CMUCL SBCL CCL Allegro LispWorks
I happen to have used SBCL, but I imagine the others would work just as well for these purposes.
Having not worked through them, I cannot confirm whether Programmer avec Scheme or Lisp in Small Pieces can be worked through in CL with slight modifications to the source but I do not see why not.
Google suggests that there does not exist a translation of Programmer avec Scheme anywhere, and no reviews are available on either amazon.fr or amazon.com; that is unfortunate.
The books happen to use scheme as their teaching platform but the books are entirely about communicating the concepts that happen to be a part of scheme.
The way the Little Schemer teaches recursion is absolutely brilliant.
If I found myself teaching an intro programming class that would be a part of the curriculum as it is short and communicates the concept in a way that is inescapable while not being dry whatsoever and can be entirely read in a few short settings at most.
By the way, I know from personal experience that at least the majority of the books listed in Jao's scheme bookshelf can be readily worked through in a Common Lisp that supports full TCO, which according to an article from 2011 (http://0branch.com/notes/tco-cl.html) is at least
CMUCL SBCL CCL Allegro LispWorks
I happen to have used SBCL, but I imagine the others would work just as well for these purposes.
Having not worked through them, I cannot confirm whether Programmer avec Scheme or Lisp in Small Pieces can be worked through in CL with slight modifications to the source but I do not see why not.
Google suggests that there does not exist a translation of Programmer avec Scheme anywhere, and no reviews are available on either amazon.fr or amazon.com; that is unfortunate.
There aren't equivalents that I know of, but the book did start off as the Little Lisper and the recent edition that I have does have examples translated to CL in the footnotes.
Amazon links with no sneaky affiliate crap? Awesome!
What do you find sneaky about affiliate links?
There is nothing sneaky per se about affiliate links. I certainly expect them on most sites. I have wondered, however, about HN links to what were essentially affiliate-link farms. It seems to muddle the purpose of interaction on HN: is the link here because it is interesting, or because it might make somebody a few dollars? I think if gaming HN becomes common, HN won't be as valuable to all of us. So it's something of a moral duty to punish attempts at gaming. (Commercial attempts, anyway. If it's for the lulz then it's probably OK.)
If it's interesting enough that significant numbers of people click through then I'm not sure it matters.
Great post, I am wanting to head down this path. I am really wanting to get Lisp in Small Pieces but is it super costly.
Maybe I will look at Let Over Lambda.
Maybe I will look at Let Over Lambda.
Though will mostly repeat what others have said, here it is:
ANSI Common Lisp from Paul Graham is also a good CL textbook. I bought it as a complement to Practical Common Lisp and it also has a nice quick reference at the end.
Having read both On Lisp and Let Over Lambda, of those, I would recommend On Lisp more because it has more practical applications of macros, LOL is much more esoteric/playful/abstract, and not everybody is into that sort of thing.
ANSI Common Lisp from Paul Graham is also a good CL textbook. I bought it as a complement to Practical Common Lisp and it also has a nice quick reference at the end.
Having read both On Lisp and Let Over Lambda, of those, I would recommend On Lisp more because it has more practical applications of macros, LOL is much more esoteric/playful/abstract, and not everybody is into that sort of thing.
A good book for experienced Lispers (because it's out of date, it's not for beginners) is Allen's Anatomy of Lisp. Good luck finding a copy, though.
http://www.amazon.com/Anatomy-Lisp-McGraw-Hill-computer-scie...
And then there are the original Lambda papers:
http://library.readscheme.org/page1.html
http://www.amazon.com/Anatomy-Lisp-McGraw-Hill-computer-scie...
And then there are the original Lambda papers:
http://library.readscheme.org/page1.html
Chapter 3 is an excellent 'nutshell' introduction to Common Lisp. The rest of the book, aside from covering various details of CL, provides a wide-ranging overview of the modern Lisp ecosystem, from editors to UIs.
I found it a valuable complement to the other books noted here, but somehow it doesn't get much mention!