Rating: 
Summary: Take it slowly
Review: "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!
Rating: 
Summary: The Dragon is the standard text but....
Review: "The Dragon" is the standard text on compiler theory and practices, and a must to have in your library if you are into compiler writing. It covers all what could be referred as the fundamentals of compiler engineering. When I first got my copy of it, late 1986 it soon became my number one reference, although I had most of the other compiler titles as well on my bookshelves. It completely covered my needs for a reference in those days, from parsing through global optimization.
But on the negative side. It can no longer be considered as a the complete reference as it used to be. Due to it's age, it is obviously missing totally on today's advanced topics, specially on native code optimization for the state of the art super-pipelined, super-scalar RISC architectures, and special issues concerning object oriented languages of today, and technologies like JIT compilation.
Rating:
Summary: This is THE compiler design text.
Review:
This is THE compiler design book. It's used in both undergraduate and graduate level computer engineering courses throughout the Western world. The immediate descendent of the classic Principles of Compiler Design by Aho and Ullman (the "Dragon Book"), it's 796 pages (hardback) of algorithms, diagrams, and code segments from (mostly) C and Pascal perspectives.
From the contents:
Chapter 1: Introduction to Compiling
Chapter 2: A Simple One-Pass Compiler
Chapter 3. Lexical Analysis
Chapter 4. Syntax Analysis
Chapter 5: Syntax-Directed Translation
Chapter 6: Type Checking
Chapter 7: Run-Time Environments
Chapter 8: Intermediate Code Generation
Chapter 9: Code Generation
Chapter 10: Code Optimization
Chapter 11: Want to Write a Compiler?
Chapter 12: A Look at Some Compilers
Appendix: A Compiler Project
It would be silly to recommend the text to students, because if you're taking collegiate or occupational compiler design, you'll be using it anyway. Instructors thinking of adopting the text can write me for specifics. This text is exlusively used by the Computer Science department at Ashland University
Rating:
Summary: AAAAHHHHAAAAHAHAHAAAA YEUS! YEUS YEUS!
Review: AAAAHHHHAAAAHAHAHAAAA Yes! Buy me! Buy me now you crazy guy! Ahhhahahhaha yeus, yeus. Everyone buy this and you will be a genius straight away. AAHAHAHHAHAAAHAHAHAHAHAHAHAH!
Rating:
Summary: Errors and obfuscation tarnish a definitive volume
Review: An essential reference on lexical analysis, syntax analysis, and code generation. I think it does a particularly wonderful job of introducing the formal details of finite state machines, grammars, and regular expressions. Sadly, errors and bad writing turn a joy into an ordeal.
I must deduct a star for the uneven and frequently tortured prose, varying from needless repetition and obfuscation to incomplete or incorrect explanations. This is very irritating in a work of this stature. A systemic problem with the book is the agonizing way the authors jump from high-level conceptual material to optimized-for-C implementations that discard all the structurally important elements of the chapter. I would have preferred more examples to illustrate the important concepts, with the C-optimizations omitted completely or at least left for a chapter on specific compiler implementations. There are few examples, and no answers provided for the chapter exercises (the exercises do not serve as additional examples). For example, "Which of the [five] grammars in exercise 2.2 are ambiguous?" Great question, but sadly the only clue in the chapter is to find two parse trees for one grammar, which is akin to chapter 2 of your elementary algebra book asking you to show that 2^6972593-1 is not prime by finding all the factors, then leaving you to guess whether or not you're right. Finally, there are numerous annoying errors in important material. For example, the sole example (p.172) in chapter 4 of an algorithm to turn an NFA into a grammar refers to an NFA in Fig. 3.23 and shows the resulting grammar, but careful inspection reveals that the grammar does not match the figure. In fact, figure 3.23 is a DFA, not an NFA, and the reference should be to Fig. 3.19, not 3.23. With a typical lack of further text to amplify the description of the algorithm, you'll be left wondering. It is high praise that the pearls in the book are worth the linguistic Oyster-shucking required to extract them. I would have given a lesser book 3 stars or worse. I wish Addison-Wesley would release an updated edition with the language cleaned up, and perhaps add a companion study guide with worked-out exercises. (Refers to the "March 1986, Reprinted with corrections" edition.)
Rating:
Summary: Still don't have the dragon book?
Review: Compiler design is a huge field. This book is a mirror of this field. The language is clear and the notation used by authors simplify understanding of the material.This book covers the main arguments relevant to compiler design:
1) Introduction to compiling
2) A simple one-pass compiler
3) Lexycal analysis
4) Syntax analysis
5) Syntax-directed translation
6) Type checking
7) Run-time Environments
8) Intermediate code generation
9) Code generation
10) Code optimization
plus other chapters with some hints and a programming project.
Some people said that this book is too "heavy" for an introductory course on compiler design. I think that all people reading a book of this entity should have at least a basic understanding of theoretical computer science, like finite state machines, grammars, and regular expressions. All the material is well organized.
The book starts with an introduction to compiler design, ideas and basic principles. Then it develops concepts in the rest of the book. Of course this is not an easy reading but this is not a problem of the book. Compiler theory is complex and this book try to explain it in the clearest way possible.
I like this book, after reading this you'll have all the skills to read more advanced books about this subject.
This book has always been considered the standard textbook about compiler design and I recommend it to all people interested in this wonderful subject. Highly recommended.
Rating:
Summary: so important for student in computer engineering to read it.
Review: congratulations, to that good work , but, i need answers to exercises of the book, it will help so much in understanding the book.
Rating:
Summary: Outstanding reference for C, Fortran, and Pascal compilers
Review: 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.
Rating:
Summary: Has done its job well
Review: 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.
Rating: 
Summary: This book is overrated.
Review: I don't know why this book got such good reviews - in my opinion it is simply NOT GOOD. I think it would be very helpful to people who already know some things about compilers - but if you come without background - and want to learn the material from the begining - Stay away. I haven't found a good book though...
| 
