---
product_id: 5424401
title: "Let Over Lambda"
price: "19.97 OMR"
currency: OMR
in_stock: true
reviews_count: 8
url: https://www.desertcart.com.om/products/5424401-let-over-lambda
store_origin: OM
region: Oman
---

# Let Over Lambda

**Price:** 19.97 OMR
**Availability:** ✅ In Stock

## Quick Answers

- **What is this?** Let Over Lambda
- **How much does it cost?** 19.97 OMR with free shipping
- **Is it available?** Yes, in stock and ready to ship
- **Where can I buy it?** [www.desertcart.com.om](https://www.desertcart.com.om/products/5424401-let-over-lambda)

## Best For

- Customers looking for quality international products

## Why This Product

- Free international shipping included
- Worldwide delivery with tracking
- 15-day hassle-free returns

## Description

Let Over Lambda [Hoyte, Doug] on desertcart.com. *FREE* shipping on qualifying offers. Let Over Lambda

Review: Advanced. Audacious. Inspirational. - 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.
Review: Highly Recommended - 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.

## Technical Specifications

| Specification | Value |
|---------------|-------|
| Best Sellers Rank | #886,416 in Books ( See Top 100 in Books ) #19,215 in Computers & Technology (Books) |
| Customer Reviews | 4.5 4.5 out of 5 stars (68) |
| Dimensions  | 6 x 0.85 x 9 inches |
| Edition  | Edition 1.0 |
| ISBN-10  | 1435712757 |
| ISBN-13  | 978-1435712751 |
| Item Weight  | 2.31 pounds |
| Language  | English |
| Print length  | 384 pages |
| Publication date  | April 2, 2008 |
| Publisher  | Lulu.com |
| Reading age  | 1 year and up |

## Images

![Let Over Lambda - Image 1](https://m.media-amazon.com/images/I/51JS6XpPz6L.jpg)

## Customer Reviews

### ⭐⭐⭐⭐⭐ Advanced. Audacious. Inspirational.
*by M***I 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.

### ⭐⭐⭐⭐⭐ Highly Recommended
*by K***S on May 14, 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.

### ⭐⭐⭐⭐ Despite the annoying Common Lisp evangelism this is a great book for the non-novice Lisper.
*by P***O 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: [...]

## Frequently Bought Together

- Let Over Lambda
- Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp
- The Art of the Metaobject Protocol

---

## Why Shop on Desertcart?

- 🛒 **Trusted by 1.3+ Million Shoppers** — Serving international shoppers since 2016
- 🌍 **Shop Globally** — Access 737+ million products across 21 categories
- 💰 **No Hidden Fees** — All customs, duties, and taxes included in the price
- 🔄 **15-Day Free Returns** — Hassle-free returns (30 days for PRO members)
- 🔒 **Secure Payments** — Trusted payment options with buyer protection
- ⭐ **TrustPilot Rated 4.5/5** — Based on 8,000+ happy customer reviews

**Shop now:** [https://www.desertcart.com.om/products/5424401-let-over-lambda](https://www.desertcart.com.om/products/5424401-let-over-lambda)

---

*Product available on Desertcart Oman*
*Store origin: OM*
*Last updated: 2026-02-21*