Compiler Construction: Principles and Practice

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.

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.

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 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.

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!