Modern Compiler Implementation in Java

by Andrew W. Appel

Book Overview

This textbook describes all phases of a compiler: lexical analysis, parsing, abstract syntax, semantic actions, intermediate representations, instruction selection via tree matching, dataflow... This description may be from another edition of this product.

• Format: Hardcover
• Language: English
• ISBN: 052182060X
• ISBN13: 9780521820608
• Release Date: October 2002
• Publisher: Cambridge University Press
• Length: 512 Pages
• Weight: 2.35 lbs.
• Dimensions: 1.3" x 8.2" x 10.1"

Customer Reviews

Average compiler text with advanced topics

This book is not as bad as some reviewers say. But if you expect to get a cookbook how to write your own compiler in Java (what the title could suggest), you would be a bit disappointed. The advantage is that this book covers also advanced topics such as register allocation, frame layouting and flow analysis. There are a lot of books which covers simple parsing and codegeneration only, but this book goes futher. The disadvantage is that Java code snippets of the compiler which are printed in the book is not of great quality (e.g. public member variables, instead of getter/setters and private vars). Maybe the code of quality is compromised to reduce the size of the code in the book. If you're looking for only a theoretical book, buy 'Engeering a compiler (Cooper et al)'. If you're looking for a pure practical book buy 'Progamming Language Processors in Java: compilers and interpreters' (David Watt). This book is just between these 2 books: theoretical plus some practical sauce.

Finally, a compiler book that makes sense to me.

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.

One of my favorite book

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.

It's the only *modern* compiler textbook out there

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.

Great Reference!

I helped debug this book in Appel's Compilers Class at Princeton University, and I strongly recommend it. Appel has scoured the literature to summarize every compiler trick out there, presenting the algorithms concisely and clearly. If you've ever tried to read a compiler paper directly, mathematical notation and all, you'll appreciate this! This book may not replace the infamous "dragon book" -- but it's a whole lot easier to code from.