Rating: 
Summary: An absolute waste of paper
Review: Andrew Appel's textbook (Modern Compiler implementation in Java) has been prescribed as a Course Textbook. Given a choice, I strongly recommend to take it from the library or any place where you can get it for free for one semester/quarter. This book is not worth the money and is an absolute waste. Not only does it not teach you anything about compilers, but if you already know something, then it serves to confuse you.
The author has tried to explain things using an example and "steps" through the process of writing a compiler. So in that sense, if you are just looking to write a compiler and be done with it whether you understand it or not, then this book might be considered OK, though not good in any sense.
No theory about compilers is explained and the author seems to be talking to himself throughout the text.
Rating: 
Summary: Wonderful content marred by confusing samples and typography
Review: As many others have noted, the "Dragon Book" by Aho, Sethi, and Ullman feels outdated today. The early chapters on regular expressions and grammars are still top-notch, but the latter chapters on register allocation and optimization are in desperate need of updating.Appel's book was a wonderful update on the state of the compiler world, with RISC and garbage-collection issues brought to the fore -- while still discussing aspects of the still important CISC processors out there. Its chapters on Static Single Assignment form (SSA) and register allocation were clear and the pseudo-code included in the text was sufficient to get me past a stage on a personal project where I'd been stuck for quite some time. The early chapters on lexical analysis and parsing are on the skimpy side, but rightfully so since these areas are mature (and the avid reader can always read "Dragon Book" if necessary). The progression through abstract syntax to register allocation leads the reader into what eventually becomes the final compiler output. The introduction of functional languages was of theoretical interest, while the chapters on polymorphism and loop optimisations were filled with interesting tidbits. Unfortunately, the code examples can sometimes be very confusing. Appel uses many similarly named namespaces and classes, and his justifications for doing so felt weak. This confusion was worsened by several editing mistakes and missing diagrams. I also wish the typography had been more consistent; sometimes, code examples are in monospaced "computer" font while sometimes they are in bold serifed font, adding to the confusion. Nevertheless, this is one of my favorite compiler books. I've been using it so intensively in my project that I've almost broken the spine of the book -- and may need to purchase another copy for archiving.
Rating: 
Summary: A reasonable undergraduate compilers text
Review: I find this to be one of the better choices currently available as a textbook for an undergraduate compilers course. As it promises, it presents a modern view of compiler construction, and many difficult new techniques are covered fairly clearly. The book is particularly appealing because it provides a fairly explicit cookbook for how to construct a compiler from start to finish, and the different parts of the book fit together much better than in, say, the Dragon Book. It also contains good material on implementing more advanced language features. The book has a number of weaknesses that have been touched on by other reviewers. The number of errors in the text is larger than it should be. The explanations of certain topics are weak: LR parsing and dataflow equations come to mind. In general, topics are covered in only slightly more depth than a class lecture on the topic would reach. This makes the book less useful as a reference after the course ends.
Rating:
Summary: It's the only *modern* compiler textbook out there
Review: I have taught a graduate compiler class out of this text, and that worked out very well. But I would not recommend this text for an introductory undergraduate compiler course without an automata theory and programming languages prerequisite. Students loved the sophisticated compiler design built up in the text, but suffered through overly concise and sometimes incomplete explanations (I think many of the "errors" reported are really omitted details). Much of that can be made up for in lectures, but it makes the text hard going on its own. So why is this an important text to consider? The Dragon book is out of date on compiler optimization, and good optimization books (I like Morgan best, Muchnick second) really can not serve as "big picture" compiler texts -- they are good reference books. Optimization is where it's at these days, and this is the only textbook that easily builds to that level. Don't be fooled by the Java edition. The compiler design reflects the ML/Haskell school of data abstraction, and will seem odd to Java programmers. But that's a good experience in itself.
Rating: 
Summary: Finally, a compiler book that makes sense to me.
Review: I love the chapter layout and the explanations of compiler concepts contained in this book. The language is a bit dry and somewhat mathematical at times. It may not be a perfect fit for every one. However, it was just what I needed to help me understand graph coloring and flow analysis. I like that he uses pseudo-code adaptable to many different languages in different places in the book. Originally, I bought this book strictly for its explanations of register allocation and liveness analysis. Those chapters were good, but flipping through, I can see that the remaining chapters may clear up other questions I may have as I become a more advanced compiler writer. Overall, I am glad I bought this book. I own several rather academic books on compilers as well as some more practical books such as Writing Compilers and Interpreters by Ronald Mak and A Targetable C Compiler: Design and Implementation by Fraser/Hanson. Each has its strengths and weaknesses. Overall, I like this Appel book for its good examples of difficult to understand concepts.
Rating:
Summary: ALL HOPE ABANDON, YE WHO ENTER HERE.
Review: I used this as one of three textbooks for an undergraduate compiler class I taught at MIT (the other two were the Dragon book and Muchnick). This one was universally considered the least useful. We used it principally as a guide to writing the lexical analyzer and parser, since our class also used JLex and CUP.
After that initial stage, it walks through the construction of a compiler, but without much discussion of the range of design choices avaliable. The material on optimization is uninspiring.
Rating: 
Summary: Vague at Best.
Review: I've read through several compiler texts over the past few months as I work away on a compilers project for school. I would have to say that this text, the required textbook for my class, is not in the least bit useful. Most of the material in the book is not covered in any real depth. If you are looking for a useful book on compilers, I would recomend "Compilers" by Aho, Sethi and Ulman (the Dragon Book), or "Crafting a Compiler" by Fisher and LeBlanc. Both books are much more thorough. The Fisher's book is also quite easy to read and understand. Appel's books only saving grace is the occasional modern view of things.
Rating:
Summary: One of my favorite book
Review: It's so sad that the rating of this book is this bad since I love this book so much. This book might have some weaknesses but I believe that this book is well worth getting. As far as I know, there're few compiler *textbooks*, other than this, that tells how to implement various modern PL concepts. As one guy said, the parsing algorithm stuffs are not any more an essential part of compiler course and modern compiler implementation should focus on how to implement modern programming concepts. After all, compiler is a *language* processor, *language* provides us *abtractions*, and we should focus mostly on how to implement those abstraction mechanisms in a compiler course, I believe. I agree that this book alone may not be sufficient for a complete introduction to the compiler writing (Dragon book and Muchnick's could be used together) but this book surely has its own benefits. I think there's a subtle difference between the viewpoints of the PL guys and compiler guys. E.g. compiler guys might be interested in how to speep things up and PL guys might be interested in how to invent a new abstraction mechanism and implement it. I believe this is the best textbook, known to me, with the latter viewpoint. Postscript to the guy who said Prof. Appel does not know OOP:
This book uses the Interpreter pattern where Interpreter pattern is just an oo-counterpart of the recursive data type definition in functional programming.
Rating:
Summary: Finally, a compiler book that makes sense to me.
Review: This book does show you how a compiler is implemented, literally. The author has a compiler already coded which he breaks down piece by piece and shows you how the pieces work. Unfortunately, instead of only giving you what you need to know for a specific piece, alot of future material is added too soon because it's already in the code. What would've been good is to trim out that stuff and give examples of code that wasn't part of the complete compiler but explained a specific point and only that point. Too much time is spent explaining pre-existing code that implements the modules in a ready-built compiler, and not enough time is spent describing what each module in a compiler is supposed to do and how you'd do it yourself or alternative ways of implementing functionality. If only there was a compiler book that was halfway between this one and the Dragon book...
Rating:
Summary: How someone else's compiler works piece by piece...
Review: This book does show you how a compiler is implemented, literally. The author has a compiler already coded which he breaks down piece by piece and shows you how the pieces work. Unfortunately, instead of only giving you what you need to know for a specific piece, alot of future material is added too soon because it's already in the code. What would've been good is to trim out that stuff and give examples of code that wasn't part of the complete compiler but explained a specific point and only that point. Too much time is spent explaining pre-existing code that implements the modules in a ready-built compiler, and not enough time is spent describing what each module in a compiler is supposed to do and how you'd do it yourself or alternative ways of implementing functionality. If only there was a compiler book that was halfway between this one and the Dragon book...
| 
