Modern Compiler Implementation in C

Rating:
Summary: This is actually a decent book
Review: Despite what others have said in their reviews, this is not a bad book at all for those who *already have some basic exposure to compiler theory.*

This book is weak on types of grammars and the differences between LL, LR and LALR parsers for instance, and could include a hell of a lot more material on using parser generators. BUT it includes a lot of readable material on more advanced topics like code generation and garbage collection. It covers the design and implementation of object oriented languages, which is a pleasant suprise.

Before tackling this book, I recommend starting with something like "Crafting a Compiler with C" by Fischer and LeBlanc. Before using this book, you must have a masterful command of the C language (in my opinion the C code is unusually ugly in this book, too).

I don't care too much for the ongoing project of the Tiger language and compiler, but it's better than nothing. (The author may as well have compiled Pascal instead).

I've covered a fair amount work and even then had to read this book carefully. I've tackled books like "Compilers: Principles, Techniques and Tools" (the so called Dragon Book) and "Crafting a Compiler with C," amongst dozens of others. This is not a light read, and it is quite dense. But it's straight to the point, and covers material other compiler construction books don't.

One of the high points of this book is that it won't put you to sleep! It really IS readable. Finally, I will emphasise again, this is not a beginner's text.

Rating:
Summary: this is a java book in disguise
Review: I bought this book, much to my chagrin, because I had looked at the Java one which FYI is a verbatim copy of this one. All the author did was translate the examples from Java to C. This was done in a very poor fashion I might add. He attempts to duplicate the object orientedness of java with straight c (no c plus plus). So instead of using a standard parse tree and symbol table, he invents this cockamamie type of tree structure using very java-esque structures. Anyway my recommendation is if you are looking for a Compiler book in C then this is not your book. If you are looking for Java, then you might as well get the java version of this guys book. My personnal recommendation is to get the dragon book.

Rating:
Summary: Excellent concept, fair execution
Review: I chose this textbook for a five-student independent study course. The book's concept is great: Define a substantial language, and describe a compiler for it over the semester, having the students write the interesting bits. I was excited to read this text and do the project with my students.

The book (at least the first half) stands or falls on the project. The project itself is outstanding - there are several interesting tidbits. It's probably too large for a three-credit course at most institutions - I had to pare it down by giving additional pieces to my students.

Unfortunately, the project destroys the book. The book devotes large portions of the first half to trying to explain it. Explanations are only marginally coherent. To make sense, the project desperately needs detailed, low-level documentation, listing each function of each module and what it does. Additionally, it would work better if there were a clearer distinction of where the theory ends and the project begins.

The program is itself well-structured on the high level. Within functions, they need to format code properly. They do some interesting things with trying to do functional programming within C - a controversial move, but not one that I mind. The definite impression I get is that the publishers demanded a C version against Appel's will. I haven't read the Java or ML versions, but I bet the code is better (especially ML).

Outside the project, I found the book strong. The algorithms are well-presented, with lots of outstanding examples. (My students found them confusing; I attribute that to the material's inherent difficulty, not the writing.) It does a thorough job, but not overly thorough. Some of the later chapters on advanced topics I've found slightly less complete - but they're advanced topics, after all.

I'd recommend it over the dragon book; but it's a close call. But this could be so much better so easily... Appel just needs to flesh out the project, and he'd have a truly great book.

Rating:
Summary: I'm speechless
Review: If you already know how a compiler operates, this book isn't for you. That's basically all this book covers, no emphasis on actual code.

In fact, the author is pressing you to use other programs like Lex to create parts of your compiler for you. Well, you certainly won't learn anything unless you do the work yourself.

This book was nothing but compiler theory, and no implementation. Lots of references to code (which often changes), and you have no clue where it is.

You can even download the code for the book, but it won't help. The code itself is written in sloppy form, too.

Rating:
Summary: a good theory...
Review: Not so bad, not so good... it has good topics, but there are not implementation of how to build it, the small number of sample have some unique (rare) style... if you intent to write your first compiler this is NOT your book, if you already made one and pass for some frustating issues then this is your book...

Rating:
Summary: Informative.
Review: The author of this book addressed all the issues that I needed to resolve. It is not a "spoon feed" approach, however there is enough examples to explain the authors ideas.

I won't recommend the book for people who likes a "copy-paste" approach.

Rating:
Summary: The Project kills this book
Review: The book is fairly good. Covers the compiler theory pretty well, and includes a good coverage of advanced topics at the end. I gave it a low rating because the project really kills this book. The first 12 chapters are a walk-through gide for building a compiler for the tiger language (which the author defined). The tiger language itself is weird at first since it doesn't have any statements. It only has expressions. Besides, the language is not thoroughly documented in the book and leaves a lot of things open for the implementor. At any rate, after building the first few chapters (about the time you've done the parse tree) the book starts to get confusing, dedicating more and more space to describe the bits and pieces of the project (which I read somewhere was ported to C from ML). All in all it's a good reference book, but it's really confusing if this is your primary text. I'd recommend it as a secondary textbook. And I wouldn't recommend tiger for a compiler project, better use decaf (search google).

Rating:
Summary: Spend hours trying to understand this book!
Review: This book is really bad. We used it at Tech for one semester and the next they switched to another book. It is very complex and difficult to read. It rambles on for pages with topics that could be understood with a paragraph and an example.

Rating:
Summary: Excellent theory book
Review: This is a very good book on modern compilers. It covers some crucial tochniques that the Dragon Book does not, such as pipelining, handling superscalar and RISC processors, tail recursion, polymorphism and OO languages, etc. These things were unknown when the Dragon Book was written. Its treatment of compiler basics is not as good as that in the Dragon Book, but the additional material makes it about as valuable. NOTE: This is a theory book, not a cookbook. You are not buying code, you are buying a reference you can use when writing code. You will still have to do your own thinking and your own coding.