Rating: 
Summary: Read this only if your discrete math is current
Review: I picked up this book because I like Java and it looked like it would be easy to understand but still concise. I was wrong. It is too terse. There is not enough explanation unless you already understand the subject and/or know a lot about set theory and notation. Unless your knowledge of discrete math is quite strong, I can't say that I recommend it. Instead, I would recommend Compilers, Principles, Techniques, and Tools by Alfred Aho. It is much easier to read than Mr. Appel's book.
Rating:
Summary: Not a good general compiler book
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: Poorly written
Review: I was drawn by the word "modern" in the title, but I found nothing useful in this book. The author summarizes to the point that the text contains too little information. Perhaps it's useful as the first two weeks of an intro to compiler design undergrad course, but entirely useless to anyone who actually wants to build a compiler. This book is not even a good supplement and is not worth the purchase price.
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: Please don't buy it!
Review: If you are a genius at writing compilers without ever needing a book, go ahead buy this book. If you want to learn something, please buy the book by Aho, Ullman and Sethi. I bought this book as part of course requirement and found it to be absolutely useless. The author doesn't care to explain anything and his programming exercises are the vaguest. Might be good if you have too much money to splurge.I think it is recommended in the universities because of the support tools JLex and CUP, the documentation of which is again more pathetic!
Rating:
Summary: Bad book
Review: It's awful. Nothing is described so that you can understand it.
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...
Rating:
Summary: Wow, what a mess
Review: This book seems hastily written, poorly edited and badly structured. Why did he pick Java? The author doesn't seem to understand Object Oriented design or patterns. The only point of the book, that I can see, is to scare people away from writing a compiler. There needs to be a good modern compiler book but this isn't it unfortunately.
| 
