Principles of compiler design

What Hacker News says

1. PaulHouleMar 2025
   Depends on the book. There are a lot of books that are the equivalent of a podcast episode (anything by Malcolm Gladwell) or a series of podcast episodes (anything by Robert Greene) and even some serious and influential books in the social sciences and can be cooked down to a single university lecture like

   Exit, Voice and Loyalty by Albert O. Hirschman

   Logic of Collective Action by Mancur Olson

   The Zero-sum Society by Lester Thurow (want to know why the world gave up on tariffs?)

   maybe some worthwhile management books could be extended into a podcast series, I'd say

   Quality is Free by Phillip Crosby

   Then there are some books that really could change your life, say

   Solid State Physics by Ashcroft and Mermin

   The Art of Computer Programming by Donald Knuth

   Principles of Compiler Design by Aho and Ullman

   Software Estimation: Demystifying the Black Art by Steve McConnell

   The Mushroom Cultivator: A Practical Guide to Growing Mushrooms at Home by Paul Stamets

   Starting Strength by Mark Rippetoe

   Being and Event by Alain Badiou

   Liberation in the Palm of your Hand by Pabongka Rinpoche

   The Art of Happiness by Mirko Fryba

   All of which have the element that they'll only change you if you engage deeply with them or the subject, like for the Rippetoe book you're going to have to pick up a bar.

   Show morethread
2. ggmFeb 2025
   The Dragon Book: Principles of Compiler Design (Alfred V. Aho, and Jeffrey D. Ullman, 1986)
   thread
3. nabla9Jul 2023
   That's because the second author is Jeffrey Ullman (Turing Award, Neumann medal)

   Ullman is of the authors of several legendary computer science books Dragon Book (Compilers: Principles, Techniques, and Tools) the Cinderella Book (Introduction to Automata Theory, Languages, and Computation), Green Dragon Book (Principles of Compiler Design)

   If you want to learn deep stuff with clarity, those old books are still the way to go.

   Show morethread
4. philipluMar 2023
   I'm a self-taught programmer, starting in the mid-70s, and learned how to write compilers in a way that probably wouldn't work nowadays, but was great fun back then.

   The first thing I'd usually do when starting on a new architecture was write a disassembler. In the late 70s, I was mostly programming in 6809 assembly, usually in Microware's OS-9 operating system. Microware released a Pascal compiler, so I ran my disassembler over that. Turns out the compiler was self-hosting, written in Pascal, and the compiler output was almost completely unoptimized. So I decompiled the compiler back to Pascal by hand, just to see how it worked. I obviously had waaaaay more free-time back then.

   I eventually read the green Dragon book (Aho & Ullman, Principles of Compiler Design), and ended up at Microsoft on the C/C++ team in 1991. Over the years, I've written several domain-specific languages (DSLs), small languages for some limited purpose. That early exposure to lexing, parsing, and error detection was invaluable.

   Show morethread
5. potta_coffeeDec 2020
   Principles of Compiler Design is old but still a great book, one of the best CS books I've read and it got me going with compilers. I'm reading an old copy from the 70's.
   thread
6. descJan 2019
   This. Visibility into what is actually going on, and the drive to understand it. Troubleshooting, debugging, learning: all the same thing, but tarred with different parts of the process. Dig into what's actually going on and understand the layer under you.

   tl;dr: Keep digging, because everything's worth knowing at some point.

   It's generally much easier to fix a bug in your own code or infrastructure if you're familiar with the innards of the things you depend upon directly, and learning your preferred platform beneath the current frameworks is a solid advantage because it helps you move sideways when the next New Framework comes along.

   But there's also the conceptual side, the general concepts which have remained unchanged for decades, which a detailed knowledge of a specific platform (eg. Java, .NET, Node.js) doesn't necessarily aid with. These probably won't even feel relevant on a daily basis, but will definitely multiply your effectiveness over the long term.

   Some things which might fall into that category:

   * SQL and relational databases (especially if you're not using SQL, because you'll be reinventing it for any nontrivial amount of data)

   * Consistency models and distributed systems (capabilities and limitations; some things can never be waved away by technology)

   * The operating system, and principles of its design (not necessarily in any great detail, but knowing roughly how software talks to hardware is very useful, especially when assessing the marketing blurb for any cloud platform)

   * Complexity theory (stringing three 'optimal' algorithms together might be textbook, but often you can apply some domain knowledge to cut out a step or two to reduce actual runtime and maintenance overhead)

   I've found stuff like graph theory, principles of compiler design, and a working knowledge of assembly code to be useful too, but that's probably the far end of the bell curve for web server stuff :P

   Computer Science is a subset of mathematics and it's amazing which bits of pure maths turn out to be useful in my day job. Shame I'm not very good at that stuff... but reading enough about it to recognise when it's applicable can mean the difference between 'picking a good library off the shelf' and 'hacking together a terrible solution myself'.

   Show morethread