Customer Reviews

Modern Compiler Implementation in Java

5 star:		(3)
4 star:		(4)
3 star:		(2)
2 star:		(5)
1 star:		(9)

 

 

I held the accursed object with both hands and examined it closely. It felt small and weak There was a change after I finished the exam. Suddenly what had once seemed an insurmountable obstacle had been reduced to a collection of molecules. Something small and without worth, a mere shadow of the former imposition. Yes, I held a mere object in my hands. Something, which would no longer hold, power over me. I was suddenly struck by a tremendous urge to exert my power over it. I envisioned myself beating the book against tress and concrete benches, hurling it baseball-pitch style at brick walls, hitting it with a ten-pound sledge at full tilt, drop-kicking it off of high buildings, tearing it cover-from-cover with my bare hands.
But most importantly, most eerily satisfying, were the visions of setting the terrible book on its side, allowing the pages to ruffle gently under the cover,-and igniting a book of matches underneath the pages. I longed to see it burn. I wanted to, through my own volition and physical power, reduce it. O book most foul, into the optimally entropic form, then relieve my bladder onto its smoldering ashes. I could think of nothing more satisfying.

I'm not entirely sure why I didn't, just then and there, outside the Wetherill Laboratory of Chemistry, satisfy my urges and just destroy the beast. Perhaps I'm not entirely certain that my travail with 'modern compiler imple- mentation in Java" is over. I won't be certain of that until I stand with a report card in hand. But the blind rage continues.

It sits on my shelf until then, forever staring at me with a bright red cover and insulting lower-case sans- serif typeface, the author's name 'Appel" an invocation of the original sin which lies within. Every time I see it there, I have feelings of hatred, angst, depression, and bitterness. I feel the bile rise in my throat and the heartburn of a dozen sleepless nights staring into its murky depths at the merest glance. The angrily pacing tiger on the front cover stands as a warning to all who would journey within of the dangers which await. Inside the front cover, scrawled in all capital letters in indelible black marker by a shaky hand, lie the words "ALL HOPE ABANDON, YE WHO ENTER HERE."

Apparently, the student who possessed it before me shares my enmity. It is truly a foul thing, an ancient, unknowable evil. By all rights and privileges, it should be written in virgin blood on human skin and bound with the tortured souls of those who dared to face it and lost. I know what must be done. It must be struck from the universe. It must be, for the good of all mankind, rendered forevermore unreadable, so it may not torment the others who, unprepared as I was four months ago, would even briefly consider themselves strong enough to face what lies within. Fools! None may face the tiger and win! Those who survive the course are never again the same person as before the course. Those who live to tell of their encounter with the book rarely talk about it, and do so in hushed tones, fearful of its horrid consequences. I cannot abide this world with the nowledge that it still exists.

Take thy interference graph from out my heart, and take thy intermediate representation from off my bookshelf.

TAKE THY INTERFERENCE GRAPH FROM OUT MY HEART, AND TAKE THY INTERMEDIATE REPRESENTATION FROM OFF MY BOOKSHELF.

quath the Tiger, 'Only if you passed.'

Patrick Fitzgerald, Senior, School of Science, Purdue University

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.

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...

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.

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.

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.

Considering the nature of the text, I find it most peculiar that Mr Appel doesn't own a java compiler. For if he did he surely would have found, and corrected, the teeming mass of errors that is his example java code throughout the book. After paying an exorbitant price in excess of NZ$100 for such a sadly dissapointing text, I can only recommend that Mr Appel check his example code with increased vigour in the future.

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!

Concise introduction to compile design. There are around 50 errors in this 500-page work. So be sure to check the errata list.

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.