Crafting Interpreters

Original Article ↗ Hacker News Discussion ↗

Book relevance and scope

  • Widely regarded as still highly relevant despite being a few years old; foundations of interpreters/compilers don’t change quickly.
  • Positioned as an introductory, hands-on book rather than a reference on advanced or bleeding-edge techniques.
  • Some readers are slightly disappointed it doesn’t go into more advanced topics, but others argue that’s intentional and appropriate for its stated audience.

Learning experience and pedagogy

  • Many say it’s one of the clearest technical books they’ve read, with strong structure, pacing, and explanations.
  • Building two interpreters for the same language (tree‑walking in Java, bytecode VM in C) is seen as a major strength: you revisit concepts with deeper understanding.
  • Challenges at the end of chapters are recommended for solidifying understanding.
  • Several discuss how to “consume” it: generally advised to follow along coding, chapter by chapter, rather than just reading.
  • One annoyance: intermediate snippets sometimes don’t compile until later in the chapter; author explains this is a trade‑off to avoid distracting boilerplate and keep focus.

Implementation languages and translation

  • Some hesitate because of Java, but many say Java is readable if you know any C‑style language and can be treated as pseudocode.
  • Multiple readers reimplemented the interpreters in other languages (Python, Zig, C#, Clojure, Rust, PowerShell, etc.), finding that translation deepens understanding.
  • The C VM is seen as a good fit for low‑level languages like Zig and Rust.

Parsers, tools, and compiler techniques

  • Debate over lex/yacc vs hand‑written parsers:
    • Pro‑POSIX side: lex/yacc are standardized and “rock solid” once learned.
    • Critical side: poor UX, C‑only output, limited portability, and lots of magic macros; better to hand‑roll recursive descent, especially in a learning book.
  • The book explicitly avoids parser generators to eliminate “magic” and focus on understanding every line.

Static typing and advanced features

  • Several ask about resources for statically typed languages, generics, and type inference; suggestions include more advanced compiler texts and Algorithm W for Hindley‑Milner.
  • The author notes a follow‑up on types or native‑code compilation is tempting but hard: design space is large (subtyping vs not, erased vs reified generics, inference styles), and writing another book is a major commitment.

Garbage collection and runtime design

  • The GC chapter stands out for some; one reader describes a modification where GC is modeled as its own instruction to avoid in‑instruction collections and certain GC bugs.
  • Author responds that scheduling GC remains an under‑documented, practical problem despite many papers on algorithms.

Impact on readers

  • Many report the book demystified compilers/interpreters, gave them confidence to build their own languages or tools, and improved their understanding of recursion, trees, closures, and language semantics.
  • It’s frequently recommended as a first or second serious step into programming languages, often paired with more theoretical texts afterward.