Rating: 
Summary: Nice book for self-paced hands-on approach
Review: Compiler design is a fascinating, and even more, essential subject in computer science. No one getting into software design shouldn't know how compilers work. Before reading this book (which I'm currently reading in my spare time) to me, compilers were black boxes, put your source in one end, it dissapears into the machine, and it spits out an object file.This well organised book assumes a fundamental knowledge of C data structures and discrete math. I'd have to say thought that the description of finite automation was a bit unusual, to me. I'm already fluent in regular expressions thanks to my (nearly) full bookshelf of O'reilly titles, and found the mathematical approach a bit less pragmatic than what I'm used to (Oh yeah, if you're going to get into some heavy lex scanning, get 'Mastering Regular Expressions' by O'reilly). But, by the time I was finished with the chapter on scanners, I wrote a little C preprocessor, first with a hand-written DFA, then using flex. The book doesn't discuss many of the caveats of using (f)?lex, but maybe the problems I ran into were platform specific. (my Linux/GCC/flex proggie would throw a segmentation fault if, in my main source file, I declared "extern char* yytext" rather than using (even more incorrect ,for my settings) "extern char yytext[];", I finally ended up pasting my main source file into the bottom of lex template) But that's beyond the scope of this book, I guess. So, anyway, if you're as interested in compilers as I am, this book is a great beginning, and will serve as a solid stepping stone to more advanced texts. I'm on the lookout for an intermediate text on interpreted language design (my primary interest in the realm of compilers) now.
Rating: 
Summary: An excellent introductory text
Review: Compiler design is a fascinating, and even more, essential subject in computer science. No one getting into software design shouldn't know how compilers work. Before reading this book (which I'm currently reading in my spare time) to me, compilers were black boxes, put your source in one end, it dissapears into the machine, and it spits out an object file. This well organised book assumes a fundamental knowledge of C data structures and discrete math. I'd have to say thought that the description of finite automation was a bit unusual, to me. I'm already fluent in regular expressions thanks to my (nearly) full bookshelf of O'reilly titles, and found the mathematical approach a bit less pragmatic than what I'm used to (Oh yeah, if you're going to get into some heavy lex scanning, get 'Mastering Regular Expressions' by O'reilly). But, by the time I was finished with the chapter on scanners, I wrote a little C preprocessor, first with a hand-written DFA, then using flex. The book doesn't discuss many of the caveats of using (f)?lex, but maybe the problems I ran into were platform specific. (my Linux/GCC/flex proggie would throw a segmentation fault if, in my main source file, I declared "extern char* yytext" rather than using (even more incorrect ,for my settings) "extern char yytext[];", I finally ended up pasting my main source file into the bottom of lex template) But that's beyond the scope of this book, I guess. So, anyway, if you're as interested in compilers as I am, this book is a great beginning, and will serve as a solid stepping stone to more advanced texts. I'm on the lookout for an intermediate text on interpreted language design (my primary interest in the realm of compilers) now.
Rating:
Summary: Best Organized for Me
Review: First, I do not understand the compile theory completely. I only familiar with lexical and syntax parse (what is needed in pratical in most cases). I have read and have been reading several books on compile theory. Some of them are too dull, listing too many definitions before a little bit example. Some of them are disorganized, the former part often relies on the latter one. But this book has no such flaws. That's all.
Rating:
Summary: Good text book. Standard text at National University
Review: Good text book. Standard textbook for National University. This means that several professors have reviewed and used this book for their classesa and wish to retain it. More thoughts and few pictures! -- Christos Kolonis, MSSE Associate Professor, National University
Rating:
Summary: Only Complete coverage if used in conjunction with Dragon!
Review: 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.
Rating:
Summary: I taught from this book
Review: 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.
Rating:
Summary: Only Complete coverage if used in conjunction with Dragon!
Review: This is an excellent text. Louden's Compilers book is far better than his silly excuse for a Programming Languages book. Combined with Aho, et. al. "Dragon Book" you will have sufficient coverage of introductory Compiler design techniques. The organization in this book is it's best feature. It's pretty hard to get lost, Louden get's an A+ in this respect. The only reason why 4 stars instead of 5 is due to the lack of coverage in certain areas (thus the reason to also get the "Dragon").
Rating:
Summary: The best introductory text for compiler design
Review: 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!
Rating:
Summary: Nice book for self-paced hands-on approach
Review: 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.
Rating: 
Summary: a few serious flaws
Review: While overall this is an okay book, I feel there are several places where it was made overly complicated. All of the algorithms are explained by means of very poor psuedo code. After several hours of reading over the psuedo code for follow sets I still had no idea what was going on. My professor however was able to explain the concept to me in a few minutes. I think this book would have been far better if he also presented the algorithms in english or at least commented the psuedo code.
|
