Practical Common Lisp

This shouldn't be your first Lisp book or your first programming book. There is just too much in here to comprehend all at once for the beginner. To learn from this book you would be well off to have learned Python, Pascal, ALGOL or some other language that includes passing procedures as argumenst to functions. You also should be familiar with SQL, stacks, pointers, objects, files, recursion, linked lists and trees. After that, you should also learn a little Lisp. Only then is this a great book. If you have that background you will find Practical Common Lisp a joy to read. Take just the first meaningful chapter, Chapter 3, Practical - A Simple Database. This is just the first example where Mr. Seibel shines as a teacher. The chapter begins simply enough by showing how lists are a nice organizational tool. He uses abstractions which the experienced programer knows would allow moving from lists in a small database to a relational database for data storage. He takes the reader from data, to easier data entry functions, to database queries and onwards. Here it gets fun. He shows how lisps flexible function argument specificaton is well suited for an elegant implementation of selecting records (like an SQL WHERE clause in a SELECT), and then moves right into macros in Lisp. What Seibel has done in that chapter is to gracefully move from a simple list through sophisticated function design and end up demonstrating macros in a single chapter. Also, it is not just toy code doing one thing, but several functions working on a database or functions that are utility functions in accessing a database. As a programmer Lisp now impresses. Those little single function examples that show how nice Lisp is don't capture the fun it is to program in Lisp. Any decent programmer can implement a single purpose Lisp function in their language of choice. What Lisp has going for it is flexible calling conventions in functions and built in data structures that effortlessly allow pointer manipulation programming without all the tedious futzing around with pointer manipulation. This all gets back to why you want to have some programming experience initially. Lisp data structures are all pointer based. However, you don't see the pointers. You see lists and variables. If you are a programmer you know the benefits of working with pointers, but you have to spend time manipulationg those pointers to use your data structures. In Lisp, you just have data structures and Lisp handles all the pointer issues. Very slick. Seibel talks about developing some code to handle a data store in Chapter 3 and references ideas from SQL and mentions data and procedural abstractions. If you know those things it makes sense what Seible is doing in this little chapter. If this were your first programming book all of those issues would be unknown and you'd be lost in why Seibel was doing things the way he was. I've been programming for years, so I hadn't picked up any of the enlightenment the Lisp supposedly brings. I have to express that this early chapter brought about my first enlightenment about programming. In functions in other languages a missing argment to a function would be an error. However, a missing argument alternatively could meansomething is unimportant. In lisp a missing argument enters a function as a logical false. The aha moment for me was recognizing that one way to use arguments that are missing is to change the internal processing in a function. The very elegant example that Seibel provides is where he defines a functiokn WHERE that uses missing values to generate don't care states in a complex test of a data structure. He does this sweetly on a simple list with keyword properties. He dosen't explicitly tell you what he just did. That is the marvelous part of his exposition. Everything comes out as "of course," but as a programmer the design clarity is inspiring and you see how Lisp supports the clear expression of design. This is why this is a good book on Lisp, it both teaches Lisp and educates the student on the benefit of Lisp. The chapters include code that builds on other code in the book. This gets away from the single function examples that show how to do stuff in Lisp, but don't really educate about Lisp. Learning some lisp first will get you past the usual first horror about Lisp. As an aside, Lisp is realy just a bunch of function calls. rather than the typical f(x) notation in most programs, Lisp uses (f x). It's just a different postion of the left parenthesis. Additionally, learning some lisp will teach you the basics of functions, mapping functions, and get you familiar with accessing the function pointer and value associated with symbols. Seibel has chapters on these topics, but they are short, too short for the student to really gain an understanding needed to appreciate and learn to program in Lisp. If I retitled the book I'd name it "Expressing yourself in Lisp". Another reason to learn some lisp is because the code examples from the book are available for download and are is ASDF format. If you know some lisp you;ll appreciate that the code is thus available. Well, that was a roundbout review. As you can see, my reommendation for this as a second book about Lisp was not meant to disparage the work. Instead I think this is a superb book that will take you from just having a basic knowledge about lisp to bring you to intermediate to advanced skills. So, should you buy it? After all, the whole book is available online free for the download. Honestly, I have been reading the book and have the PDF on my iPad. I bought it for several reasons. This book exists because a publisher paid the author for the work. Authors want to make money, and I want other authors to want to write books. Seibel gets a cut of the purchase and I've learned enough from this I want to pay him. I get a hardbound copy, which reads better and is easier to flip from secton to section in. I've mentioned that this should not be the first book and you should lear some lisp. To learn lisp go to this site: https://stevelosh.com/blog/2018/08/a-road-to-common-lisp/#s9-a-road-to-learning-common-lisp and follow the recommendations. He recommends the book "Common Lisp: A Gentle Introduction to Symbolic Computation". The next book recomended is this book, Practical Common Lisp. The website A road to learning ... is an excellent guide. After all, there is more to learn about Lisp than is in Practical common Lisp. That website is a good guide.

First, these are my credentials as a reviewer. I have read this entire book (some parts more than once). I have completed modestly large freelance projects using php, actionscript, python and c. I do not have a formal background in computer science (I have a degree in Art). I learn by practice and by reading books. 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.

To an outsider, LISP seems like a slow, ugly, language for doing AI. Turns out, it's nothing of the sort -- it's perhaps one of the most advanced and feature laden languages out there having capabilities well beyond things you find in other languages, allowing you to do what seems impossible. 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.

After reading a couple of chapters on the free online edition, I decided to buy the book. I am new to Lisp. Given the complexity of some concepts, the author describes them clearly. The examples are interesting. Got a little dry near the end. I think I am spoiled by more entertaining and "childish" programming books, such as the Head First series.

This book has everything a beginner Common Lisp programmer is looking for: It gives detailed analysis about many commonly used features of the language, shows a different way of thinking about some trivial programs, has plenty of examples varying in size and shows the beginner that Common Lisp can be just as efficient and "practical" as any other 'popular' language. It's not bad for the intermediate or advanced lisp hacker either; it might not show you anything you don't know, but it will give some great examples that you might have not even thought about trying to develop. My only grievance with this book is that the language the author uses can, at times, be a little advanced. If you had no prior programming experience this might take some getting used to. I suggest going through the book in order and you'll be very ready to go over the many examples at the end and maybe even try to edit them into your own creation!

I graduate college with an Electrical Engineering Degree, but took many Computer Science classes. I went into software, instead of hardware, as a career choice. I have used Perl, Java, C, VB 3-6, C# and other languages in my day to day job over 8 years. My only experience with LISP is hearing about it, while in college, and possibly the use of EMACS when doing Unix systems programming in C. While trying to locate good beginning courses for a co-worker, I came across MIT's online 6.001 class, using LISP. This rekindled my interest in learning LISP. The book for this course really didn't answer the "why should I learn LISP?" question. This book does. After intending to purchase the textbook for that course here at Amazon and actually ordering it, I found this book. I wound up ordering this book and canceling the other (since it was online). If you are very low on funds, you can also find the text of this book online. I prefer a hard copy of the book for easier reference. This book takes me through not just learning LISP, but why certain features are unique and/or important. It is truly a great book for learning LISP.

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.

This book is the symmetrical other half to the general collection of Common Lisp literature. You've read about the mathematical foundations and the language syntax, now put it all together. From the very start, Seibel stays true to the 'practical' in the title: you write a quick, simple, yet robust and illuminating music cd database implementation. This database features immediate explanation of the 'format' call, not the usual simplistic "print vs. prin1," and even includes the functionality of saving and loading the database from file. Do yourself a favor and buy this book, it really is that good. Best of luck