Reddit mentions of Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp

Thank you all for your responses! I have compiled a list of books mentioned by at least three different people below. Since some books have abbreviations (SICP) or colloquial names (Dragon Book), not to mention the occasional omission of a starting "a" or "the" this was done by hand and as a result it may contain errors.

edit: This list is now books mentioned by at least three people (was two) and contains posts up to icepack's.

edit: Updated with links to Amazon.com. These are not affiliate - Amazon was picked because they provide the most uniform way to compare books.

edit: Updated up to redline6561

• 14 The C Programming Language
  
• 11 Structure and Interpretation of Computer Programs
  
• 8 Introduction to Algorithms
  
• 7 Compilers: Principles, Techniques and Tools
  
• 6 Programming Erlang
  
• 5 The Mythical Man-Month
  
• 5 The Pragmatic Programmer
  
• 5 Applied Cryptography
  
• 4 Beautiful Code
  
• 4 The Little Schemer
  
• 4 Programming Perl
  
• 3 Types and Programming Languages
  
• 3 Gödel, Escher, Bach
  
• 3 OpenGL Programming Guide
  
• 3 Code Complete
  
• 3 Artificial Intelligence: A Modern Approach
  
• 3 Programming Pearls
  
• 3 ANSI Common Lisp
  
• 3 A Brief History of Time
  
• 3 Agile Web Development with Rails
  
• 3 Concrete Mathematics: A Foundation for Computer Science
  
• 3 Modern Operating Systems
  
• 3 Paradigms of Artificial Intelligence Programming
  
• 3 Operating System Design and Implementation
  
  

Some context, I've been living in this house for about 3 years now, my girlfriend and i moved in to take care of the owner of the house. Turns out that he was a big lisp / scheme hacker back in the 80s-90s and had developed a lot of cutting edge tech in his hay day. Anyway, these books have been hiding in his library downstairs...

It was like finding a bunch of hidden magical scrolls of lost knowledge :)

edit: I will compile a list of the books later. I'm out doing 4th of July things.

update: List of books

• Lisp: Style and Design by Molly M. Miller and Eric Benson
  ISBN: 1-55558-044-0
  
  
• Common Lisp The Language Second Edition by Guy L. Steele
  ISBN: 1-55558-042-4
  
  
• The Little LISPer Trade Edition by Daniel P. Friedman and Matthias Felleisen
  ISBN: 0-262-56038-0
  
  
• Common LISPcraft by Robert Wilensky
  ISBN: 0-393-95544-3
  
  
• Object-Oriented Programming in Common Lisp by Sonya E. Keene
  ISBN: 0-201-17589-4
  
  
• Structure and Interpretation of Computer Programs by Harold Abelson, Gerald Jay Sussman w/Julie Sussman
  ISBN: 0-07-000-422-6
  
  
• ANSI Common Lisp by Paul Graham
  ISBN: 0-13-370875-6
  
  
• Programming Paradigms in LISP by Rajeev Sangal
  ISBN: 0-07-054666-5
  
  
• The Art of the Metaobject Protocol by Gregor Kiczales, Jim des Rivieres, and Daniel G. Bobrow
  ISBN: 0-262-11158-6
  
  
• Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp by Peter Norvig
  ISBN: 1-55860-191-0
  
  
• Practical Common Lisp by Peter Seibel
  ISBN: 1-59059-239-5
  
  
• Common Lisp The Language by Guy L. Steele
  ISBN: 0-932376-41-X
  
  
• Anatomy of Lisp by John Allen
  ISBN: 0-07-001115-X
  
  
• Lisp Objects, and Symbolic Programming by Robert R. Kessler
  ISBN: 0-673-39773-4
  
  
• Performance and Evaluation of Lisp Systems by Richard P. Gabriel
  ISBN: 0-262-07093-6
  
  
• A Programmer's Guide to Common Lisp by Deborah G. Tatar
  ISBN: 0-932376-87-8
  
  
• Understanding CLOS The Common Lisp Object System by Jo A. Lawless and Molly M. Miller
  ISBN: 0-13-717232-X
  
  
• The Common Lisp Companion by Tim D. Koschmann
  ISBN: 0-417-50308-8
  
  
• Symbolic Computing with Lisp and Prolog by Robert A. Mueller and Rex L. Page
  ISBN: 0-471-60771-1
  
  
• Scheme and the Art of Programming by George Springer and Daniel P. Friedman
  ISBN: 0-262-19288-8
  
  
• Programming In Scheme by Michael Eisenberg
  ISBN: 0-262-55017-2
  
  
• The Schematics of Computation by Vincent S. Manis and James J. Little
  ISBN: 0-13-834284-9
  
  
• The Joy of Clojure by Michael Fogus and Chris Houser
  ISBN: 1-935182-64-1
  
  
• Clojure For The Brave and True by Daniel Higginbotham
  ISBN: 978-1-59327-591-4
  
  
  
  

> I don't think you've actually used any of the modern Lisps.

Not true. You'll find my name in the acknowledgements of Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp. My "Road to Lisp Survey" page is here.

> Common Lisp has CLOS (a ridiculously powerful object system)...

That's a definite plus for Common Lisp, IMHO.

> most Schemes have their own object systems.

Yes, but they aren't standard.

> In addition, there is no Lisp that ships without stuff like hash tables, arrays, structs, etc.

On the contrary; most Schemes ship without them.

> The reason textbooks build this basic stuff from scratch is because they need to demonstrate how you can build complex systems using simple abstractions.

In the cases I'm referring to, that's not the reason at all. The reason is they want to be able to manipulate abstract syntax trees in the obvious way: as sum types. So they simulate the minimum functionality of sum types they need. There's nothing wrong with that per se; it's just unnecessary in languages that already support sum types (and much, much more). Granted, the authors may be well aware of this and chose to use Lisp in their texts so as not to have to explain sum types in a text that's supposed to be about implementing programming languages rather than using one to do so, but it's not obvious that that's a win; see Modern Compiler Implementation in ML for a counterexample.

> If you want to use Lisp for actual production work, I suggest you ditch SICP and pick up something like Practical Common Lisp. If you want to stick with Scheme, the Racket documentation should be more than adequate.

Practical Common Lisp is indeed brilliant. Racket is a wonderful Scheme (and much, much more) implementation. But I've long since moved beyond Lisp.

> Also, obligatory QuickLisp mention. It'll change your life.

For folks who haven't yet tried Common Lisp and want to get going in a hurry, that's absolutely correct.

Some CL-specific resources:

• The book Land of Lisp has some sections specifically on functional programming, and answers some of these questions. It goes into more detail on the philosophy and spirit of separating effects and organizing code, albeit for a limited example. Chapter 14 introduces it (in the context of CL), then implements the core of the game Dice of Doom in a functional style in chapter 15.
  
  
• On Lisp discusses programming in the functional style early on in Ch2/3, (with an emphasis on bottom-up programming). I think Graham uses a functional style more-or-less throughout, except for performance optimizations or where the imperative imperative implementation is actually more desirable for clarity.
  
  
• Peter Norvig similarly leverages a bit of a functional style throughout PAIP, and he has several remarks about leveraging higher order functions, recursion, and small, composeable functions throughout the text. FP isn't the focus, but it's discussed and present.
  
  
• Practical Common Lisp has some brief mentions and examples in chapters 5 and 12.
  
  Non-CL:
  
  
• SICP starts off with functional programming from the start. Although it's scheme, the ideas are similarly portable to CL. It's an excellent resource in general, regardless of language interest IMO.
  
  
• There's a chapter in the free Clojure For the Brave and True that more-or-less covers the bases and builds a small game functionally. Due to its prevalence, you pretty much find articles/blogs/chapters on FP in every clojure resource. I found the ideas generally portable when revisiting CL (absent reliance on persistent structures with better performance profiles than lists and balanced binary trees).
  
  
• Joy of Clojure Ch7 specifically focuses on a FP concepts and applies them to implement a functional version of A* search. They run through simple functions, function composition, partial function application, functions as data, higher order functions, pure functions / referential transparency, closures, recursive thinking, combining recursion with laziness, tail calls, trampolines, and continuation passing style.
  
  Others:
  
  
• http://learnyouahaskell.com/chapters
  
  I flip back and forth between Clojure and CL periodically (CL is for hobbies, clojure is for work and hobbies), and have mucked with scheme and racket a bit (as well as decent mileage in F#, Haskell, and a little Ocaml from the static typed family). IME, you can definitely tell the difference between a language with support for FP strapped on after the fact, vs. one with it as a core design (preferably with mutable/imperative escape hatches). CL supports FP (closures/functions are values (e.g. lambda), there's a built-in library of non-destructive pure functions that typically operate on lists - or the non-extensible sequence class, and non-standard but general support for optimizing tail recursive functions into iterative ones enables pervasive use of recursion in lieu of iteration), but I think it's less of a default in the wild (not as unfriendly as Python is to FP though). Consequently, it's one paradigm of many that show up; I think there's likely as much if not more imperative/CLOS OOP stuff out there though. I think the alternate tact in clojure, scheme, and racket is to push FP as the default and optimize the language for that as the base case - with pragmatic alternative paradigm support based on the user's desire. Clojure takes it a step farther by introducing efficient functional data structures (based on HAMTs primarily, with less-used balanced binary trees for sorted maps and sets) so you can push significantly farther without dropping down to mutable/imperative stuff for performance reasons (as opposed to living and dying by the performance profiles of balanced binary trees for everything). You'll still find OOP and imperative support, replete with mutation and effects, but it's something to opt into.
  
  In the context of other FP langs, F# and Ocaml do this as well - they provide a pretty rigorous locked-down immutable approach with functional purity as the default, but they admit low-hanging means to bypass the purity should the programmer need to. Haskell kinda goes there but it's a bit more involved to tap into the mutable "escape hatches" by design.
  
  In the end, you can pretty much bring FP concepts into most any languages (e.g. write in a functional style), although it's harder to do so in languages that don't have functions/closures as a first class concept (to include passing them as values). Many functional languages have similar libraries and idioms for messing with persistent lists or lazy sequences as a basic idiom; that's good news since all those ideas and idioms or more or less portable directly to CL (and as mentioned here are likely extant libraries to try to bring these around in addition to the standard map,filter, reduce built-ins). For more focused FP examples and thinking, clojure, racket, and scheme are good bets (absent an unknown resource that exclusively focuses on FP in CL, which would seem ideal for your original query). I think dipping into the statically typed languages would also be edifying, since there are plenty of books and resources in that realm.

Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp by Norvig (PAIP)

I don't want to overhype, but it's been called "The best book on programming ever written".

Oops, maybe I overshot. But anyway, very enlightening even if you're not a Lisp or AI programmer.

The problem with ANSI CL is that I could never shake the feeling that Graham wants Lisp in general to maintain some mystique as language only suited for the very clever, and he teaches the language with intent on keeping it that way. I really enjoyed PCL, but I really do think that Paradigms of Artificial Intelligence Programming needs to get more attention. Granted that I haven't yet finished the mammoth volume, Norvig introduces the language in a clear way that makes it seem more natural (perfect example is that he prefers 'first' and 'rest' rather than the more esoteric 'car' 'cdr'), but additionally he has great 'hand holding' examples that show exactly what makes Common Lisp so powerful and how to organize largers programs in language as well as going over a ton of interesting CS related things. Having gone through these 3 books while I was learn I can definitely say that each had a lot to offer, but I think if I was trapped on an island with just one I would definitley take PAIP.

Paradigms of Artificial Intelligence Programming

My recommendations for books:

• Automated Planning - Theory and Practice, one of the recommended texts for AI Planning course at Coursera.
  
• Paradigms of Artificial Intelligence Programming: : Case Studies in Common LISP

Common Lisp remains a touchstone. I highly recommend installing Clozure Common Lisp and Quicklisp and then working through Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp and Artificial Intelligence: A Modern Approach with them. Although I'm now firmly in the statically-typed functional programming world, this has been part of my journey, and it will change how you think about programming.

The code was taken from here, which seems to be from this book originally. It doesn't look too interesting, but it does seem to be taken wholesale from the aforementioned repository.

There's definitely a steep learning curve to get to the mindset of being productive with it. I really enjoy Norvig's "Case Studies" book. I feel like you're right in some ways though... LISP is supposed to be able to be extended even in a language sense but it is just not that intuitive to do it. I have heard interesting things about Perl 6 in this regard but I haven't had time to play with that yet... maybe when i finally completely finish school :)

https://www.amazon.com/Paradigms-Artificial-Intelligence-Programming-Studies/dp/1558601910