Customer Reviews

Compilers: Principles, Techniques, and Tools (2nd Edition)

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

 

 

I spent some serious quality time with the first edition (the "red dragon book"), in three main episodes over the past dozen years: 1) undergraduate compilers class, 2) industry project, and 3) parser generator implementation. During all three episodes, I was disappointed in various ways, though there is no denying that the book contains a wealth of information. As an undergraduate, I found the book somewhat impenetrable. When in industry, I found the book too abstract. When implementing a parser generator, I discovered that the book excludes important research results with regard to LR parser generation. It is the last disappointment that I will focus on.

The book presents parser generation in layers of increasing complexity, from SLR to LR to LALR, where LALR is presented as the penultimate algorithm, though LALR parsers can only handle a subset of the grammars that LR can handle. The justification for this is that the original Knuth LR algorithm is intractable for large grammars. However, an efficient, fully correct, approach for LR parser generation was published in 1977, and on top of that it appears easier to implement than efficient LALR parser generation! The red dragon book's original authors simply cannot have been unaware of this research result, but I suspect that they elected to warm over the "green dragon book" (published in 1977) rather than incorporate the state of the art as of 1986 into the "red dragon book". Now here we are another 20 years later, and as near as I can tell from reading through available online information, the "purple dragon book" is perpetuating this omission. The result of the red dragon book is that we have an entire generation of computer scientists who have been mislead to think that LALR is somehow superior to LR, and the purple dragon book is setting things up for yet another generation to be mislead.

This book has the reputation as being THE book on compilers. I'll grant that. It covers everything and the kitchen sink, at a theoretical level. This is NOT the book on implementation details. Without prior exposure to the basic principals and problems in compiler implemenation, it can be difficult to see why the theory, as presented, is relavent. Why is left recursion bad? What good are handles? How is the type system significant? How do symbol tables relate to scoping? This stuffs in there, but if one is not expecting it, one won't appreciate the terse presentation. But that's the kind of learner I am, I have to know why something is relavent before I get it. So, I don't recommend this book as a first book on languages and compilers.

I wrote a complete complier as a semester project 30 years ago using the Green Dragon book. (I had written a parser generator the semester before, otherwise I could never have done a compiler on my own in one semester.) Doing that resulted in a tremendous sense of accomplishment and a feeling that I could do anything with computers. A feeling that has remained with me since then.

If you are not a computer science major and are just looking to implement a simple compiler, perhaps there would be books with less theory that might still get you to produce a compiler and that would be easier.

On the other hand, if you are a computer science major (or several related fields), your CS knowledge will be greatly enhanced by writing a compiler. And this book or some future edition of this book should be your guide.

To the people who mention some of the newer books that cover a lot of the newer techniques and technologies, I say, it doesn't matter to most people. Most people will only write a fairly simple compiler. Unless you are going to work for Microsoft developing the next version of Visual Studio, you don't really need most of those developments. Compiler construction is complex, and if you're learning about RISC, you're probably not learning enough about LALR. Both will be useful to know, but I think it's reasonable to not burden a compiler class with too advanced topics.

I read the first release of this book while studying for my degree almost 20 years ago. Having the second edition of this classic text augmented with modern techniques introduced in the meantime is thus almost a privilege for me :)

Even though the book is pretty academic in its approach and writing style (at least compared to other material I have to digest) and covers material that not many of us use on a daily basis, it's a great brain exercise after daily menial tasks.

This book is famous, and when I told people 20 years my senior that I was in compilers and I was using the dragon book, they knew the book. There are probably some changes between editions between now and then, but the fundamentals of compiler design has changed little.

And when it comes to be basics, reading this book can be more like slogging. The information is there, but it isn't quiet clear. Some topics have examples that do most of the explaining, while other topics lack a nice example that would explain it.

Aho, Ullman et. al's "Compilers" is a fantastic book and well worth studying for all computer programmers - implementing a compiler compiler will yield tangental benefits to anyone who writes programs for a living or for fun.

However, the Amazon Kindle edition of this book is *awful*. First and foremost, I discovered at least one error in an algorithm that is not present in the standard edition that causes the book's proposed algorithms to be incorrect (in this case, it was algorithm 4.31 - in step 1, you should compute FIRST(alpha), not FIRST(A).)

On top of that, there are spacing issues and font issues throughout the book. It appears that in many places where the standard edition had a word separated across lines, the Kindle edition merely has that word split in two with a space between its halves. Worse, the font choice used to typeset algorithms doesn't easily distinguish many greek lowercase letters from their modern English equivalents, the result being that it is fiendishly difficult to understand some algorithms (the book uses greek letters to indicate a 'sentential form', so they appear a *lot* and tend to be right next to their modern equivalents.)

In other words, I would give Compilers (the Standard edition) a 5/5 (or maybe a 4/5 - it could stand to use a bit more real-world code), but this Kindle edition is rubbish and you SHOULD NOT BUY.

Any serious computer scientist should at least read this book - if not own it. It covers all different aspects of a compiler and even more in relatively small space.

It is not a book on how to build the best compiler or what are the best optimizations for a specific architecture. It is a really good introduction in the black art of compiler development. After reading it, you will understand a bit better how compiler writers think and how their brainchild works under the covers. You will also be able to create your own rudimentary compiler.

However, it is not a guide on how to make a state-of-the-art compiler or teach you how a specific implementation came to be.

Highly recommended for people that have their first experience with compilers, both in undergraduate and early graduate levels.

I'm a computer engineering student and I purchased the book for my programming languages and compilers course. At present I still haven't completed the course, but I've already found this book pretty useful so far. The concepts are clearly and well explained, so that I could better understand some points that I found rather obscure during the lessons. It's being of great help, so I'm very satisfied of this purchase.

Simply put, the "Dragon Book" has not proven to be an effective educational tool for me. Our compilers class requires me to learn a fair amount of material directly from the text and it is quite inscrutable at times. I'm a straight-A student, have some years of professional coding, and usually pick up programming concepts quickly, but this book just makes my eyes glaze right over.

I feel like new concepts are introduced with insufficient examples, after which they are referenced with no further explanation. This means that the book becomes progressively more difficult to follow as you go along if you have not been keeping up with their specific terminology.

In order to save space, the text also frequently uses examples that refer to other pages, requiring you to flip back and forth constantly to follow along.

To add insult to injury, only a fraction of the contained material is relevant when working with modern compiler compilers. It would be much easier to get your hands dirty with a more simple and direct text before trying to come here and understand all the underlying theory.

In short, while thorough, the Dragon Book really needs some kind of primer that we can use before jumping in. Objective analysis aside, this book actually makes me very frustrated and angry to try and read. I would never recommend it to any beginning compiler student, ever.

This was the best and most understandable book for development of the skills needed for compiler development. It was also useful for me to understand the use of data structures for the need as well. Buy this book.