Writing a C Compiler: Build a Real Programming Language from Scratch

First and foremost: the book is FANTASTIC. It has the perfect hands-on approach fitting for anyone that prefers learning by tinkering, playing with, tweaking and/or bending code, getting their hands dirty with full blown implementations, rather than with theoretical rigor, proofs, and descriptive completeness. In other words, while there are plenty of books out there for PhDs, this is the first I’m coming across FOR ENGINEERS. I’m one of the many (many) out there that learns by doing, and god damn, I’m happy that this book exists. Here, there is no need to digest so much information that you’ll be disgusted and saturated by the time you write the first line of code; no, you learn along the way, by seeing the results at each and every step.On one hand, there is all the information you could possibly need such that you never have to look it up somewhere else, and you can stick with the book the whole way for it is completely sufficient on its own (but the numerous additional resources and links are more than welcome to dig deeper on specific points that would nonetheless scratch your interest). On the other hand, nothing is given to you on a plate, and you still must go through every line with the uttermost attention to make things work, which is absolutely great for understanding and learning. Thus, you can only get a working result if you REALLY understand what is going on.About the content itself, the features are well chosen and there are enough to get a serious real-world language: each chapter implements a language feature that builds up and extends the existing set of features, and thus what the compiler can DO. The resulting subset of C that is implemented by the end of the book supports almost all core features of the C language and covers more than enough ground to be then used for the development of your own hobby projects.The difficulty curve is also nicely increasing over the course of the book. Once you understand the layout of the project, as well as how to use the test suite, the first chapters are going quite smoothly, and the complexity is slowly growing throughout Part 1. Things are getting serious in Part 2 with the implementation of the Type System, where a lot of time is spent dealing with finicky details of the language and debugging assembly code. But what tricky details and corner cases you fail to figure how to solve from the book, you will find answers for in the extensive comments in the tests.I’m a young C++ software engineer a few years out of university, with no prior experience in making compilers, but that got passionate and seriously invested in the project. All I can say is that, with no background nor prior knowledge in compiler engineering, I managed to get through the whole book and fully implement the project: which means that anyone can! This project also gave me a much deeper understanding of the C language, and made me quite significantly better at my job, which includes a good chunk of C development. For all of that, thank you.

Yes, this is a good book about writing a C compiler.But I expected - without, perhaps, reading the description well enough - that it would explain and then present source for the compiler. It's about writing a C compiler, so - again, lazily - I expected that the source of a canonical example of the book's design would be presented. It's not.The design of each fragment of the compiler is presented as pseudo code. This is detailed enough that I think it would be straight forward to translate it to C. But then you would be presented with testing the resulting code.The book provides 'this code should compile' and 'this code should fail to compile' examples for testing purposes, but this is a coarse filter.It's possible to say that well, gosh, if you're writing a compiler you should be able to construct test cases yourself - and for a general compiler - that could be for a new language - this is certainly fair enough. Not sure that's the case for C, especially a large subset of C rather than a particular C specification. If it were a compiler for C99, for example, there's probably a test suit somewhere.This is simply saying that if you use this book to write a c compiler, you've got a lot of work to do. But much less than you'd have if you didn't buy the book.I bought it because I'm writing a compiler for a new language, and wanted to see if I'd done things in a reasonable way.

I purchased this book expecting to have a fun fall project. I really wanted to love this book. It covers the topic very thoroughly and must have been a gargantuan writing project. This book tells you the whats and whys of designing and building a compiler in great detail. What it does not have is concrete examples of how to do these things. There is absolutely no hand-holding when it comes to actual coding. It also recommends and assumes knowledge of more modern languages like Rust or OCaml. I was hoping to code the compiler directly in C.This book is not for novices full stop. I have been coding both professionally and as a hobby for a little over 35 years and am currently finishing my BS in CS. I started getting lost on page 10. My expectations for this book were sadly not met as I was looking for it to have more ‘this is how to write x’ with example source code. What it does do is tell you what to make, and then you have to go figure it out for yourself with a test suite that lets you know if you made it correctly. This approach may work for some, but unfortunately, I am not one of those people.

pretty solid book though the first chapter was confusing to me after muddling through it made more sense

I have three years of computer science experience and have loved working through this book (currently through 6 chapters). I didn't have any knowledge of assembly or compilers coming in but the author does a fantastic job outlining compilation steps and algorithms. It's true that there is not a ton of hand holding, but why would you want that? When writing my compiler, I'm free to make my own decisions, and when I'm wrong I learn infinitely more than I would have if the author had told me what code to write.I don't know if I would have been prepared to tackle this book on my own before a year or two of coding, but I can't recommend this book enough to anyone who is excited to learn about compilers and understands going in that they'll need to think for themselves and will make mistakes.