ANSI Common LISP by Paul Graham

by Paul Graham

ANSI Common Lisp combines an introduction to Lisp programming, and a convenient, up-to-date reference manual for ANSI Common Lisp. Beginners will find that its careful explanations and interesting examples make Lisp programming easy to learn. Professional programmers will appreciate its thorough, practical An up-to-date reference manual for ANSI Common Lisp. An in-depth look at object-oriented programming. Explains the Common Lisp Object System (CLOS), and also shows how to write your own object-oriented language. Over 20 substantial examples, including programs for ray-tracing, text generation, pattern-matching, logical inference, generating HTML, sorting and searching, file I/O, compression, and date arithmetic. Special attention to critical concepts, including prefix syntax, code vs. data, recursion, functional programming, types, implicit pointers, dynamic allocation, closures, macros, class precedence, and generic functions vs. message-passing. A complete guide to optimization. The clearest and most thorough explanation of macros in any introductory book. Examples that illustrate Lisp programming styles, including rapid prototyping, bottom-up programming, object-oriented programming, and embedded languages. An appendix on debugging, with examples of common errors.

Genres: Programming, Computer Science, Technology, Computers, Reference, Software, Nonfiction

Paperback

First published January 1, 1996

About the author

Paul Graham is an essayist, programmer, and programming language designer. In 1995 he developed with Robert Morris the first web-based application, Viaweb, which was acquired by Yahoo in 1998. In 2002 he described a simple statistical spam filter that inspired a new generation of filters. He's currently working on a new programming language called Arc, a new book on startups, and is one of the partners in Y Combinator.

Paul is the author of On Lisp (Prentice Hall, 1993), ANSI Common Lisp (Prentice Hall, 1995), and Hackers & Painters (O'Reilly, 2004). He has an AB from Cornell and a PhD in Computer Science from Harvard, and studied painting at RISD and the Accademia di Belle Arti in Florence.

Paulgraham.com got 10.6 million page views in 2008.

Reviews

[John Chilton · Rating 4 out of 5]

If you are going to read one book on Lisps or functional programming, it should be Structure and Interpretation of Computer Programs. If you are going to read a second book, you should reread SICP. When you are ready for a third book, this is a pretty good option. This is a better book than Programming Clojure or any of the various scheme books I have read, but it is perhaps too focused on the particulars of Common LISP and not about functional programming more broadly, so there might not be as much in this book for you if you are not programming Common LISP. I could not recommend Common LISP over Scheme or Clojure, so despite the fact this is a better book I would have to recommend The Seasoned Schemer, How to Design Programs, or Programming Clojure over this book for the typical developer.

[Marshall · Rating 4 out of 5]

This is what programming books should be like. It explains the Lisp language thoroughly but without fanfare. It is packed with information and several helpful examples. It's not dumbed down, but it's easy to follow. It was even able to make macros explicable, the first treatment of the subject that made sense to me. After reading this book, I felt like I had more than enough to start coding. It's also a fabulous reference, which is important as much of the power of Lisp is in its hundreds of built-in functions. Something that was missing in this book was some discussion of how to use 3rd-party libraries. In general, this book feels more theoretical than practical.

[Neal Aggarwal · Rating 5 out of 5]

This book is the intro to the language that I followed up with On LISP. Taken together the books are a treasure trove to me. I keep going through them again and again. My most recent reading at end 2013 brought up new insights AGAIN!

[Jeff Foster · Rating 4 out of 5]

Perhaps not as eye opening as On Lisp, but instils a sense that you are learning something amazing that's going to change the way you think. Worth it for that alone!

[Christoffer Ventus · Rating 3 out of 5]

This is an okay book describing the language and libraries of Common Lisp. It also shows how to utilize all this for some non-trivial cases to make the best use of the language possible.

But sometimes I got a bit distracted by Grahams's smug way of writing. But that's a recurring theme in Lisp texts as far as I've seen.

This book did not make me want to code in Lisp (SICP did a much better work at that).

[William Roe · Rating 5 out of 5]

I don't think I've read any book that's advanced my programming knowledge more than this little book.

[Didik · Rating 5 out of 5]

I learn a programming language accidentally
One day I was given a gift of a laptop from my brother
and I don't know what would I do with it
that in the end my friend give me a copy ansi common lisp
after so long I read with a capital of the brain below the average with my english is very bad, I am trying to understand it, though with much difficulty everywhere
but eventually, I was able to give a command in the terminal comand and REPL run in accordance with my wishes and that day I felt happy once.
although my experience was very funny and silly
please be understood me, I come from third world countries and very poor.
My purpose, learn common lisp is to help relieve and create a sense of ease among people with what I earn in the future.
because, in the world there are still many people who have problems with computing.

[Guru Devanla]

After getting a good handle on Clojure, I was curious what the original LISP provided that Clojure did not. I did a read this book with that question in mind. I am convinced Clojure picks on all the powerful features of LISP, but gets ahead of the standard lisps with its emphasis on immutability and focus on concurrent operations. Though, these aspects can be achieved with LISP, I am convinced Clojure just makes it transparent.

[Jonathan · Rating 4 out of 5]

A great book to introduce you to Common Lisp. It will get you started on the right footing, and it's worth noting where some of the style points are, because you'll most likely end up looking for those parts again.

[Tim · Rating 4 out of 5]

This book and Pete Seibel's Practical Common Lisp are way to common lisp. Perhaps now Stu Halloway's Programming Clojure should join these.

[Phil Eaton · Rating 4 out of 5]

Paul Graham and his editor(s) are excellent. His prose is light and easy to follow. The only awkward component of the book's organization is that he tends to use a concept one section before explicitly introducing and defining that concept. I'm not sure yet if this is a good or bad thing.

As a learning resource

Among books recommended to potential Lispers, ANSI Common Lisp is typically written off. Graham's style of Lisp is called "non-idiomatic". That's fair, both ANSI Common Lisp and On Lisp feature aspects of Common Lisp that lend themselves to functional programming. And as those of you who've read Practical Common Lisp know, Common Lisp (unlike Scheme) was not designed to be a functional programming language. Ultimately ANSI Common Lisp covers the same topics Practical Common Lisp does, if not more. But ANSI Common Lisp is better written, in less space, and with shorter examples.

I'm impressed at Graham's ability to summarize. There is a graphic illustrating symbols as a structure composed of a name, a value, a function, a package, and a property list. Although other resources (books and otherwise) mention symbols as having one or more of these components, his graphic was the first representation that clicked for me. He also provides clarity about packages being namespaces for names (symbols) not objects or functions.

And toward the end of the book, there is a discussion on the "instance" abstraction (relative to the class definitions themselves) being more powerful than plain "objects" that carry around methods themselves. This has been the single most useful discussion on the implementation of object-oriented constructs I've read yet.

Digression on Practical Common Lisp

Practical Common Lisp is often called the best introduction to Common Lisp. After reading both, I'd give Practical Common Lisp second place or call it a tie. The issue with Practical Common Lisp is that it takes too long to get anywhere and the practical chapters themselves are just as much a slog. And for as big as it is, Practical Common Lisp still doesn't include some major (potentially confusing) aspects of "modern" Common Lisp like ASDF, Quicklisp, production deployment strategies, etc.

Even after having read Practical Common Lisp I wasn't really clear how to pull together all the libraries I needed to get anything real done (e.g. scripting against an HTTP API or interacting with a SQL database). This is not to say that Practical Common Lisp is a bad book, it is a good book. But I definitely don't recommend reading it without also reading ANSI Common Lisp. And regardless, there are still a few of those modern concepts neither book covers.

[Antonio Ognio · Rating 3 out of 5]

Mandatory book on Common Lisp. Textbook for the "Programación No-Procedural" course at Universidad Peruana de Ciencias Aplicadas.

[Ryan · Rating 3 out of 5]

Common Lisp demonstrates how an elegant concept can snowball into an unmanageable mess. This book documents that mess well.

[Nick Black · Rating 4 out of 5]

a classic--my first book on functional programming, the textbook for GT's CS2360.