Posted 2010-01-16 02:55:00 GMT

I've been meaning to write something about Let over Lambda for a while. This book is positioned as a sort of successor to On Lisp. Last year, I got in touch with the author, Doug Hoyte, because I was curious about his antiweb server. Doug generously gave me an access code for the book. I also ordered a hardcopy for work. Then yesterday, Hacker News (which has a giant soft spot for Lisp) was running a post by Jack Harper to the ever-interesting Lispworks mailing list, explaining why he wrote his fingerprint scanner's software with Lispworks, in which he heavily praises Let over Lambda.

Unfortunately, LoL doesn't really fit into an easy category. It's not a comprehensive hand-holding introductory text like Practical Common Lisp, and it doesn't stay aloof from practical issues like On Lisp. I'd say it's more a wide ranging collection of novel techniques for Common Lisp. Hoyte says the point ... is to expose you to ideas that you might otherwise never be exposed to. The book certainly succeeded with me. Some of the ideas I might disagree with, but they are generally thought-provoking.

An example is the defmacro! macro (a replacement for defmacro), which goes through and creates gensyms for all symbols used in its sub-lexical scope that start with "g!". It certainly is can be a bit tiresome continually predeclaring all the vars you use in your macro expansion with alexandria:with-gensyms, and that does introduce another level of indentation. On the other hand, do you want to deal with this kind of implicit variable creation? It violates the principle of least surprise. Debating the morality of end result, however, ignores that the journey to it was surprising and introduced a new idea. Arguing over whether or not to use a tool is only possible if you've heard of it and LoL introduces many original tools.

Sadly, only the weaker first chapters of the book are freely available, giving a wrong impression of the overall book (recently chapter five was opened). The later chapters introduce much more advanced concepts and are where the book really gets going. The discussion on sub-lexical scope (including the sublet macro) isn't anywhere else, as far as I know, and his sortf using Batcher's algorithm is thought-provoking.

While his Lisp fanaticism is ladled on rather thick, claiming e.g. no other language has the potential for secure software that lisp does, Hoyte isn't one of those ivory-tower pontificators who think that the compiler should magically transform their vague programs into efficient machine code. He shows several disassemblies and discusses how more complex features like keyword arguments are implemented in practice, and even touches very briefly on practical security (unfortunately, not addressing how to deal with heap and stack-overflows — but then again, nobody addresses how to deal with those).

In the posting that finally gave me the impetus to write this review, Jack Harper, who's been programming Lisp for decades, says about Let over Lambda, you end up with an enormously powerful set of programming tools unlike anything else out there. I find it difficult to unequivocally recommend the book, but that puts me into a quandary as the good bits are really excellent, and I'd like to encourage more people to read it. The flaws you can skim over. Let over Lambda introduces a unique and fresh approach. If you're already comfortable in Lisp or willing to put a fair amount of effort in, you should read this book.

I found the Let over Lambda fun, entertaining and often unexpected. I hope it will inspire you.

PS. For other opinions, see Vladimir Sedach's balanced review or Adam Petersen's more enthusiastic reception.