Customer Reviews

Modern Compiler Design

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

 

 

I bought this book as an introduction to Compiler Design and to that end I have found it quite useful. The material is dense, so expect to have to re-read chapters quite often. Also, I have found it necessary to supplement this book with additional resources to fully understand what Grune is attempting to explain, particularly with chapter 3, which covers attribute grammars. The book's english can be poor sometimes so expect to have to back-track over convulted sentences. Overall, however, this book succeeds in being useful as an introduction to the theory. The authors skip implementation details, so if you are expecting to be able to actually write a compiler when you are done, you are going to be needing additional sources.

Pros: 1)great introduction to theory and maintains enough detail in each section to keep you interested. 2) Book is organized well. Each chapter represents the next step in compiler design. 3) This book covers theory, not implementation...it does not bind itself to one particular language

Cons: 1) Expect to check-out or buy additional reading to supplement this book. 2) The english often leaves something to be desired. 3) The excercises at the end of each chapter were obviously just "thrown-in" at the end. They are quite poor.

This is really an excellent book that proves that a computer science text can have huge scope and be rigorous yet still do a good job of teaching and presenting its topics. Well written and laid-out. I would recommend it to anyone doing a course in compilers, provided you know the relevant chapters to choose to read (it goes way beyond the scope of an intro course) and any more advanced course. This book was actually recommended to over the "dragon book". It is more up-to-date and relevant.

Yes, this is a good text about compilers, mainly about theory. It has good insights into the area of compiler design, and it approaches many topics with ideas that aren't common in compiler books. However, many of these topics are only touched upon, with no depth, requiring you to look for other references.

Other very good feature of the book is covering compilation of languages from other paradigms. Most compiler books are geared towards mainstream imperative and object-oriented languages. This one has chapters on compilation of functional, logic and parallel programming languages as well. There is ample evidence that declarative programming paradigms in general, and functional programming in particular, are becoming ever more important in the computing industry, and this trend should go on. After all, throughout all the history of computing, the trend was always to go for more abstraction and less implementation details. So it's important to take contact with other paradigms.

Ok, so it's good in general. But it is incredibly boring to read, and I say that as someone who's very into compilers and own a lot of books on the subject. As another reviewer said, the text is often convoluted and hard to read; the organization is mostly good, but it tends to have big sections and big chapters (some very big chapters). Add to that the completely uninspiring layout and typography -- really, it's a very dull and bland look -- and I had serious trouble to read some chapters. Besides, the pseudo-code notation is really bad; better typography for the pseudo-code sections could help too.

To sum it up, if you only have to buy a single book on compilers, I would recommend against this one. Try "Engineering a Compiler" by Cooper & Torczon or wait the new edition of the dragon book by Aho et al. This one is good maybe as a second book, to get complementary insights and new ideas to explore about compilers, especially if you are researching on them, or looking for new ideas to escape from the mainstream.

But if there's ever another edition of this book, I would seriously recommend the authors to rethink its layout and typography to make it more attractive, get help with improving the text and break some chapters and sections in more maneageable pieces. Then it would be a really great book about compilers.

Overall, this is an excellent book for compilers. It covers a broad range of concepts. On think that I like is that the authors didn't take the very popular approach of "hey, let's write a small subset of Pascal". They actually only covers the concepts. So, this is not a beginner's book.

Algorithms are written in "english pseudo-code" and, altought I tought it'd be a good idea, it ended up being harder to read than the "usual pseudo-code" (like in the Dragon book).

If you are looking for a first book on this subject then this is not the book for you. Instead get the dragon book on Compiler Design published by Addison Wesley. This book is very good at filling in implementation details, but you may get lost if you don't know the buzz words already.

At the end of the book there is a good introduction to the theory parallel compiler design.

This is the textbook my class used for the compiler design class, and I must say it is excellent. Every technique is well expained, and its a lot easier to follow than "the dragon book". Best book I've read on the subject, it will get you from the start of languages design to a working interpreter in no time. You must have a solid base in coding and computer sciences tough, the book loose no time with petty issues.

Don't buy this book if you're looking for an introduction to compilers. I've purchased or borrowed 5 books on compiler design and this and Dragon are the least well written. This book does not suffer from the organization problems of the Dragon book, but it never provides simple overviews/explanations of a topic before diving head first into it. And it takes a heck of a lot of words for the authors to say anything. It is a chore to read. It is not the depth that is a problem. Intro to Algorithms and Advanced Compiler Design are as rigorous as this text, and yet I found them to be a lot more succinct and enjoyable.

If you have already read an introductory book on the topics it covers, you should be OK with this text if you can stand the high word to concept ratio. After trying to stay awake for the first few chapters and not understanding the treatment of lexing and transition tables at all, and after skimming through some of the later chapters, I can say for sure that I will only use this book when I can find no other reference. It does cover topics not found in any other text - which is the only reason I'm keeping it.

If you are starting out, then buy "Programming Language Processors in Java: Compilers and Interpreters" by Watt, Brown and Brown. It is far more appropriate for anyone not versed in basic compiler theory. Also, "Constructing Language Processors for Little Languages" is a pretty good introduction.

For advanced reading, I much prefer "Advanced Compiler Design".

I bought this book for a science fair project I was doing for school reasons. At first, the topic of compiler design scared me very much, and I had no idea what to do. The internet proved to have little material that was of much use, all the articles were scattered and mostly informal "hacks". That, or material that was way over my head with advanced calculus and other mathematics. When I bought this book, I did not anticipate it being so well suited to my current understanding. This book started at the very basics though, giving good explanations step by step. This was espically useful in the descriptions of parsers and code generators. This book was not too simple (or advanced) to be boring. This is not to say I read the book cover to cover, I left out about half of chapter 3 (which had a lot of fluffy material). The book is about half and half general compiler design and paradigm specific compilation. I skipped a lot of the extra material at the end (most of the logic and parallel compilation chapters). If you are looking for a book which holds a compiler within its pages and explains it line-by-line, this is not it. The book includes very little code (the self invented language they use is quite distasteful), but this does not matter very much. It takes a level of imagination to design a compiler anyway, but if you want a more implementation-oriented book perhaps you should look elsewhere. All in all, this book helped me a bunch, it's certainly worth a try.

This is a good compiler text, but my theory book winner is 'Engineering a compiler' by Cooper et al.

This is a very complete text. If you want to buy one theory book, buy this one because it simply covers all topics. This book also very nice written with a nice layout so a pleasure to read.

It starts very simple. Maybe some higher math would be a plus, but I think this book can also be read by novice people.

The real advantage of this book is that it also cover very advanced topics such as functional languages,. logic languages, parralelization, etc.

This book is disappointing. It is not a book on theory. It's not a book on implementation. It names a technique, add a shallow description and quickly pass to the next topic. This is the kind of book I would use for learning a couple of words about compilers to drop it later in a conversation. If this is just what you want, then it's OK.