The two most popular discussions of this fantastic book:

2020 with 777 points: https://news.ycombinator.com/item?id=22788738

2024 with 607 points: https://news.ycombinator.com/item?id=40950235

Reading this book brought me a better understanding of "the expression problem" and the use of the visitor pattern as its solution. This led me to (finally) grok the use of Class _Heirarchy_ Inheritance[0] as a solution not requiring visitors. In Newspeak[1], classes can contain nested classes, so when you subclass a class, you inherit the nested classes as well. This blog post discusses the same feature affording Free Object Algebras [2].

[0] https://blog.bracha.org/primordialsoup.html?snapshot=Amplefo... [1]https://newspeaklanguage.org [2]https://blog.bracha.org/primordialsoup.html?snapshot=Amplefo...

I've found this book to be a good way to learn a new language, because it forces you to do a bit of reading about various language features and patterns to create equivalent implementations. For languages that lack some of the features in Java, it can be tricky to learn how to apply similar patterns, but that's half the fun (for me).

I just went through this book during the winter holidays. I just love the author's casual writing style and all the tiny jokes and puns they made.

I hope we get to see "Add a type checker to Lox" sequel

It's a great book, I bought the paper version first, but man it was too big and heavy for my liking, ended up buying a digital copy; much more practical for notes and search...

although I keep getting lost somewhere in the mountain :)

I also recommend munificent's other book about game programming patterns. Both are fun to read.

I have bought the print version of this 3 seperate times to give as a gift, its excellent.

One of the best resources for learning compiler design. The web version being free is incredibly generous.

I love this book! I do wish there was a new edition that updated the version of Java used in the tree-walk interpreter. There's been some additions to the language, like sealed classes and exhaustive switches, that could really benefit the implementation.

Really I would love to know how parse context sensitive stuff like typedef which will have "switched" syntax for some tokens. Would like to know things like "hoisting" in C++, where you can you the class and struct after the code inside the function too, but I just find it hard to describe them in rigorous formal language and grammar.

Hacky solution for PEG such as adding a context stack requires careful management of the entry/exit point, but the more fundamental problem is that you still can't "switch" syntax, or you have to add all possible syntax combination depending on the numbers of such stacks. I believe persistent data structure and transactional data structure would help but I just couldn't find a formalism for that.

Simply my favorite programming text of all time.

I'll just drop this here for those looking to get started on interpreters:

https://github.com/codr7/shi

And perhaps this for those leaning towards C:

https://github.com/codr7/hacktical-c

Part of a 2nd half of this book translated to Go became a skeleton for the BCL configuration language https://github.com/wkhere/bcl

I stopped reading when he started using the visitor pattern

In case anyone finds it useful, we (CodeCrafters) built a coding challenge as a companion to this book. The official repository for the book made this very easy to do since it has tests for each individual chapter.

Link: https://app.codecrafters.io/courses/interpreter/overview

Crafting Interpreters is the one thing that LLM's can do really really well. Because it is so easy to define and test.

Here are is a new LUA interpreter implemented in Python:

https://github.com/rhulha/MoonPie

And here is a new language:

https://github.com/rhulha/EasyScript