
A Common Lisp Bookshelf - momo-reina
http://mozartreina.com/lisp-bookshelf.html
======
arh68
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/](http://clqr.boundp.org/)

~~~
momo-reina
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.

------
fractallyte
Don't forget 'Successful Lisp' by David Lamkins
([http://psg.com/~dlamkins/sl/](http://psg.com/~dlamkins/sl/)) - in printed-
book or HTML versions.

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!

------
dschiptsov
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.)

~~~
momo-reina
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...

~~~
dschiptsov
All non-toy CL implementations do TCO nowadays. [http://0branch.com/notes/tco-
cl.html](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.)

~~~
lispm
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, ...)

~~~
momo-reina
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...

------
agentultra
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).

~~~
momo-reina
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...](http://programming-musings.org/2007/01/31/a-scheme-bookshelf/)

~~~
mheathr
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](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.

------
ruricolist
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.)

~~~
ajarmst
I came here to say this. Full text of title: Object-Oriented Programming in
COMMON LISP: A Programmer's Guide to CLOS

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

------
fsck--off
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...](http://www.amazon.com/Anatomy-Lisp-McGraw-Hill-computer-
science/dp/007001115x)

And then there are the original Lambda papers:

[http://library.readscheme.org/page1.html](http://library.readscheme.org/page1.html)

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

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

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

------
brudgers
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/)

~~~
01Michael10
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."

~~~
brudgers
Check the links for Chapters (< 8 n 13).

------
mrottenkolber
I really loved LoL! Might be a tad esoteric but gopes very deep into some very
powerful and underused areas of CL.

------
microcolonel
SICP isn't Common Lisp, @momo-reina.

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

------
jessaustin
Amazon links with no sneaky affiliate crap? Awesome!

~~~
tjr
What do you find sneaky about affiliate links?

~~~
jessaustin
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.)

~~~
jlarocco
If it's interesting enough that significant numbers of people click through
then I'm not sure it matters.

