Let over Lambda

Let over Lambda is a new self–published book on lisp by Doug Hoyte. I'm not quite sure what to make of it, overall.

It's great to see a book full of straight-ahead programming these days rather than mere system composition. It's especially great to see an extended work dealing with programming in the small. It's great fun to see someone who really likes programming as an activity in its own right exhibit their enjoyment. It's a great pleasure to see assembly language appear in a programming book of the 21st century. I find the curious combination of lisp being at once both a very high level language suited to symbolic programming and being very close to the metal most stimulating. That's a pair of properties that the programming language design mainstream seems to have abandoned. Java, for instance, doesn't feel particularly close even to the JVM.

It's especially great to see a lisp afficionado standing up for vi.

Assembler arises in a couple of spots where the impact of macros, the parsimony of lisp's internal representations and the intelligence of the lisp compiler combine to collapse quite sophisticated source code down to startlingly few opcodes. Which is all very fascinating. So much so that I was inspired to resurrect the SBCL installation on my Mac and go refresh my memory of how cute the disassemble function is. However, it feels to me as if an opportunity has been lost to take that just a bit further and come up with some Programming Perls–like startling observations about performance.

The book builds up to a very interesting exercise in implementing Forth. It's very nicely done and a great illustration of how easy it is to implement one interesting language given another. Lisp/Prolog used to be the canonical pair, I think. This illustration makes a good case for lisp/forth being roughly as illuminating.

Along the way there are several not–quite–consistant claims about what the book is for and the big build up to the alleged principle of “duality of syntax” is a very long run for a very short slide. Again, it feels as if an opportunity to do somehting really startling has been lost. There's a sort of plonking “here it is” presentation of this and other material. It's often good and interesting material, but needs a little bit more development in places.

It's perhaps not so great to have the, what shall I call it? unfettered enthusiasm of the author for lisp, macros and all that they imply coming at you un–moderated. I don't think that a commercial editor would have allowed quite so much polemic to make it onto the page. There's a bit too much direct quotation of Paul Graham material (“Blub”, “secret weapon”, you know the sort of stuff) that makes it quite clear that there are on the one hand people who get it, and on the other dullards. This is made very explicit on the back cover blurb:
Only the top percentile of programmers use lisp and if you can understand this book you are in the top percentile of lisp programmers.
Hmm. I have a strong feeling that I understand most of what's in the book and also that I'm not in the top of the top. Whatever that means. I'm not even a “lisp programmer” in any very serious sense of the term. Faced with a little light programming to do then in the absence of any other constraints I'm likely to reach for Scheme—and that brings me to another item that a commercial editor probably wouldn't have let through.

You might imagine that the differing trade–offs made in Scheme and Common Lisp are something that reasonable people could agree to disagree about. Hoyte wants his reader to understand very clearly that this is not so: the choices made in Scheme are wrong (emphasis in the original) and those made in CL are right (emphasis also in the original). The first one of these assertions was amusing enough. The second, not so much. And they just keep on coming. Hoyte is far too young to be settling scores from some X3J13 puch–up, wich would be embarrasing enough, so it all ends up looking a bit adolescent to me.

One last thing...at least in the print–on–demand form I've got from Lightning Source UK the book looks absolutely ghastly. “Made with lisp” says the front matter. Lisp with a lot of help from TeX and that's really not good enough for 2009, not without a lot more tuning than has gone into this. And Lightning Source (or whomever did the camera-ready copy) have originated the work at too low a resolution. That and the lazy choice of CMR combined with the glossy toner makes the actual print a less than comfortable read. Self–publishig has a long way to go yet.


Doug Hoyte said...

Dear Peripatetic Axiom,

Thank you for your review of Let Over Lambda. Your comments are fair and well received.

About the strong language, ie doing things "right" versus "wrong" and "top percentile programmers" and the like, I won't apologise but in hindsight I probably would have phrased things a bit differently. Still, I prefer writing that is bold and assertive as opposed to wavering and uncertain so I hope you can forgive me for taking some artistic liberty.

I must not have explained my thoughts on duality of syntax properly because I maintain my position that it is one of the most important principles of lisp, even if my examples of it are somewhat benign and trivial.

I'm sorry you didn't like the fonts and formatting. It is possible that the UK printer fouled it up in some way. If that is the case I can ship you a USA-printed copy. My email address is on my website.

Thanks again for taking the time to read and review my book,

Doug Hoyte

Mark Dalgarno said...

Scheme is nice but 20 years of commercial programming in CL suggests that Doug is right on that point.

BTW I've heard you speak a couple of times and you most clearly are in the top percentile :-)

keithb said...

Re Lisp: could be. I've never written Lisp for money (Smalltalk and Prolog, yes) so I'm prepared to be wrong on that.

Re the other: you are too kind.

Anonymous said...

I think it's nice that authors have strong opinions when they can defend them. Paul Graham aptly demonstrates Lisp superiority, so what? A little boasting can also be a fun way to relate to the audience. People (and programmers) are not created equal. And maybe you are smarter than you think ;-)

nakadaldalus said...

I found Hoyt's enthusiasm for Lisp and disparagement of all other languages quite entertaining. Of course you have to take all such statements with a grain of salt, but the same goes for practically anything that a person could say.

Many of the most memorable books on computing are permeated with a distinctive attitude about programming. Larry Wall's Perl book comes to mind as well. I think it's more than just the entertainment value, it's the way that this attitude connects on a deeper level with your own feelings about programming and what drives you to do it, even when it's hard.

A certain level of arrogance is necessary to be a good programmer or engineer. To look at a hard problem and say, "I'm going to solve that," it takes self-confidence and determination. You have to have some stones or you're never going to get anywhere.