Customer Reviews

Compiler Construction: Principles and Practice

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

 

 

This is an excellent basic book on compilers. Its strength is its strong practical approach combined with using YACC/LEX technology. It hand holds you through the development of a simple compiler. If I wanted to learn about compilers I would read this first. Its weakness is it is too narrow. There are plenty of features of languages that are not addressed but in passing. Its goal is to get a compiler built. For a compilers 101 class there is no better book.

I am studying for an M.S in software construction/engineering and this book was used for a compiler course. This review is written from my perspective as a student required to understand the information.

The language: The book is written in a clear and frindly "student"-friendly tone. It is actually like the author understands that I am a student and seeing this subject for the first time. The language is straightforward and not over-complex as I have seen it in other books used by instructors.

The structure: As a student i liked the content of the exercises a great deal. They kept focus on things which had been discussed earlier and this is always a good thing. I was able to keep pace with the reading and to follow the course at the same time - this is quite a feat (though maybe i just pulled myself together this time).

Content: It should be no problem for any instructor to plan the teaching using this book. The first chapters introduces compilers and the idea of simple text-recognition using regular expressions and finite automatas and moves on from there by introducing the BNF notation to write context-free grammers. Three chapters explains the essence of CF grammers and top-down and bottom-up parsers in a clear and friendly way.

The book uses the C language to show programming examples. Personally i had not problems but some might feel that the use of pseudo-code would be more appropiate. The book describes the construction of a simple compiler (written in C) for a simple programming language. C or pseudo-code - i like this way of doing a real example which is followed all the way through the book. The entire C source-code for this compiler is presented in the back of the book and used as reference through the chapters.

But - have you never seen the C programming language before, perhaps another book was better. It tries to keep focus on the clean understanding on the theory of parsers, semantic analysis and also later on code optimization. How to program compilers in an object oriented manner is not described, which i believe is okay since it would move the focus away from what is important here. There are books with focus on implementation of compilers in Java for instance, which could be a better choice if you are not a C programmer.

All in all - a good compiler book for students if the instructor teaches by the structure of the book and uses the exercises in class. But it can also be used for self-study.

Unlike some of the classic compiler texts (ex: Aho), this one has the benefit of coming with a hands-on project, in which you take a working codebase for a tiny language (without even functions in it) and turn it into a compiler for "C-", a fairly minimal subset of C (no pointers, for instance, but function calls and a number of other elements are added: it'll keep you busy). Personally I found it useful to have something concrete to work on while learning material that is otherwise quite abstract: actually writing a scanner and parser for a language makes it all soak in a lot better. Note that the target of the compiler you build is an interpreter, so you target an intermediate language rather than actual machine code. But that's interesting in itself, and you can always change it to crank out machine code if you've got a nice chunk of extra time on your hands.
The book is also shorter than Aho, which can either be good or bad, depending on what you're looking for. It reads fairly well, though there are a few typos that can be confusing, and it seems to be fairly rigorous in the topics it covers.

This is the best introductory compiler design textbook that I ever read. It is not as comprehensive as the old "Dragon Book" but it is the only book that contains a clear, concise and complete presentation of both top down and bottom up parsing algorithms. If you want to know what is the difference between the LR(0) and LR(1) algorithms or why it doesn't exist an LL(0) parser then this is the book for you.
It contains many very well chosen examples and what is most important a logic description and comparation of all the parsing algorithms. However the last subject covered by the book is the code generation. If you are interested in code otimization issues this book is not for you. The only problem is that it is a little bit expensive!

I was fortunate enough to use Dr. Louden's text in a compiler theory class several years ago. The text is an excellent introduction to a very challenging concept. I recently thumbed through the text again while selecting old textbooks to donate to the library. I admired how accessible the information remains years after my last compiler theory class. This is one text I remember fondly and will not be donated.

The text uses a toy language called "TINY." It is used to introduce the topics as the student builds a compiler for a more advanced language "C-minus." I found this approach very effective in making some very challenging subject matter approachable and even fun without skimping on information appropriate to a course at the introductory/intermediate level.

A negative to some is the fact that it requires fluency in C rather than Java. My opinion is that it is a mistake to use a language with a garbage collector for a compiler class.

This book is outstanding! The Dragon Book is way overhyped. I have tried again and again to follow the dragon book, and each time I found it too difficult. On the other hand, Louden's book has answered many questions that I had in a clear, concise manner! I love this book! I have also flipped through almost all other compiler/interpreter books on the market in various bookstores, but none of them compare. This is *THE* book on introductory compiler design. Other books you might want if interested in writing your own programming language/compiler are "Programming Language Pragmatics", "Lex and Yacc", "Java Virtual Machine Specification" and "Virtual Machine Design and Implementation in C/C++".

This is a fantastic book because Louden gives the theory behind how compilers and programming languages work, and then implements the theory with a simple programming language written for this book. This book, however, will take you some time and much study to complete.

This book explains the theory of compilers a whole lot better than the dragon book. From the standpoint of not knowing anything about compiler design, and having never taken any classes on the subject, this book was the most helpful that I came across. It really takes the time to explain everything (like a textbook should!).

This is the best compiler book I have read. I have gone through 4 different compiler books. All have clear problems. This one is totally different, it is easy to read and understand. Furthermore, it is full of examples and come with solution manual for instructors. IMHO, it is the most suitable textbook for an introductory course in compilers.

I rate Compiler Construction: Principles and Practice to the same category as legendary Kernighan/Ritchie C Programming Language, Petzold's Programming Windows or Richter's Programming Server Side Applications for MS Windows 2000. This is one of the best books I have ever read.

Compiler construction is relatively hard topic with lot of theory needed to be understood before you can write even the most trivial compiler. Regular expressions, finite automata, BNF or attribute grammars are just few things you need to know and known them very well before you can write you own compiler.

Many books paying too much attention to theory, but theory itself without many practical examples is nearly useless - especially if you are new in this field. You need examples, very good, thoroughly explained examples and even better having source code where theory is transformed into practice. This is something that the book does and does it very well.
Every topic is covered by such examples and at the end of every chapter there is practical implementation of scanner, parser (recursive descent), semantic analyzer and code generator in 'raw' C, using very simple (but useful) language called TINY.

Another great thing is how the book is organized. First chapter introduces major steps in compiler design like scanning, parsing, semantic, runtime environment, code generation and subsequent chapters dealing with these topics. That's great, because after finishing each chapter you can write your own scanner (chapter 2), top down parser (chapter 4), bottom up parser (chapter 5), semantic analyzer (chapter 6) and runtime environment and code generation (last 2 chapters).

Probably the best 'proof' how great this book is, is the fact that I as absolute beginner in compiler construction (I work professionally as developer for 10 years), was able to write down my own scanner, parser (LL(1), LR(1), and also LALR(1)), semantic analyzer and code generator to 0x86 MASM ASSEMBLER in 'raw' C#, without using of any automatic generators like Lex or Yacc for simple C- language presented in the book (language has global and local variables, procedures, simple arrays and strings).

Compiler Construction: Principles and Practice is the best book for everyone who has no previous experience with compiler construction. Book doesn't cover all advanced topics but it's the best material for those ones who are new in this field. After finishing book you will have enough theoretical and practical experiences to move to more advanced books (but also much more difficult to grasp) like famous Dragon book.