Peter Seibel
gigamonkeys.com · Personal blog · on HN since 2007
Peter Seibel is a programmer and author of Practical Common Lisp, and writes about Lisp, code and software craft.
What HN saysHN links it mainly for the free Practical Common Lisp book, which commenters recommend as a starting point for learning Common Lisp.
328HN people shared it
267linked it in comments
89stories submitted
2.8Kstory points
3 months agolast shared
2007people per year2026
Most-shared posts
- 1Practical Common Lisp (2005)131 people · 596 points · first shared 2007 · 157 comments on HN
- 2Beyond Exception Handling: Conditions and Restarts44 people · 159 points · first shared 2009 · 20 comments on HN
- 3Code is not Literature22 people · 445 points · first shared 2014 · 83 comments on HN
- 4Let a thousand flowers bloom, then rip 999 of them out20 people · 252 points · first shared 2015 · 122 comments on HN
- 5How to use loop in Lisp19 people · 3 points · first shared 2009 · discussion on HN
- 6The Story of Mac: A Just-So Story (2005)9 people · 77 points · first shared 2009 · 2 comments on HN
- 7Object Reorientation: Generic Functions8 people · 2 points · first shared 2007 · discussion on HN
- 8Unit Testing in Coders at Work7 people · 7 points · first shared 2011 · 1 comments on HN
- 9Introduction why lisp6 people · first shared 2007
- 10C++ in Coders at Work5 people · 181 points · first shared 2011 · 185 comments on HN
- 11A tale of two rewrites (2009)5 people · 5 points · first shared 2010 · discussion on HN
- 12Practical a simple database5 people · first shared 2008
- 13End of the line for Code Quarterly4 people · 59 points · first shared 2011 · 18 comments on HN
- 14Lispbox - lisp in a box4 people · 27 points · first shared 2008 · 14 comments on HN
- 15Object reorientation classes4 people · first shared 2009
What HN people wrote when they linked it
kayo_20211030 · 2026-01-11
Peter Seibel's original post is worth reading in its entirety.
It's a decently balanced piece. It leaves room for various views, and its summation seems about right.
https://gigamonkeys.wordpress.com/2009/10/05/coders-unit-testing/
skydhash · 2025-12-17
Do you honestly think that’s how people learn?
This is an example of a book on Common Lisp
https://gigamonkeys.com/book/practical-a-simple-database
What you usually do is follow the book instructions and get some result, then go to do some exploration on your own. There’s no walk in the dark trying to figure your own path.
Once you learn what works, and what does not, then you’ll have a solid foundation to tackle more complex subject. That’s the benefit of having a good book and/or a good teacher to guide you to the path of mastering. Using a slot machine is more tortuous than that.
taeric · 2025-11-11
I think this often boils down to the same criticisms directed to LISP's FORMAT? https://gigamonkeys.com/book/a-few-format-recipes has my favorite take, "While FORMAT's control strings can be cryptic, at least a single FORMAT expression doesn't clutter things up too badly."
Feels like the same would be true for the array languages. Obviously code golfing it all down to be an array manipulation is going to be unreadable. But if you are legit doing manipulations on an array of data, probably going to be pretty hairy in the expanded version, as well. I can see wins from not necessarily naming every intermediate part of the process.
mananaysiempre · 2025-08-02
Oh, that’s an interesting take. I’ve long been looking for newer developments on Awk’s clause structure, and this seems like an interesting take (though I’m unclear on whether I can have multiple begin/end clauses, which are the best thing about Awk’s version). It also finally connects this idea to something else in my mind—specifically advice[1] and CLOS’s :before/:after/:around methods[2]. (I guess Go’s defer also counts?)
[1] https://en.wikipedia.org/wiki/Advice_(programming)
[2] https://gigamonkeys.com/book/object-reorientation-generic-functions
mepian · 2025-07-05
I recommend starting with this free book which covers Common Lisp: https://gigamonkeys.com/book/
susam · 2025-01-12
I began learning Common Lisp (CL) from the Common Lisp HyperSpec (CLHS): <https://www.lispworks.com/documentation/HyperSpec/Front/Contents.htm&g… When I began learning CL about two decades ago, I did know of any other easily available source, so CLHS was my only source back then and I think it has served me well.
A popular recommendation these days is Practical Common Lisp (by Peter Seibel): <https://gigamonkeys.com/book/>.
brabel · 2025-01-08
I suspect you'll love Common Lisp's LOOP: https://gigamonkeys.com/book/loop-for-black-belts
Example:
(loop repeat 8 ;; init x, then decide how to "prepare" next iteration for x = 0 then (+ (* 2 x) 1) collect x) (0 1 3 7 15 31 63 127) You can insert a condition check in the middle, of course:
(loop repeat 8 for x = 0 then (+ (* 2 x) 1) ;; but stop if x gets too big while (< x 100) collect x) (0 1 3 7 15 31 63) And much, much more. It's the ultimate loop construct.
ocodo · 2024-07-26
The Giga Monkeys Book, Practical Common Lisp is also excellent:
https://gigamonkeys.com/book/
schemescape · 2023-12-04
Not exactly what you asked for but, if you have time, I would recommend looking at Practical Common Lisp:
https://gigamonkeys.com/book/
And also this blog post (which is a much smaller time commitment):
https://mikelevins.github.io/posts/2020-12-18-repl-driven/
benrutter · 2023-08-24
There was a blog post from Peter Seibel recently called [Code Is Not Literature)](https://gigamonkeys.com/code-reading/) which pointed out that although everyone seems to agree reading code is great, very few tend to do it regularly.
I feel like I get a lot more out of messing with / hacking on code than I do from reading it. I'm sure people vary, but I've got loads more out of open source contributions to sometimes small projects, and not very much out of trying to do something like read the code for the Glasgow Haskel Compiler or something.
So for code to read, I think having an in is crucial, at least for me. So I'd say, find a cool, maybe small open source project, look at the issue tracker if it has one, and try to implement something. You'll only really know if it's good code (or why) after you start trying to change it.
st3fan · 2023-07-01
The book is great too. You can read it online at https://gigamonkeys.com/book/
Even if you will never use Commin Lisp in production it will teach you new tricks and new ways to think about software development.
andsoitis · 2023-06-05
> Is there a recommended "intro to understanding lisp" resource out there for someone like myself to dive in to?
Practical Common Lisp - https://gigamonkeys.com/book/
Casting SPELs in Lisp - http://www.lisperati.com/casting.html
Structure and Interpretation of Computer Programs - https://mitp-content-server.mit.edu/books/content/sectbyfn/books_pres_…
One of many prior discussions here on HN: https://news.ycombinator.com/item?id=22913750
... amongst many resources for learning LISP.
pavlov · 2023-03-06
Since the 2010 nadir of fail whales, Twitter invested a lot into improving their engineering quality.
There's a great 2015 essay by Peter Seibel who was tech lead on their Engineering Effectiveness team:
https://gigamonkeys.com/flowers
I'd guess almost nobody from that era remains at Musk-Twitter.
massysett · 2023-02-18
The short answer is that with a singly-linked list, you can easily add items to one end (conceptually, typically the front end.) Then if other code has references to the older parts of the list, they’re still valid.
A great explanation of this is in “Practical Common Lisp”:
https://gigamonkeys.com/book/they-called-it-lisp-for-a-reason-list-pro…
twawaaay · 2023-01-17
My favourite is "Practical Common Lisp" by Peter Seibel (https://gigamonkeys.com/book/)
Not only is the book free to read (although I would suggest to pay for it if you like it!) The code to parse binary files actually "inspired" my design of an actual production application which was very flexible, succinct and, most importantly, so fast I had to spend a lot of effort convincing people the numbers are actually true.
It taught me some important lessons about how you can achieve performance with Lisp languages and the real reasons for the power of macros. Not too shabby for the first book on Lisp I red!
reikonomusha · 2022-11-25
For Common Lisp, there are several free books available:
- Practical Common Lisp (aimed at people who know how to program in a more mainstream language already) [1]
- Paradigms in Artificial Intelligence Programming (my personal favorite) [2]
- Common Lisp: A Gentle Introduction to Symbolic Computation (aimed at absolute beginners of programming) [3]
I highly recommend the r/lisp Reddit community. Reddit as a platform has its issues, but the Common Lisp community there is very responsive and very helpful.
Lastly, you might be interested in checking out Kandria [4], a game written entirely in Common Lisp, to be released imminently on Steam.
[1] https://gigamonkeys.com/book/
[2] https://github.com/norvig/paip-lisp
[3] https://www.cs.cmu.edu/~dst/LispBook/
[4] https://store.steampowered.com/app/1261430/Kandria/
eadmund · 2022-07-11
To learn Lisp, rather than Scheme, Practical Common Lisp is awesome. It's available online for free at https://gigamonkeys.com/book/, but I recommend purchasing it if you can.
guenthert · 2022-06-07
The specification is (mostly) exhaustive, but would make a very poor introduction into the language. Common Lisp the Language (2nd ed.) [1] by Guy Steele himself gives good background information, but I wouldn't recommend it as introductory text either (and it isn't meant to). Practical Common Lisp [2] by Peter Seibel does IMHO a pretty good job at that.
[1] https://www.cs.cmu.edu/Groups/AI/html/cltl/cltl2.html
[2] https://gigamonkeys.com/book/
ksaj · 2022-05-25
The most famous resource is also probably one of the best. Practical Common Lisp, by Peter Siebel. https://gigamonkeys.com/book/
You can read it for free. But its such a good resource I bought a hard copy and keep it within reach at all times. I like to take notes in the columns, and mark up interesting things I know I'll have to review on occasion.
Last year Peter tweeted out a teaser that he might add some new content to the book, as there has been a lot of progress since this was written. But it is in no way outdated as is.
emodendroket · 2022-01-09
Yeah, the word "read" seems to have seduced us into an obviously false analogy. "Reading" code is not like "reading" a novel. Perhaps this could seem more plausible if your work was primarily along the lines of Knuth's, rather than combining the same bag of shopworn, well-known techniques into academically rather uninteresting production code.
Another article on this topic I recommend is "Code Is Not Literature," from Peter Siebel: https://gigamonkeys.com/code-reading/
xfer · 2021-05-02
clojure uses immutabilty heavily. It doesn't really match 1-to-1 CL/elisp code. I think PCL(http://gigamonkeys.com/book/) is still a great introduction to CL. The author is planning a 2nd edition last i heard.
fiddlerwoaroof · 2021-05-01
The best way to learn CL, IMO, is installing Portacle[1] and working through either Practical Common Lisp[2] or Common Lisp: a Gentle Introduction[3]. (I personally prefer PCL, but a lot of people like Gentle)
[1]: https://portacle.github.io/
[2]: http://www.gigamonkeys.com/book/
[3]: https://www.cs.cmu.edu/~dst/LispBook/index.html
jnxx · 2021-04-24
Here is an introduction by Peter Seibel:
http://www.gigamonkeys.com/book/beyond-exception-handling-conditions-a…
(it is a chapter from "Practical Common Lisp", an really excellent book!)
lew89 · 2020-12-16
First you have to choose your flavor. If you want to use JVM, probably clojure. Otherwise Scheme, Common Lisp and Racket. Scheme is rather minimalistic, Common Lisp is very functional and Racket is the most modern one I guess. I ended up with Common Lisp and I rather don't look for change. SBCL is implementation I use and like it. Probably the best one and quite portable.
Emacs seems the best choice for Lisp, since it is scripted in Lisp and it's best adapted to it probably. However when I started, I was already so used to vim that I kept going with it. Maybe not the best option, but it's ok, maybe just a little bit more effort to automatize some stuff.
If you choose Common Lisp, this is probably the best book for start: http://www.gigamonkeys.com/book/ . Anyway be prepared, Lisp is not easy to grasp at first, but as soon you do, you will probably love it and appreciate way it is. :)
pcr910303 · 2020-05-01
Not OP, but Lisp isn’t really a functional language — it’s a usual language that also has some functional ideas inside. Mutation is common, don’t think Lisp will be a language like Haskell.
For resources, I would recommend Practical Common Lisp[0] and PAIP[1].
For some modern development practices, the Common Lisp Cookbook[2] is great.
[0]: http://www.gigamonkeys.com/book/
[1]: https://github.com/norvig/paip-lisp
[2]: http://lispcookbook.github.io/cl-cookbook/
papaf · 2020-04-19
There are many book resources and it’s way more fun.
I recommend Practical Common Lisp - its free online:
http://www.gigamonkeys.com/book/
matthberg · 2019-03-06
Currently working through these to learn Common Lisp after being introduced to the language as part of a college CS class, can definitely recommend them along with Practical Common Lisp [0] and Let Over Lambda [1].
0: http://www.gigamonkeys.com/book/
1: https://letoverlambda.com/
kwccoin · 2019-03-01
Waiting for it and can it port to multiple platform like pi, iOS, Andorid, browser ... etc. Obviously can be a joint effort but once the basic is done, we can have a new and refreshing effort.
I always think that why PAIP is great you always have this feeling like Star Trek NG. Suddenly you have a function that works. BTW, I think the other web sites http://www.gigamonkeys.com/book/ would be good.
Not one person but if there is a basis we can grow the community, especially if one can port to Pi and iOS.
TeMPOraL · 2019-01-15
Two important newer Common Lisp books worth mentioning:
- Common Lisp Recipes - http://weitz.de/cl-recipes/ - the de-facto go-to book on practical Common Lisp usage, for people with at least basic familiarity with the language.
- Land of Lisp - http://landoflisp.com/ - introduction to CL + overview of some more distinct aspects of other Lisps (often portable to CL as a library), teaching by means of writing small games; quite... peculiar.
Also, if someone wants to start with Common Lisp, then Practical Common Lisp (PCL) is usually the book for it. The entire book is available on-line for free: http://www.gigamonkeys.com/book/.
zeveb · 2018-10-16
Another two factors in the '00s re-rise of Lisp were Steve Yegge's Drunken Blog Rants (https://sites.google.com/site/steveyegge2/blog-rants) & Practical Common Lisp (http://gigamonkeys.com/book).
The former was, at the time, very influential (and deservedly so); the latter was and remains the best reference for actually using Common Lisp to write real software (Edi Weitz's Common Lisp Recipes is an excellent companion volume).