6 of 6 people found the following review helpful
on 2 April 2002
I read most of this book while I was at College as one of my tasks was to build a compiler for the TIGER language, written in Java. The book includes examples and the building blocks of the TIGER language and tells you how to build your compiler, step by step. It also provides some foundations on compiler theory, starting on automata and regular expression theory.
It is hard reading at first and you might have to bang your head a couple of times before you find the correct track. Once you've found your track, you will be fine. It took me about 2 months to go through the first 12 chapters, but it was very rewarding in the end...
The book's website contains information that you can use to update the knowledge base provided by the book. There is also source code to download.
15 of 16 people found the following review helpful
on 28 June 2001
A comprehensive and interesting book, but real hard work. An immediate failing is in the style of writing - concepts are nearly always explained by code examples, which would be fine if the code were neat, clean and correct. However, the many code examples and written in some mock-Java language (it seems to switch between Java and C at random) with terse names such as class names Nx and Cx, with equally hard to follow variable names. In the end, the code is very hard to read, but is critical to understanding. If you time to bang your head off a wall, fine.
If you are interesting in learning how compilers work I would definetley recommend 'Programming Language Processors in Java' by Prof. D. Watt over this text. It covers essentaily the same material but is a much smoother read, and each stage of design and impl. the authors promote quality software engineering practices. None of the frustation and endless re-reading encoutered here.
10 of 11 people found the following review helpful
on 20 January 2002
The book leads the reader on a perilous quest to build a compiler for a simple language called Tiger. It is quite a challenge to work through the chapters, but I felt quite a sense of achievement when I was able to complete the tasks at each stage. My main goal was to learn how to write interpreters, not compilers, so I didn't pursue the sections on translation to machine code.
The book has, I feel, two main failings:
1. The writing style is rather obscure and far too concise. Very brief and inadequate explanations are given of key points. In some cases, some important coding techniques are not described in the text at all, and are only discovered if you download the supporting code from his web site.
2. By far the worst fault in the book is the quality of its sample code - both that included in the text and that downloaded from the web site. Variable, method and class names are unnecessarily shortened to meaningless symbols, classes often have the same name as the package in which they reside, code is poorly formatted making it very difficult to read, and the comments are often sparse or absent. In short, it violates all the principles of proper coding we attempt to teach novice programmers. Much of the "code" in the text is actually pseudo-code, not real Java (or anything else).
Having said that, if the reader is willing to persevere, he will learn a good deal from the challenge of overcoming the book's numerous obstacles.
2 of 3 people found the following review helpful
on 18 February 1999
I found the start of the book very hard going and found myself re-reading a lot of it before I realized what it was going on about, but it does get better after you get over the first part. Overall it is quite a good book for learning compiler implementation.