Customer Reviews

On Lisp: Advanced Techniques for Common Lisp

5 star:		(11)
4 star:		(2)
3 star:		(0)
2 star:		(1)
1 star:		(0)

 

 

When I find something really interesting in a book that I want to remember later, I write the page number on the end page. A good book might get 5 to 10 page numbers so noted. My copy of On Lisp has 25. Now, not every one of the 25 contains something I agree completely with, but they all made me think. If you're experienced at Lisp, you'll find a similar number of thought-provoking ideas, and if you're new to Lisp, you'll find a whole new way of looking at programming (and you'll find that you can apply the new ideas to other languages as well).

Looking at Graham's code felt like reading my own code masterfully translated, say, from Danish to Swedish. A lot of the ideas are the same, some of the old friends had new names, and there were some new friends that I had never bothered to abstract and name, but recognized instantly once Graham did so (e.g. mapcars, fn).

Along with the ideas, I admire the many handy turns of phrase that make the book a real page-turner:

"It used to be thought that you could judge someone's character by looking at the shape of his head. Whether or not this is true for people, it is generally true of Lisp programs."

"The classic Common Lisp defmacro is like a cook's knife: an elegant idea which seems dangerous, but which experts use with confidence."

"Lisp is not inherently about processing lists any more than Polo shirts are for Polo" (Note that the sentence would have been a little confusing if Graham had written "list processing" rather than "processing lists". In Graham's prose, like his code, every word counts. Time and again I can only say "I wish I had thought of that.")

Go to paul graham's website and download this book for free now. You'll be happy you did.

There are dozens of programming texts that I recommend to people who want to understand various topics. There are only a small handful that I recommend to programmers who aren't using the tool or language that the book covers. This is one of those books. It requires a prior knowledge of Lisp, but not expert knowledge. Paul Graham rewards his readers with a much deeper understanding of the merits of Lisp and how to take advantage of the power it provides.

Paul Graham has commented on his web site ..., "It seems to me that there have been two really clean, consistent models of programming so far: the C model and the Lisp model. These two seem points of high ground, with swampy lowlands between them. As computers have grown more powerful, the new languages being developed have been moving steadily toward the Lisp model." I read that comment before I read On Lisp. It was fresh in my mind at the time, and I saw some of the features of Lisp in C++ and Java. Graham cites runtime type checking and garbage collection, but there are subtler features that appear in the C++ STL. When he described using macros to create functions as needed, his examples immediately brought to mind some of the templates for various "helper" classes; pair, for example. But he could equally well be talking about some of the classes in the Java runtime that are designed to be derived from. The bottom line is that this book is an excellent tutorial on good library design. It teaches by example the philosophy behind creating libraries that extend your language, either in general ways or specifically for the problem domain.

Paul Graham handles Lisp lovingly as an expert craftsman. An observant reader can learn a great deal about craftsmanship from his book. Eric Raymond stated in his essay How To Become A Hacker, "LISP is worth learning for a different reason - the profound enlightenment experience you will have when you finally get it. That experience will make you a better programmer for the rest of your days, even if you never actually use LISP itself a lot." Mr. Graham has commented about this specific quote wondering why anyone would learn about a great tool and then not use it. Lisp in general and this book specifically are an answer to that question. Lisp is not a single language. It is a family of languages that share a common philosophy and a core. Once you learn what gives Lisp its power, you can choose to enhance any tools you use with some measure of that power.

This is the only technical book I've read cover-to-cover *twice*. As others have noted, the author treats macros in *far* greater detail than any other books on Lisp. Furthermore, I thought his example code was more easily understood than most programming books.

The only caveat: this book *is not* for people beginning lisp. Given it's title, this obviously doesn't reflect poorly on the book.

This is an excellent book, and if you understand it it will make you a better lisp programmer. See the other reviews here or search through the comp.lang.lisp archives for testemonials. Yes, it's _that_ awesome...but unfortunately On Lisp is out of print, and is really hard to find used copies of--probably because nobody wants to part with it. Furthermore, it doesn't look like Prentice Hall, or anyone else will be publishing it any more. Fortunately, Paul Graham has made this available in postscript and pdf forms on his website. It's missing a few figures, but will definitely be helpful for everyone who has been patiently waiting months for a copy. Thanks, Paul!

One problem with Lisp novices is that they generally try to treat Lisp like ALGOL or C; but while Lisp is, technically, an imperative language, it is best used as a functional (and symbolic) language, and that requires a different approach to solving problems "in the Lisp way". Once learned, this problem solving approach can be used in a variety of situations even with other programming languages, but the real problem has been the lack of good presentations of Lisp that didn't either concentrate just on the lanugage itself, or on applications. _On Lisp_ is one of the best treatments of *Programming in Lisp*, in my opinion, as it takes the reader beyond just the semantics of the language, and teaches them typical patterns of code which helps one know how to look at problems so they are easy to solve in Lisp.

No matter what your experience level (and I had been a professional Lisp hacker for over ten years when I first read this book), there is something to learn from _On Lisp_. Read it, and improve your ability to conceptualize solutions to your programming problems. END

One of the strange things about Lisp is that while there exist books for beginners and for true wizards, there are relatively few books for those caught in the middle; who have progressed beyond the initiate but are not yet wizardly. _On Lisp_ is such a book, and is an extremely good introduction to both what makes Lisp so different and so wonderful, and what being a Lisp guru is all about. Macros in particular are a strong point; the bulk of the book is an enormous system of macros culminating in a Prolog implementation. Highly recommended for those it targets.

I've been programming Perl for over 10 years. I started to read On Lisp recently (though I've had to stop for a few weeks while I finish an "emergency" project) and the book has already changed my Perl programming style completely. Even though the book is not about Perl and even though I'm only half-way though the book, my programming techniques have evolved so significantly that my programs are about 1/10 the length of what they used to be, they are easier to debug, and far more enjoyable to program.

Finally I found out why people like Stallman consider Lisp the most 'powerful' language in existence. This book does a very good job explaining the mode of thinking that lisp programmers use; in other words, it's a very introspective book.

It is aimed at people who know how to use the language already; for an intro, you may wish to look at his book _ANSI Common Lisp_.

About macros: It is an important feature of the language. If you eventually decide that macros are harmful, it is best to been shown macros' full strength so you can make such an informed decision.

If you don't know what macros are, they're just sort of a shorthand you define, that gets expanded to its full form. It may be a bad idea to use often in normal programming for languages like C or Java, but Lisp is sufficiently different that macros may be very useful in making code that generates more code.

This book treats advanced Lisp techniques. Its strongest feature is the treatment of writing Lisp macros. I've been working with Lisp for thirty years now and this is the best treatment I've seen on writing Lisp macros. This book should be considered a MUST for any serious Lisp programmer.