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.

O autor do livro "Practical Common Lisp" descreve com maestria as principais características da linguagem Common-Lisp e nos encoraja a repensar a programação tradicional.Esse livro é excelente!

Smart programmers are usually lisp programmers. This book is an excellent guide to learn lisp. Be sure to read through. Peter is an excellent author.

I have only just discovered that you can get used books from Amazon, so I went this way to get a spare copy of Seibel's Practical Common Lisp - - a volume that any Lisp programmer will want to own at least one of - - but I didn't want to pay full price so I went for a used one. When it turned up I was smack mouthed to find a hardback, and in spanking condition too. Blimey. Brilliant.

This is a good book to learn Common Lisp.Unfortunately, it's not a good book for someone who never program before. It more structure for adept programmers who want to learn an other language. I wouldn't say that you will master the common lisp after you read the book but you will have understand a lot of things.The chapters are progressive and you use concept that you learned in the previous chapters. The only thing that I don't like is that the examples are not easy for people who never programed in Lisp (or common lisp) for the reason that doing a specific way is not well explain.[...].

Das Buch gehört zu den sehr wenigen IT-Büchern, bei denen das Lesen Spaß macht.Auch wenn man selbst nicht mit Common Lisp arbeiten wird, öffnet das Buch ganz neue Perspektiven. Es ist schon erstaunlich, wie weit Common Lisp seiner Zeit voraus war und noch ist.Das Macro-System (nicht zu vergleichen mit dem C-Macros) erlaubt die Definition eigener Sprachen in Common Lisp - ein Ansatz, der heute als DSL (Domain Specific Language) bekannt ist und mit vergleichsweise wahnsinnig hohem Aufwand und Code-Generierung betrieben wird.So kann man eigentlich bei jedem Feature anderer Programmiersprachen sagen: "Das hat Common Lisp auch, nur mächtiger und flexibler."