Successful Lisp

What Hacker News says

1. JachAug 2025
   One source of awe people have with the idea of Lisp is how much you can build off of so little. I like pg's Roots of Lisp paper on that https://justine.lol/sectorlisp/jmc.pdf The core thing was the meta-circular evaluator (eval) in the original Lisp paper. You can work through it or try re-implementing it in something else. I like this recent tiny version https://justine.lol/sectorlisp2/

   Another source of awe is about Lisp being more of a programming system than a language, and Common Lisp was the standardization of a lot of efforts towards that by companies making large and industrial pieces of software like operating systems, word processors, and 3D graphics editors. At the language level, "compile", "compile-file", "disassemble", "trace", "break", "step" are all functions or macros available at runtime. When errors happen, if there's not an explicit handler for it (like an exception handler) then the default behavior isn't to crash but to trigger the built-in debugger. And the stack isn't unwound yet, you can inspect the local variables at every layer. (There's very good introspection in general for everything.) Various restarts will be offered at different parts of the stack -- for example, a value was unknown, so enter it now and continue. Or you can recompile your erroneous function and restart execution at one of the stack frames with the original arguments to try again. Or you can apt-get install some foreign dependency and try reloading it without having to redo any of the effort the program had already made along the way.

   Again, all part of the language at runtime, not a suite of separate tools. Implementations may offer things beyond this too, like SBCL's code coverage or profiling features. All the features of the language are designed with this interactivity and redefinability in mind though -- if you redefine a class definition, existing objects will be updated, but you can control that more finely if you need to by first making a new update-instance-for-redefined-class method. (Methods aren't owned by classes, unlike other OOP languages, which I think eliminates a lot of the OOP design problems associated with those other languages.)

   I like the book Successful Lisp as a tour of Common Lisp, it's got a suggested reading order in ch 2 for different skill levels: https://dept-info.labri.fr/~strandh/Teaching/MTP/Common/Davi... It's dated in parts as far as tooling goes but if you're mostly interested in reading about some bits rather than actively getting into programming with Lisp that's not so bad. If you do want to get into it, https://lispcookbook.github.io/cl-cookbook/ has some resources on getting started with a Lisp implementation and text editor (doesn't have to be emacs).

   Show morethread
2. eimrineSep 2022
   Successful Lisp David B. Lamkins
   thread
3. vindarelOct 2018
   In [Successful Lisp, how to understand and use CL](http://www.communitypicks.com/r/lisp/s/17592186045679-succes...) there is a chapter on debugging. Book's site, free dl: https://successful-lisp.blogspot.com

   Also, it may not be necessary to master the most complicated machinery: compiling function by function gives lots of hints, and the very nice [log4cl](https://github.com/sharplispers/log4cl/) is handy.

   thread
4. z0ltanDec 2016
   Definitely this book. I would recommend keeping Graham's books for later.

   Practical Common Lisp + Land of Lisp + Common Lisp recipes + the Lisp Hyperspec = Profit!

   Additional readings: Successful Lisp (Lamkins - very underrated), Paul Graham's books, and Hoyte's Let Over Lambda (advanced).

   thread
5. groovy2shoesMar 2016
   For SICP, you need a Scheme implementation (specifically, one that supports IEEE Scheme if you're using the second edition of the book -- R5RS, the most widely-implemented standard, is a strict superset of IEEE Scheme and works just fine with the code in the book, apart from the non-standard "picture language" stuff in chapter 2).

   I highly recommend using Racket with the DrRacket IDE and Neil van Dyke's SICP package from the Planet package repository. It's the easiest way to get up and running with an editor and a REPL, and it's got support for the "picture language" in chapter 2.

   You could also give it a shot with MIT Scheme -- I've got a feeling it's the implementation SICP (2e) was developed with. It's also got a built-in Emacs-like editor called EdWin. Launch the MIT Scheme REPL and type `(edwin)` to get at the editor.

   GNU Emacs has an extension called Geiser (available in MELPA) that works well to integrate with Racket and Guile. Otherwise, the cmuscheme package that ships with Emacs gives you rudimentary REPL integration with just about any Scheme interpreter (and quite a few Schemes, such as Gambit, come with packages to better integrate with cmuscheme and scheme-mode).

   If you're not an Emacs user and you're not willing to invest the hour or so it takes to get a handle on the basics, you can, of course, use any editor you want and use the `load` procedure (which, iirc, was omitted from IEEE, but most Schemes have it) at the REPL to import definitions from a file (or there's always good ol' copy+paste).

   If you want to learn Common Lisp rather than Scheme, you can check out "Successful Lisp" by David Lamkins and/or "Practical Common Lisp" by Peter Seibel, both of which are freely readable on the Web. You'll also want to keep the ANSI Common Lisp HyperSpec by Kent Pitman handy as a reference (also free on the Web). For this, you can grab virtually any ANSI Common Lisp implementation (GNU clisp, SBCL, Clozure CL, ABCL, etc.). GNU Emacs has excellent support via the SLIME package (available from MELPA), or the other-editor with the `load` function will work here, too.

   If you want to learn Emacs Lisp, GNU Emacs comes with an introductory programming book that uses Emacs Lisp, "An Introduction to Emacs Lisp Programming" by Bob Chassel, and the Emacs Lisp Reference Manual. As you might guess, GNU Emacs has the best editor support for Emacs Lisp, though Vim at least has syntax highlighting for Emacs Lisp.

   If you want to learn Clojure, the only freely-available book I'm aware of is "Clojure for the Brave and True" by Daniel Higginbotham, though I'm sure there are others. MELPA has the CIDER package available for Clojure support in GNU Emacs. I'm not familiar enough with Clojure at this point to know what the equivalent to `load` is, though.

   At this point, I've pretty much exhausted my usefulness on this matter. If you want to learn T, ISLISP, EuLisp, Le Lisp, Arc, or any other Lisp dialect for that matter, I can't help you.

   After all that, I highly recommend starting with SICP. It's really a great introduction to programming, and it also covers quite a few concepts that will likely be new to you even if you're already a programmer (mostly in chapters 3-5). (Disclaimer: although I like most of the Lisp dialects, my favorite is absolutely Scheme, so I may be biased ;)). Pick an (IEEE or R5RS) Scheme interpreter, have a glance over its documentation, and you should be good to go!

   Show morethread
6. fractallyteJul 2013
   Don't forget 'Successful Lisp' by David Lamkins (http://psg.com/~dlamkins/sl/) - in printed-book or HTML versions.

   Chapter 3 is an excellent 'nutshell' introduction to Common Lisp. The rest of the book, aside from covering various details of CL, provides a wide-ranging overview of the modern Lisp ecosystem, from editors to UIs.

   I found it a valuable complement to the other books noted here, but somehow it doesn't get much mention!

   Show morethread