Let over Lambda–50 Years of Lisp (2008)
letoverlambda.com
letoverlambda.com
I have previously read the printed version, so maybe now is a time for a very brief review. The book is technically fascinating and a worthwhile read, but it is also highly opinionated even by Lisp standards. Then again, it is refreshing in this time and age to see this deeply human and creative side of programming. I wholeheartedly recommend others to read it - and to carefully choose which of the advice to follow and which not :)
Thank you so much, Doug Hoyte, for making this book available to all of us!
I have been programming in Common Lisp since the early 1980s, love the language, but I just use the language simply. That said I like the things that Doug, Paul Graham and others write about great Common Lisp techniques.
When an LLM is given access to a REPL, it gets even more interesting. Agents stop guessing and start empirically analyzing the current state of affairs, changing things dynamically, reaching the correct solution much faster and costing even fewer tokens.
Checkout the Forth implementation in https://letoverlambda.com/index.cl/guest/chap8.html
It's very good for realizing the difference between what is possible and what is feasible, since Lisp mastery requires both knowledge of what is possible to do and restraint in the actual use of those possibilities. Clever things require cleverer debugging techniques, and Let Over Lambda is absolutely full of the former.
A personal anecdote - not long ago I saw a beautiful piece of code (not mine) using the Result monad being rewritten as a chain of nested if statements - all because it was "too clever to understand". Go figure.
Sure, with proper documentation and comments and enough modularity to refactor this code as necessary - your example of moving between Result and an if-chain is an example of this.
"Too clever" is subjective, and often just means that the developer lacks sufficient familiarity with the abstractions, such as Result in this case.
The abstractions are what allow us to build systems with intrinsic complexity and keep them manageable. The "too clever" accusation is about perceived complexity, and depends on the observer. Expertise changes what seems complex or simple to someone.
It's possible to write macros without problems like variable capture in Lisp, it just takes some more care and a choice to follow this paradigm. LOL macros often explicitly choose not to follow it.
The book isn't about teaching lambda calculus, though. It's covering things you can do in Common Lisp, specifically around macros.
I wish I had found Lisp many years sooner. That simplified Haskell, Rust and Idris for me. The downside is that it turned out to be vastly pragmatic, and for personal stuff I'm on Lisp. Even though most things at work are not.
So, maybe you should honestly self-reflect: had that book not happened in your life before, would you even consider understanding LC today, unadulterated by "gimmicks"?
But perhaps we're teaching lambda calculus wrong. Let and lambda are essential building blocks of it, and Lisp is a sort of special case.
I don't think it has to be hard - To Mock a Mockingbird is just as enjoyable as LoL. It's just difficult to see significance of LC for programming, I think, because people do not think of lambda calculi as programming languages.