Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Other Sellers on Amazon
+ Free Shipping
Let Over Lambda Paperback – April 2, 2008
The Amazon Book Review
Author interviews, book reviews, editors picks, and more. Read it now
Frequently bought together
Customers who bought this item also bought
If you are a seller for this product, would you like to suggest updates through seller support?
Top Customer Reviews
In the first couple of chapters, the author shows examples of assembler, C and Lisp, mostly in preparation for introducing lexical closures.
Closures, it turns out, are generated easily in Lisp by using the construction "let over lambda".
Regarding closures, I agree with the author that most of us have been left "with the inaccurate impression that closures are only good for toy examples like counter." But in fact, "closures are the building blocks of Lisp. Environments, the functions defined inside those environments, and macros like defun that make using them convenient, are all that are needed for modelling any problem." And in fact, the author's aim is "to stop beginning Lisp programmers . . . from . . . reaching for systems like CLOS." Yes, CLOS offers certain things, but ". . . do not use [CLOS] when a lambda will suffice."
If you're like me, you find all this very refreshing and stimulating.
From pages 31-37, the author deftly shows how objects are collections of procedures and associated state, and how the entire object infrastructure is easily derived from the lexical closure, otherwise known as "let over lambda," and combinations of "let over lambda over let over lambda." The ease and power with which this is demonstrated is breath-taking.
A couple of more quotes: "Object systems are a formalisation of a subset of let and lambda combinations, sometimes with gimmicks like inheritance bolted on (footnote 10: Having macros is immeasurably more important than having inheritance.)"
"Once assignable value cells and good old lambda expressions are available, object systems are, at best, occasionally useful abstractions and, at worst, special-case and redundant."
As I indicated, I have not finished the book, but the first couple of chapters have given me plenty to consider. I highly recommend this book.
The opinion-to-fact ratio makes the book a very hard read, though. The usual arrogance towards different language and paradigms (please forget that section on Functional Programming) is somewhat expected but makes it really hard to enjoy the text.
Even though Hoyte's blind evangelism of Common Lisp is extremely annoying, he is a great hacker and knows how to reuse other people's work --even if originally written in one of the Lisps he despises.
If you are fairly new to Lisp in general and Common Lisp in particular I don't think you will find it very interesting. Even if you write code in Clojure -the Lisp most people I know are exposed to these days- I would recommend that you read the fantastic Practical Common Lisp, by Peter Seibel, before trying this one.
What I love most about this book is how it teaches you to think of macros as nothing but functions that return lists. The fact that these lists happen to contain code is irrelevant; macros are still functions.
Full review: [...]
Most Recent Customer Reviews
Hoyte must have spent years preparing the material, and it shows in the presentation.Read more
Author must be true lisp lover.Read more