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
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.
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
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.
Post a comment