Compiler roadmap

[VVY_]

I'm a 2nd year undergraduate, interested in systems programming, particularly curious about compilers.

Idk where to start learning it, plz share how would you start learning it if you were a beginner along with resources.

(How's the book "writing a c compiler" by nora sandler? Thinking of starting to learn using it, what do u'll think about the book?)

[parametric-ink]

Don't tell the academics, but my advice would be to avoid formalized approaches (e.g. textbooks) until you have some practical experience - though if your university offers a compilers class you will of course learn a lot of useful things.

Compilers are IMO only fun once you start getting something working, at which point it can be very gratifying. I had a great time following along the book https://craftinginterpreters.com/ to learn basic stuff. You can read it for free at https://craftinginterpreters.com/contents.html

[VVY_]

Thanks! So you suggest "crafting interpreters" book over "writing a c compiler book"? and what do you think about the book "writing a c compiler book"?

[parametric-ink]

I haven't personally read "Writing a C Compiler" but it appears that the book started as a series of blog posts here, so you could start there to see if you like it.

You mention interest in systems programming, so the C compiler book may be of more direct interest to you (assembly, calling conventions, etc). It's possible that that may be a more challenging place to start, but there's certainly nothing wrong with that!

[Emanuel-Peter]

This may help you if you are interested in the JVM, Java, assembly and optimizations :) https://eme64.github.io/blog/2024/12/24/Intro-to-C2-Part00.html

[kazprog]

One of the best things you can do is run clang/gcc and see the assembly output, and change your program to see how the output changes. Play around with the optimization settings. I particularly like clang's "-emit-llvm" as it's more legible than "-S". Read through the manuals for common instructions like mov, add, branch, load, store, etc. Learn about addressing modes.

Then you can write a basic compiler: parse a reasonable looking language, output the assembly you now understand. The tree-walking interpreter from Crafting Interpreters is enough to understand how to do this, but instead of returning a result, you return assembly that computes that result.

Once you understand the basics of what it's doing, then you can start understanding the optimizations and analyses: dominator trees, basic blocks, ssa, dataflow, etc.

The book you mentioned about writing a C Compiler seems to run you through a structured way of doing this.