A Common Lisp Bookshelf
mozartreina.com
mozartreina.com
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).
LoL is definitely one of the major highlights in my reading plan.
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!
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.)
Now that totally changes if you're writing Scheme...
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.)
* 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, ...)
Pascal Costanza has an interesting opinion[1] on why TCO wasn't included in the ANSI standard.
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.
[1]http://programming-musings.org/2007/01/31/a-scheme-bookshelf...
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.
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.
http://www.amazon.com/Anatomy-Lisp-McGraw-Hill-computer-scie...
And then there are the original Lambda papers:
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.
Maybe I will look at Let Over Lambda.
"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."
I'll edit the post though and note those two things to avoid potential confusion.