Customer Reviews

Practical Common Lisp

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

 

 

I've been recommending this text to people who want to start learning Common Lisp since it was first available in draft form on the author's web site. Now that it's out in print I can enthusiastically recommend that anybody who is interested in learning Common Lisp - or even curious about how the language can improve your productivity - purchase it.

Peter has a very enjoyable and easy-to-understand writing style, and he starts early with practical examples that show how Common Lisp can be used to solved problems. Chapter 3, "A Simple Database", is a great explanation of how programs are grown from pieces in Common Lisp to solve large problems. It's presented early and draws people in to the problem solving techniques used when programming in Lisp.

Peter doesn't skimp on details, though: detailed chapters on FORMAT (for formatted output), LOOP (for general iteration / value collection), and CLOS (the Common Lisp Object System) provide a wonderful tutorial to these powerful but complex features.

The book ends with a long string of practical examples that synthesize multiple concepts into programs that are useful and show exactly why programming in Lisp is so cool. The last practical example, which builds a HTML generation library in Lisp, gives the reader a taste of why writing a Domain-Specific Language is so easy in Lisp and why it can integrate so well with the rest of the language.

Peter is very enthusiastic about Common Lisp and it shows in his writing. Unlike other authors (Paul Graham comes to mind) he gives every major feature of the language its due and shows how and where it should be used.

Practical Common Lisp may be one of the most fun books on programming you'll read all year. Even if you're just curious, check it out. It may change the way you program.

Practical Common Lisp is a solid introductory text to Common Lisp for people with previous programming experience, and is sufficiently no-nonsense that even relatively experienced lisp programmers will benefit from it.

Having been exposed to people with no lisp experience who have started learning it from this book, most seem to manage well. Common problems stem from jumping too far ahead: unlike many books who claim to do so, PCL actually has a very nice didactic approach to most things, and benefits from being read in order.

I have very few grivances with the book:

1. I believe that package and symbol semantics could benefit from a thorough treatment earlier in the book -- say around chapter 6, as opposed to being left for chapter 22.

2. While Seibel's style is refreshingly idiomatic[1], he consistently uses Javaesque dotted.package.names, which while not by any means unique to him I still find irritating. Most of the package names in the book are prefixed with com.gigamonkeys, whereas the more traditional approach would be to leave the prefix out totally, or make it com-gigamonkeys.

3. Optimizing lisp code is admittedly a tough topic to deal with, especially when aspiring to give portable advice. The treament given is nonetheless too cursory for my liking. Norvig's advice in "Paradigms of Artificial Intelligence Programming" is far superior, but could still have been improved upon.

These nits aside, I must say that this is definitely a book I wish I'd had when I was learning CL. Recommended to anyone interested in learning Common Lisp.

[1] Some well-known authors of Common Lisp textbooks *cough* Graham *cough* have unfotunately quirky personal styles of writing code that do not mesh that well with what many consider idiomatic lisp. In comparison to this Mr. Seibel's style is clear and provides a good model to emulate.

Peter Seibel's writing style is a joy to read, and (unlike other commenters) I find his footnotes quite useful. Concepts are introduced in a natural and general intuitive ordering, and in general this is a great book for the first-time learner of Lisp.

Now -- WATCH OUT FOR THE INDEX! My first indication that the index of this book was not up to par was an especially useful footnote on page 58 mentioning READ-FROM-STRING, which I couldn't find later when I needed to use READ-FROM-STRING in the small Lisp program I'm writing. A little experimentation convinced me that nothing in the footnotes is listed in the index, and I started reading with a pencil in my hand.

Unfortunately, the index fails in more fundamental ways as well. It would have you believe that the "do" keyword is introduced on page 278, when in fact an entire subsection is devoted to "do" in pages 85-87. If you look up "comment" you'll find no mention of page 49, where comment conventions for block comments, line comments and so forth are described in concise and useful detail. The long list of special characters that stars the alphabet is inexplicably lacking some of the most common operators and directives, such as #', ,@ , ,@ and #. In fact, the only thing the index seems consistently to get right are words that appear in all capital letters in the body of the text.

It slows my reading considerably to constantly be adding pencilled entries to the index, but since it will probably save hours of irritated searching for information in the future, I'm persisting. Let's all hope this glaring flaw is corrected soon in a second edition. In the meantime, there's always the option of searching the full text, which is online on the gigamonkeys site, every time you would normally flip to the index.

Lisp has a lot of things to teach us, and it's a very practical tool in its own right. It has all the features you're used to in other languages, usually done very well. There are plenty of good reasons to look seriously at Lisp, and Practical Common Lisp is the best introductory Lisp book out there.

The things that most people don't see when they study Lisp are the interactive development style, macros, and practical applications. Peter Seibel gets you started off properly right from the start, walking you through picking a high-quality Lisp implementation and IDE, and then teaching you how to use it. This is one of the biggest things about Lisp: your program is running as you write it. You write and debug programs incrementally, and it feels good. After getting you started on the basics of using Lisp, Seibel plunges right into writing a simple CD database, with fast compiled queries that look almost like SQL in Lisp.

After you learn more of the basics, Practical Common Lisp goes into the next big neglected topic in Lisp: macros. Ever practical, Seibel uses macros as part of a very pleasant unit testing framework that only takes up 26 lines of code, all of it easy to understand. Macros are a powerful tool, but easy to abuse. This book doesn't abuse them, and that rubs off on you.

The next few chapters cover, clearly and completely, topics dear to the heart of every programmer: high-level data structures, file I/O, object-oriented programming, string processing, complex looping constructs, exceptionally powerful exception handling, and more. I use this book as a friendly reference; whenever I forget how to use something, I look it up here.

From then on, the book is all practical examples. A spam filter, an object-oriented binary file parsing framework, an application of that binary file parsing framework to get ID3 information from MP3 files, and a lot of web programming.

Practical Common Lisp is already the book universally recommended by the Lisp community for learning Lisp the right way. Read it, and you'll never program the same way again.

This book is a fantastic introduction to Common Lisp. Too many Lisp books you'll find are either a) incomplete (i.e. little to no discussion of macros or CLOS, two of the most powerful features of Lisp), or b) are written before 1990. Not so with Practical Common Lisp. The book opens up with an introduction to the language itself and then surveys major features of the language before going through a series of practical examples.

The book really shines in its treatment of macros. Before reading PCL, I'd had a rough idea of what macros were and why they were cool, but no idea how to write them. Peter Seibel manages to explain in two chapters what took Paul Graham most of a book (On Lisp) to discuss.

One of the later chapters describes Common Lisp's condition/restart system, which I had never heard of until reading this book. If you are unfamiliar with the condition/restart system, picture the try-throw-catch construct found in other languages, only with the ability to jump back to where the error was thrown and take a different code path. It is incredible that this system gets so little mention outside this book.

The practicals it includes are also very cool. Seibel builds a simple test suite in one of the early chapters that is amazingly featureful yet incredibly concise. He builds an astonishingly small in-memory database in one of the earlier chapters with pretty advanced features. Two practicals toward the end involve building an HTML generation system and then using macros to optimize the generation.

He includes a brief discussion of efficiency as well, describing how bottleneck functions can be tweaked for maximum efficiency and introduces some of the techinques that can bring Common Lisp applications to C-like efficiency.

I highly recommend this book to anyone looking to learn Common Lisp, or even just someone looking to see what all the hype is about. It provides a great survey of the language, lots of useful practicals, and is pretty handy as a reference as well.

Buy this book!

There have been any number of excellent books written on Lisp and its sister, Scheme. "The Little Lisper" and "Structure and Interpretation of Computer Programs" are two that come to mind. What most of them have in common is an emphasis on applying the powerful semantic features of Lisp to fundamental questions in computer science.

This book does show that side of Lisp. However, its most important feature is in showing an underexposed side of common Lisp - that of a potent and underutilized tool for real world programming applications.

File operations, XML and HTML output and web services are all covered. Constructs like the loop macro and package system are given extensive treatment. These were essential tools in the days when Lisp Machines roamed the earth. The unique power of the "defmacro" user defined macro facility is shown to good advantage.

I am giving the author five stars for a comprehensive *practical* treatment. This book demonstrates that Lisp is as capable as the current breed of "dynamic" languages for application programming - while possessing unique functional powers that have yet to be equaled.

Leaving aside the practicality of learning Lisp, this book is really amazing. I've read a couple of books on Lisp and never really gotten it until now. Generally they present some abstract math concepts, show how they work in Lisp and leave it there. This book takes it to the next level, the practical level, as you see in the title.

Macros, slots, object orientation, data structures, and more, are all discussed in detail without 'leaving it to the reader' as the other books do.

Finally! A good book on Lisp.

I don't remember how many times I have referred to that book when I gave advice to my fellow programmers. Long before the book came out I was reading its drafts online and admiring (and of course telling people to go and get some fresh ideas). Now, forget about your prejudices, fasten your seatbelts and get ready for a tour of Common Lisp applications for Internet, database, streaming server, etc. programming.

This is not the Lisp you may have seen in your typical class, here we are talking about real world applications: handling HTML, creating mini languages for Internet, creating an mp3 streaming server, building an SQL like language from scratch and learning the power of Lisp.

The author has also extensive Java experience and can provide great insights and comprasisons. In addition to that he is an active participant in various newsgroups related to Lisp, Java, Perl, etc.

This great book would be better if exercises were included at the end of the chapters but for that I prefer ANSI Common Lisp from Paul Graham and PAIP from Peter Norvig. If you have a %90 understanding of these three titles you'll be much more than an average programmer with a deep and broad vision.

What can I say that others haven't said about Peter Seibel's new Practical Common Lisp?

It is now the best written introduction-to-intermediate Common Lisp book you can buy. It's great reading, the practical focus of the examples are well chosen and meaningful, and he jumps right in with the power of Lisp, instead of doing the pedagogically boring "this is a list" and "this is cons, car, and cdr".

I especially like the domain-specific language approach the book uses. In particular, Chapter 24 - Practical: Parsing Binary Files, and the later chapters are excellent examples of what you can really do with macros. In fact, I think Chapter 24 is standalone to point that, with some warning, you could show it to someone interested in the kind of power you get with macros, but doesn't want to wade through the whole book to get to the punchline. That person wouldn't understand a lot of the code, but would certainly see the ability of creating macros that can write a significant amount of straightforward boilerplate code.

If you have any amount of interest in learning about Common Lisp, this is the book you'll want. It will be like stepping into much larger world. You won't regret it.

The only lisp I ever knew was scheme and I'd long meant to dig into Common Lisp, so I finally got around to it. I am not sorry that this book was my introduction. Let me start off by saying that there are two kind of people in the world - the kind that like to read a tech book straight through and then start doing and the kind of people that like to do while reading the book (ok, so maybe there's a few more kinds of people...). I am of the first sort and the organization of this book was perfect - I don't know that I've read a book better suited to the way I like to learn a language. It is targetted to an experienced programmer, but one w/out any experience in LISP. I think it'd be a tough book for a complete newcomer to programming to start working with.

The book is divided into 2 sections, the first (slightly more than half) is the language reference and the second is the practical part. The language part was the perfect model for me, it works you from basic to advanced. Beginning from the very beginning it gives you suggestions on the environment in which to work with LISP and where and what would be good to install. It moves to through all the basics, syntax, functions, variables then spends a little bit of time on macros (a very key and subtle feature), moves onto numbers and strings, collections and lists (spends some time really covering these to give a true understanding), and then pushes on to I/O, OO in LISP and then a good look at FORMAT, exception handling and loops.

These were not cursory overviews of language features, but were in depth coverage. As such, it is inevitable that in trying to show you how things work they need to use some more advanced constructs that they have not yet covered. They, however, tell you that you don't know about this feature yet and explain just enough about what it's doing that it's no impediment to understanding the example. They are very thorough and concious when this happens. The alternative, confining yourself to only what you've covered traps many writers into showing only trivial examples that are unable fully display particular concepts.

There are a couple practical examples in this first section that demonstrate ideas covered up to that point. The examples themselves are excellent, showing how programs are built up and refactored. It is a really clear view of the expressiveness that LISP allows.

The second half of the book is dedicated to putting things together in a diverse set of projects. The first, kind of standalone is the Spam Filter. The rest are parts of the elements needed to create a streaming music library from parsing binary files, extended to reading ID3 tags of mp3's, to working with AllegroServe (a lisp web server), you build a database of music, learn how to build a shoutcast server and tie it all together with an online mp3 browser.

There's a good amount of coverage on working with the web, generating html and the like. These practical topics are not the lightweight fairly trivial examples that you most often see in books, these are in depth and very diverse examples of what you can do with LISP. To me this is the advantage the book gets by its organization, by first letting you learn all the basics of the language, they can show you how a real program is developed using the full expressiveness of LISP.

I gave this book five stars because of the great way it was organized, the in depth coverage of it's features and it's friendly and readable writing style. It did have some flaws, sometimes it didn't give examples on some topics that might have been more easily explained through a little show and tell, a couple minor typos caused a little bit of confusion. But these are minor nits that don't detract from the overall goodness of the book. If you are interested in learning LISP, I can whole heartedly recommend this book.