Customer Reviews

Compilers: Principles, Techniques, and Tools

5 star:		(29)
4 star:		(10)
3 star:		(10)
2 star:		(5)
1 star:		(1)

 

 

During each compiler stage (lexical analysis, syntax analysis, translation, type checking, translation, code generation, and code optimization) multiple methods, strategies, and algorithms are presented. This comprehensive book examines items that are unique to the various languages presented (Fortran, C, and Pascal); there are even sections on dealing with estimation of types (10.12) and symbolic debugging of optimized code (10.13). Wow! The exercises are thorough, challenging, and thought provoking. Examples are interleaved with the discussion and algorithms. There is an excellent set of historical and bibliographic information at the end of each chapter. The use of automated tools such as lex, yacc, and compiler-generators is discussed throughout the text. This is an advanced book, however a good understanding of compilers can be obtained without understanding the details of every algorithm.

Once again, I want to point out the title of the book: "Principles, Techniques and Tools".
I think there are two kinds of compilers books available today: "Principles and Theory centered" ones and "Modern Compilers design and implementation" ones.
One might wonder what's the difference between the two.

The former kind is more suited for a course on theoretical aspects that lay the foundation of compiler construction. DFAs, NFAs and Regular expression along with relations and equivalence between the them; FSAs minimizations; grammars and Push-down FSAs in details, ambiguities and and how to cope with them; and so on.
This is what I mean for "theoretical aspects". And these topics are covered in great details in this book. Almost the same details they (the authors) placed on writing a more specific book as "Introduction to Automata Theory ...".
Same situation applies to principles on more application- oriented topics. Take the example of LR parsing. You can face the topic from a more theoretical side, dealing with details on bottom up parsing (still, it implies an in-depth knowledge of grammars theory), handles and (viable) prefixes, SLR or canonical LR or LALR parsers and techniques for the relative tables construction by hands (and for this, add a detailed and solid knowledge of Push-down FSAs along with grammars). By hands, at least, if principles are what matter in your course.
If you expect to find these topics (with this depth) in a book of the other kind, you might get mislead. As I did when I still had not clear this distinction, before I took the course.

The latter kind of books is more suited for a more pragmatic course. One where real, "modern" compilers are at hands, and probably written as homeworks. In this case, time being always limited in a university course, one (the instructor) will likely have to give up with those theoretical aspects (or just mention them) and focus on coding techniques and modern compiler studying. But ... perhaps, for these purposes books like Grune's "Modern Compiler Design", or Pittman's "Art of Compiler Design, The: Theory and Practice" or, at some degrees, Muchnick's "Advanced Compiler Design and Implementation" will be more suited.
Back to the LR parsing example, more pragmatic compilers design courses will (for time constraints) just have a glance on principles and spend a considerable time learning YACC. To do both things you would have to take a course on YACC alone (it requires time to exploit all of its advanced features, you can be sure of this).

All this said, once again: which is the best book ? The one that best fits your needs. And in fact, my needs were those of my course, which was completely centered on theoretical aspects. And for this course, the Dragon book (as it is better known since its cover) proved to be perfect, definitely no matter it was published on 1986: FSAs and grammars and their theory is (for all practical purposes) still the same since even before then.

This is a comprehensive and easy to understand text. It covers all the fundamental stages of compiler design, with plenty of explanation (both practical and theoretical). It doesn't exhaustively cover every conceivable topic, but it does leave you with a good taste of what's involved. Of course, it is not a book for beginning programmers, and there are very few code examples. Judging by the comments of some reviewers, I would suspect that they gave poor reviews because they lacked the prerequisite background (familiarity with a good HLL like C, data structures, mathematical background etc). As with any 'advanced' topic in computer science, there is quite a lot expected from you. Upon first reading, some topics occasionally seem overwhelming. Welcome to Earth. This is where your library card comes in. Do a little research and then come back to this text; you'll find that it is well organized and extremely clear. If you want a cookbook this book isn't for you. If you want a solid understanding of compiler fundamentals then this book is your best bet.

A great book, which covers all you need to write a decent optimizing compiler.

However, it's dated. It doesn't cover single static assignment, advanced control-/data-flow techniques, or instruction scheduling. It predominantly focuses on flat quads or binary tree representations, and a good third of the book covers the theory of scanning and parsing, which nowadays are almost exclusively handled by scanner/parser generators.

I'd instead recomend "Advanced Compiler Design and Implementation" by Muchnick, or "Engineering a Compiler" by Cooper

Chapters 5-11 of the forthcoming second edition of the Dragon book are available online at the publisher's website.

For those interested in the more general and theoretical principles behind compilers, this book can still serve as a good introduction in that regard. More modern treatments are available to those who need more information on modern developments in compilers, such as optimization, partial evaluation, etc. The book covers lexical analysis, parsing techniques, syntax-directed translation, static semantic checking, type checking, unification, target code generation, and compiler code optimization. All of these are discussed in great detail, the C language is chosen to write the compiler coding, and numerous exercises are put at the end of the each chapter. The reader can also gain an insight into the historical origins of the subject.

This book, in its time, was a classic. When it was published
it was one of the best books available on compiler design.
Like the compiler design books of its time, this book has an
academic bent. Compared to later works, it is overly formal,
using obscure notation which is not really needed.

This book may have laid the foundation, but it has been replaced
by better books. In particular, "Advanced Compiler Design
and Implementation" by Steven S. Muchnick and "Optimizing

Compilers for Modern Architectures" by Randy Allen, Ken Kennedy.
The introductory compiler books by Grune et al or Appel may
be useful for those who without compiler design experience.
In all cases these book concentrate on real compiler
implementation issues and do not get mired down in formal
notation.

I dunno how many people like me tried to read this book.

* I am not very math oriented.
* I dont have a CS degree.
* I am generally a dumb dude.

I am reading this purely for fun. I had a lot of trouble just understand the concept of CFG's. Since the text was dense, I had to look up other resources (web) to clarify and understand whats described.

What I dicovered was that book contained the best and shortest description and explanation of the concepts. In other words highly optimized. Every day read a couple of pages and every day this book fills me with new ideas and joy!

Conclusion: The text is terse. For an average guy like me, it is a little hard on the poor brain. With a little effort, hard work and patience this is proably the best book for concepts.

Santy

"Compilers: Principles, Techniques, and Tools" (Aho, Sethi, Ullman) is a very comprehensive, detailed description of compiler technologies. Because of its great detail, you may have to take a different approach to reading this book than you would a normal programming book.

My first tip is to read the book more than once. With this in mind, it is useful to do your first reading in segments (i.e. not every page of the book). My tip is to follow the example lesson plan provided in the front of the book. It will direct you to chapters that would be used in a Compiler class. Once you have done this lesson plan, you can re-read the book from start to finish to get those extra details hidden within.

If you try to read this book in its entirety on your first try--intending to successfully grasp all of its contents--this will be difficult. My recommendations above will help those out there that want to learn about this technology, but haven't had experience with compilers before to read this book in a way that lets you absorb the great amount of information.

Other than the reading approach, a good mathematical background (algebra II and above) is recommended for grasping some of the concepts mentioned within. Also, a basic knowledge of common Computer Science concepts (binary, assembly, stack, etc.) as well as a familiarity with using compilers and multiple programming languages is very useful.

Although the book may seem overwhelming at times, with careful consideration and time spent following these guidelines, it can be done. I'm only 15 years old and have started embedding some of these concepts into my applications.

Good luck to all who read this book and happy programming!

I was sad to read the negative comments on this book because they could give people who are not familiar with the topic the impression that this is not a great book.

This book is still considered the standard text on compiler design, even though it is now 15 years old. It is not, however, a book for the weekend programmer or hobbyist and that could be what disappointed some of the negative reviewers. This is a demanding book but rewards the persistent reader with a thorough grounding in the theory and practice of this complex subject.

If you are in the profession of compiler design or a serious student of the subject, assimilating the content of this book is a prerequisite. I work on a team that produces one of the most popular professional C++ compilers. When I joined the team, I asked around for advice on what books to read. The most common response: "If you haven't read the 'dragon book' you better start with that."