Lisp, the second high-level programming language invented at the dawn of the computer age, has never been out of fashion, especially for artificial intelligence and other specialized areas. When the Lisp community recognized the benefits of an official language definition, the response was not one but two standards: Common Lisp and Scheme. Both are still in use, and each has a dedicated following. Of the two, Common Lisp has been more stable: it hasn’t changed at all for a long time. Once you know the language well, you can do pretty much anything you want with it, so changes to the language definition have not become essential. The language manages to keep current and vibrant through libraries written in Common Lisp.
Becoming an expert, though, may take considerable time and effort. The simplicity of the syntax can be deceiving, especially for programmers familiar with other languages: Lisp simply has a look and feel of its own, and Common Lisp, at heart a compromise among various Lisp dialects, is a big language with lots of features. It is not uncommon to have an “aha” experience, a point at which suddenly things become strikingly sensible and clear. And it is also not uncommon for Lisp to become a programmer’s favorite language.
Common Lisp recipes is for Lisp programmers who want to go beyond the novice or even the journeyman levels; if you want to become a Lisp expert, this book is for you. But you must first be comfortable with the basics. Unlike other books with the word “recipes” in their title, this book does not offer source code you could use with little or no modifications to accomplish specific tasks. The book has lots of recipes and Lisp code; each recipe is meant to explain and explore some feature of the language. Each recipe is explained in three sections: “Problem,” “Solution,” and “How It Works.” Of necessity, many recipes are grouped together to cover a given area in depth, and beyond that, tangentially related recipes are linked by extensive references throughout the book. Weitz also provides numerous external references, including details about various libraries and language implementations.
The best way to read this book would be to first review the table of contents (you can find it online at Amazon), and then to select a topic to begin reading. If you follow the links, you will soon find yourself going back and forth throughout the book. At some point, you may become interested in another topic, explore it at some length, and then go back to a previous topic. Quite likely, you will find yourself going back to a topic more than once, and gaining additional bits of understanding and insight each time.
The book contains 744 pages, 22 chapters, and an extensive index. But even summarizing the contents here would take too long. So I recommend that you look at them online to make a more accurate assessment of the book. I do want to mention this: the book covers some basics, the ones Weitz considers really important, such as what a cons is and how it is used in concert with other conses. Most of the book, however, deals with more advanced topics. These are the things every competent Lisp programmer should know really well: the Lisp reader, for example, and the difference between the reader and the read–eval–print loop (REPL).
The book can be accessed online, at a price or through an account, through Springer at http://link.springer.com/book/10.1007%2F978-1-4842-1176-2.
For someone like me, neither novice nor expert, this is an excellent resource. I recommend it.
More reviews about this item: Amazon