- Series: Books for Professionals by Professionals
- Hardcover: 500 pages
- Publisher: Apress; 1st Corrected ed., Corr. 4th printing edition (April 11, 2005)
- Language: English
- ISBN-10: 1590592395
- ISBN-13: 978-1590592397
- Product Dimensions: 7 x 1.1 x 10 inches
- Shipping Weight: 2.4 pounds (View shipping rates and policies)
- Average Customer Review: 81 customer reviews
- Amazon Best Sellers Rank: #157,842 in Books (See Top 100 in Books)
To get the free app, enter your mobile phone number.
Practical Common Lisp 1st Corrected ed., Corr. 4th printing Edition
Use the Amazon App to scan ISBNs and compare prices.
Frequently bought together
Customers who bought this item also bought
About the Author
Peter Seibel is a serious developer of long standing. In the early days of the Web, he hacked Perl for Mother Jones and Organic Online. He participated in the Java revolution as an early employee at WebLogic which, after its acquisition by BEA, became the cornerstone of the latter's rapid growth in the J2EE sphere. He has also taught Java programming at UC Berkeley Extension. He is the author of Practical Common LISP from Apress.
Top customer reviews
Perhaps a crud way of describing is that you know how a high-level language complies into an abstract syntax tree of some intermediate representation which then is converted into low-level code for actual execution? LISP has a phase in the middle of that, where not only can you manipulate the intermediate representation, but you can alter the grammar of the reader itself and construct your own language that's designed for your given application. It's code that generates and manipulates code -- not a transpiler, not a text-preprocessor, not a different way of looking at functions.
Practical Common Lisp does a *beautiful* job of explaining the concepts, the language, and the practical bits and pieces you need to know to get what's happening well beyond syntax. It's side discussions and footnotes are pure gold and themselves are worth the cost of admission. The book goes deep into the libraries, the differences between environments, and covers many gotchas.
The book actually changes the way you think about programming, even if you've done it for years. It's that good.
This is a great introduction to Common Lisp. Thankfully it doesn't get to the stuff I learned in my Lisp manual 40 years ago, CAR, CDR and similarly arcane functions until 1/4 of the way in to the book. Much of the insight in to the unique power of Lisp was lost in the orignal books while mucking around in list structures.
The light bulb starts to click on what a powerful language Common Lisp is in Chapter 5 about functions, and clicks on brighter in Chapter 7 on macros (despite my deep-seated reservations about macros as a long-time professional c/c++ programmer), and many chapters after that illuminate the power, flexibility, expressiveness and conciseness.
I have one small complaint. In my paper copy (yes I am a bit old skul and do better reading from ink on dead trees, but at least in my case the book will do an outstanding job of carbon sequestration since I don't burn books, nor do most others), the print is slighly faint and fuzzy, and varies some from page to page. I was reading without my glasses one night and saw the reason. The font is slightly fuzzy with dots on narrow parts of letters and alternating dark/light areas on thicker parts. This likely saves a fair amount of ink in printing, but it detracts from the appearance and readability of a very fine book.
One surprising thing missing from the book is any discussion of the art of debugging lisp. There is a discussion of handling error conditions and exceptions, but that is not debugging. There are some good links online (search Google for Common Lisp debugging), but given how different debugging Lisp is compared to other languages, where most readers will come from, a chapter on that would have put the final icing on an outstanding book.
Thinking of this book, here's what comes to mind, -one of the most enjoyable learning experiences I have had. It communicates itself with effectiveness, originality and a careful attention to detail.
When I first began using this book, I was skeptical of it. Chapter 3 introduces Common Lisp with a 'Practical', a step-by-step build-up of a small Lisp program. The next few chapters explain syntax, functions, variables and macros.
I was skeptical because, at the time, I understood little of Chapter 3 and it seemed to me that the following chapters (syntax, functions, variables, etc.) should have preceded Chapter 3. There are no end-of-chapter directives and only the 'Practical' chapters include significant tasks for cementing concepts. What does it mean?
It becomes evident that this organization is a good thing. It forces the reader to engage the book with a fresh approach. After reading a few chapters following Chapter 3, a necessary re-read of Chapter 3 yields great understanding. It sets the reader into a rhythm of reading... reading some parts once for creative enjoyment and once again for critical comprehension.
This is an important aspect of this book and my appreciation of it. The author does not try to anticipate and satisfy the expectations of the reader (a linear presentation of mixed code/explanation). Instead, like an artist, the author presents his method and changes the reader's perspectives to match his own.
The organization also adds something to the long-term usability of the book. Mini-programs and behavior test-cases are mostly reserved for the 'Practical' chapters. The other chapters are not cluttered with these things and are devoted to single topics. 'For example there is a chapter devoted to numbers. Another chapter is about the 'format' function, Common Lisp's equivalent of printf. The material in these chapters is patiently and thoroughly presented.
This is one of my favorite books. After reading it I was able to write a Common Lisp program that uses classes, packages and macros.
Most recent customer reviews
And there is a webpage version of this book: [...], good for later reference