
Let over Lambda – Common Lisp Book (2008) - matthberg
https://letoverlambda.com/
======
VLM
Interesting, possibly flawed analogy: The Build Your Own Lisp book explains
how, and the LoL book explains why. Build your own lisp book is the natural
pairing for LoL, despite many people claiming it goes best with Seibel's
common lisp book or whatever.

Seibel's book is good, don't get me wrong; I just don't think its the proper
pairing in the sense of culinary arts putting together a plate of well paired
books.

The common lisp people and the clojure people fight viciously as only siblings
can; this will infuriate those in the common lisp tribe but the ideal
introductory lisp book in the general sense of the language is probably not
Seibel's book its probably the comedic Clojure for the Brave and True. Not
aware of anything quite like that, for common lisp.

------
eatonphil
I enjoyed this book. I personally did not find it condescending. Additionally,
the implementation of a Forth interpreter in this book is the best
introduction to Forth I've seen (even after years spent playing with Forth and
reading one or two books on Forth). But I don't recommend this book as an
introduction to (Common) Lisp.

I recommend this order:

1\. Practical Common Lisp

2\. On Lisp (kind of a big jump, so maybe check out ANSI Common Lisp)

3\. Let over Lambda

4\. Lisp in Small Pieces (especially if you want to implement a Scheme or
Common Lisp)

With Common Lisp the Language (Guy Steele) and ANSI Common Lisp (Paul Graham)
somewhere in the mix.

These are all excellent books and must-reads for anyone interested in
programming languages and/or the Lisp family.

~~~
zoltar
Good list. Practical Common Lisp deserves that spot at the top. It's very
approachable and provides examples of all those features you keep hearing good
things about. I remember running through the spam filter chapter and finding
an email that SpamAssassin misclassified about four years prior.

I think my favorite Forth introduction comes at it from the other direction,
though:
[https://github.com/nornagon/jonesforth/blob/master/jonesfort...](https://github.com/nornagon/jonesforth/blob/master/jonesforth.S)

~~~
eatonphil
That is a really impressive guide.

------
agumonkey
slightly related: the clasp/cando team has some news to share

Putting this here because I'm not aware of a lot of research done in/with lisp
these days (only other thing I know is the quantum computer dsl)

[https://old.reddit.com/r/lisp/comments/axu858/here_is_what_w...](https://old.reddit.com/r/lisp/comments/axu858/here_is_what_we_are_doing_with_common_lisp/)

> This our (thirdlaw.tech's) computational chemistry system Cando. Some might
> remember it from Lisp conferences or our previous videos. Here is a demo of
> going through a free energy perturbation calculation. FEP is very important
> in chemistry right now.
> [https://www.youtube.com/watch?v=hZRuGt4TcD8&list=PLbl4KVdl9U...](https://www.youtube.com/watch?v=hZRuGt4TcD8&list=PLbl4KVdl9U3I3MhFWgauT0cz-x7SymZmn&index=4&t=0s)

~~~
cracauer
That is me, I'm half of that team (Martin Cracauer).

If you have any questions I'd be happy to answer.

If you want to learn more about the programming side of our work (not so
chemical), check out our other videos. They are from programming conferences:
Longer talk:
[https://www.youtube.com/watch?v=8X69_42Mj-g&t=177s&index=3&l...](https://www.youtube.com/watch?v=8X69_42Mj-g&t=177s&index=3&list=PLbl4KVdl9U3I3MhFWgauT0cz-x7SymZmn)

Shorter one from the LLVM meeting:
[https://www.youtube.com/watch?v=gYYH2zF41fc&list=PLbl4KVdl9U...](https://www.youtube.com/watch?v=gYYH2zF41fc&list=PLbl4KVdl9U3I3MhFWgauT0cz-x7SymZmn&index=2&t=201s)

(yes, the whole system is a compiler using LLVM as the last stage to make
machine code from abstract assembly. The thing I always missed in SBCL)

~~~
agumonkey
Oh well I just had a question but not related to cando itself more about how
you structure your research project / team / finance. But maybe that's not a
place to discuss this.

~~~
cracauer
Feel free to message, here or on twitter or whereever.

------
pepper_sauce
It can be abrasive at times but is full of gems of knowledge. Well worth a
read.

------
t-sin
This nice book is a Lisp book but also a Forth book. Forth is great.

------
rhizome31
Is there a prominent open source project written in Common Lisp? Something
like Pandoc for Haskell or RabbitMQ for Erlang?

~~~
cracauer
Common Lisp has a package manager/source repository called Quicklisp.
[https://www.cliki.net/Quicklisp%20tutorial](https://www.cliki.net/Quicklisp%20tutorial)

There are some web frameworks in there that are fairly impressive.

There is very little advertising going on. It goes a bit back to what your
folks mentioned here, a bit of dejection and being condescending to other
languages. Common Lisp is the only language with reasonable compile-time
computing right now, and it is hard to bring that concept over to people who
still think about writing software, as opposed to living with changing
software for 30 years. So the Lisp community is a bit in the mindset that
those who get it do so on their own, and software is distributed among those
who already know they want.

The Cando chemical computation system (based on Clasp) in the video posted
below/above is open source, BTW.

~~~
vram22
>Common Lisp is the only language with reasonable compile-time computing right
now

How does D compare, with its CTFE (Compile-Time Function
Evaluation/Execution)?

------
ravieira
I bought Land of Lisp by Conrad Barski but never really read it due to
procrastination. I really wanna read Lisp one day. Also, I didn't see Land of
Lisp mentioned here. What do experience lispers think about it?

~~~
talaba
I have some experience with Common Lisp, although not too much. I have read
Land of Lisp and enjoyed it very much. It may not adhere to software
engineering best practices, such as avoiding mutating the global state, etc.,
but for learning CL without getting bored, this is the book.

------
ratsimihah
I tried to read it as a first Lisp book, that was very theoretical. I just
write Lisp these days while looking up what I need on-demand. Will probably
give it another read when I have a better idea of what Lisp is.

------
maze-le
>> it describes the most advanced features of the most advanced language:
COMMON LISP

... really? the most advanced language (?), are we back in the 50ies again?

~~~
Grue3
Common Lisp was finalized in the 90s. And it's not its fault that the other
languages haven't caught up yet.

~~~
maze-le
Still, its a trip to hell to maintain any lisp codebase -- especially if it
contains macros. I think it is actively hostile to collaborative programming,
and that is a structural problem where there is no remedy but obscure
programming patterns (which are amplifying these problems in some instances).
With that in mind -- boasting about 'the most advanced language' is a bit of a
stretch -- to say the least...

~~~
PuercoPop
Do you say that out of experience? That is certainly not my _experience_. Lisp
codebases tend to be easily "appropiable"

~~~
varjag
It sounds more like someone's musing of why Lisp should be bad idea rather
than anything practical. Doubly so when they don't seem to know what Common
Lisp is.

~~~
PuercoPop
I agree it _sounds_ like an armchair critic, but I prefer to give the benefit
of the doubt. Maybe they had a bad experience involving Lisp?

The actively hostile to collaborative programming seems particularly
misguided. Even an extreme case like the code from hu.dwim, which is written
in practically a new language they built on top of CL and has barely any
documentation is still fairly easy to understand.

~~~
fiddlerwoaroof
Yeah, and the other thing is that the macrostep expander in slime makes it
fairly straightforward to understand how an unfamiliar macro works: you just
expand it a couple steps and see how its mapping the surface syntax to
utilities you know. In fact, I often find function calls harder to grok now
than custom macros :)

------
wirrbel
Worth a read because it is one the most condescending computing books I have
ever read. While reading I got the impression that I read the text of a really
immature fanboy in a web forum of the 2000s.

I hope the author has matured by now. Seriously, don't buy this book.

~~~
black-tea
I thought it was great, but I know it's not a book for snowflakes. When I hear
someone say "this is right" or "this is wrong", I am able to effortlessly
interpret this as "I believe this is right/wrong". It's just being efficient
with language. I don't need people to add extra words for fear of offending
me.

Maybe the author was immature. That's great. Let it remind you what it's like
to be young and so excited about something that you'd write a book about it.
This book is great.

~~~
damsdu78
Do you think it is useful for a Lisp noob?

~~~
fiddlerwoaroof
This book is sort of a trap because some of the macros it defines make
assumptions that are not guaranteed by the language specification: every once
in a while, you’ll find people on IRC or similar asking for help with some of
the examples from this book.

Also, IMO, the defmacro/g macro defined in this book would have been better
defined as a reader macro than as a codewalking macro.

~~~
weavie
If I recall somewhere around SBCL 1.2 they changed the way the backquote
worked (totally fine for them to do that as it wasn't specified in the
standard..) which broke the Let over Lambda macro.

I think CCL still works.

The code here should fix the problems : [https://github.com/thephoeron/let-
over-lambda](https://github.com/thephoeron/let-over-lambda)

Note, it's been a while since I looked at it so I could have some of the
details wrong. The book is still well worth reading to help you understand the
possibilities with a programmable programming language, but just bear in mind
the various caveats..

------
tuukkah
_> it describes the most advanced features of the most advanced language:
COMMON LISP._

I thought Haskell surpassed it a long time ago already.

~~~
m00natic
So where's Haskell's advanced object system or the restart/condition system
that Common Lisp has? Even its performance is hardly on par with CL for all
the flexibility of the latter.

~~~
tuukkah
I'm not saying it has everything that Common Lisp has - it's _different_.

