Amazon.com: Customer Reviews: Let Over Lambda
Your Garage Summer Reading Amazon Fashion Learn more Discover it Songs of Summer Explore Premium Audio Fire TV Stick Sun Care Patriotic Picks Shop-by-Room Amazon Cash Back Offer AnnedroidsS3 AnnedroidsS3 AnnedroidsS3  Amazon Echo  Echo Dot  Amazon Tap  Echo Dot  Amazon Tap  Amazon Echo Starting at $49.99 All-New Kindle Oasis UniOrlando Best Camping & Hiking Gear in Outdoors STEM

Customer Reviews

4.8 out of 5 stars12
Format: Paperback|Change
Price:$38.00+ Free shipping with Amazon Prime
Your rating(Clear)Rate this item


There was a problem filtering reviews right now. Please try again later.

on October 31, 2008
Let over Lambda is an exploratory journey into advanced techniques involving Common Lisp features and language properties, that can be combined in ways that result in more than the sum of their parts.

There are plenty of "wow, that is cool" moments and useful constructs demonstrated, that will probably make it into the reader's toolkit. But of greater importance is the progression in how these are delivered. While not a broad tutorial in Common Lisp (although the reader-macro chapter could serve fairly well in that capacity), Let over Lambda contains an underlying tutorial on the incremental/iterative development of such macros/tools against desired requirements - building up to constructs via interim revisions and explanations.

A book involving Lisp has little choice but to stand on the shoulders of giants, and by necessity these are frequently referenced and cited. The most important of these is Graham's "On Lisp" (currently available for free download) - which, while attempting to cover the breadth of the language, is regarded as one of the more advanced texts on macros. Some topics introduced in On Lisp (such as the leveraging of unhygienic macros) are taken much further in Let over Lambda, and combined with other constructs (such as capture/closures) that would have to be described separately in more general purpose tutorial or language overview.

The writing style definitely includes an "attitude" that is partially inherent to the material being discussed and partially from the author's obvious passion (a passion that becomes REALLY obvious in the Forth chapter). Hoyte often highlights the blanket superiority of Common Lisp over all other languages; but to a reader who has put in the time to learn Lisp macrology in enough detail to understand this book, this isn't a particularly large stretch. Also, certain comfortable safety idioms are challenged as being more safeguards for beginners. On several occasions, the reader receives an explanation: "Here is the what and why of adhering to restriction X. Now here are the incredible things that become possible when you break it!" This is demonstrated via unhygienic macros, as well as the broader concept of "duality of syntax" - a definition that evolves throughout the book.

Early in the introduction Hoyte states that macros (in a language that can leverage them) are more than just boilerplate-reduction tools for known simple cases; but that their power represents a sort of "uncharted territory" of immense potential. Certain common (seemingly) ideological arguments (things like lisp-1 vs lisp-2), were laid out against a backdrop of examples and threaded into the theme of the entire book. While often going out on a limb, the author makes his case.

I was inspired by this book.
0Comment|122 people found this helpful. Was this review helpful to you?YesNoReport abuse
on March 29, 2009
This book is for intermediate or advanced lisper. It's great writing, with excellent style and very fun to read. Doug Hoyte is extremely intelligent person who shared his specific techniques of metaprogramming and macro writing. Reading this book will introduce you to many cool utilities and knowledge that will advance your lisp macro skills. Paraphrasing Alan Perlis : a book that doesn't affect the way you think about programming, is not worth reading. And let over lambda certainly will influence the way you think. You might disagree with Hoyte, or ignore his advice but you will certainly learn there is another way of lisping.
0Comment|47 people found this helpful. Was this review helpful to you?YesNoReport abuse
on September 2, 2009
I've recently moved up from being a lisp beginner to an intermediate lisp user. Part of doing that is reaching a better understanding of closures and writing macros. LoL does a good job of helping you get to that next stage in the first set of chapters (my favorite part of the book). I find Doug's writing style to be easy to follow and somewhat more enjoyable than Paul Graham's OnLisp. LoL uses macros in ways not covered in other lisp texts including OnLisp. For that reason alone is it worth getting. I'm still growing as a lisp programmer and the other chapters are still beyond my understanding but I can easily see myself coming back to it when I'm ready.
0Comment|37 people found this helpful. Was this review helpful to you?YesNoReport abuse
on July 7, 2010
It took me over 3 months to read this book cover to cover. Although I haven't read Graham's 'On Lisp', which is why it may have taken so long for me to read this book. That said, I learned more about programming in lisp (and programming in general) during the last three months than I have over the past two years that I've been exposed to the language.

By far, my favorite section of the book is in Chapter 6, on pandoric macros. I was immediately able to apply 'plambda' and 'with-pandoric' to my own code as soon as I saw them. Such a wonderful abstraction.

Doug Hoyte, you've turned me into a lisp lifer. Thanks!

-Clayton
0Comment|28 people found this helpful. Was this review helpful to you?YesNoReport abuse
on February 13, 2011
If you know your way through the multiple flavours of Lisp this book becomes really interesting. Doug starts by explaining the basics of why one would want macros in a programming language and quickly moves on to extending the basic Common Lisp language with all sorts of new features; including a very sweet chapter implementing Forth macros. Most of the code is based on lexical closures, hence the book's title.

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: [...]
22 comments|40 people found this helpful. Was this review helpful to you?YesNoReport abuse
on May 13, 2010
I haven't finished it, but like another reviewer I am being inspired by this book.

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

And,

"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.
0Comment|21 people found this helpful. Was this review helpful to you?YesNoReport abuse
on November 7, 2014
A mixed bag. Contains some interesting and worthwhile ideas. Also contains an equal number of broad, unsupported claims and idiosyncratic digressions. I found it interesting as a sort of memoir of how Hoyte thinks about programming, as manifested in his affection for Lisp macros. But he occasionally falls victim to his own tunnel vision. For instance, Hoyte dismisses hygienic macro systems without providing any evidence that he appreciates why they exist. (He's also surely the world’s only Lisp programmer who considers Perl "beautiful.")
0Comment|7 people found this helpful. Was this review helpful to you?YesNoReport abuse
on May 16, 2016
The book is amazing, if the bit chaotic at times. Besides covering lexical closures, lexical, dynamic and other types of scoping, it contains a solid discussion of metaprogramming in general and practical use of Lisp macros. Some of the examples used are pretty mind-bending (in a positive way). I highly recommend it for any serious Lisper.
0Comment|Was this review helpful to you?YesNoReport abuse
on November 3, 2015
Great book about Common Lisp, one of the best out there.
Hoyte must have spent years preparing the material, and it shows in the presentation.

There is nothing dry here, the pages read extremely smooth. After the first 3 chapters
which serve as a sort of introduction, the reader is hammered with techniques,
one after the other!

There was some controversy in #lisp when this book was first released, some regulars
(hello drewc!) didn't quite like it, but in my view that is because they never dove below
the surface and really tried to appreciate what this book teaches.

Hoyte deserves major props for pulling this out.
0Comment|Was this review helpful to you?YesNoReport abuse
on May 4, 2014
This book is right up there with SICP and Lisp In Small Pieces. If you are serious about Lisp (any dialect) this book is one of the best.
0Comment|2 people found this helpful. Was this review helpful to you?YesNoReport abuse