To use our price comparison to get the cheapest price, please click on the "Find the Cheapest Price" button located above for Programming Language Processors in Java: Compilers and Interpreters by David Watt, Deryck Brown (ISBN-10: 0130257869, ISBN-13: 9780130257864).
At this time we have not yet written a review for Programming Language Processors in Java: Compilers and Interpreters by David Watt, Deryck Brown (ISBN-10: 0130257869, ISBN-13: 9780130257864). Please continue to keep checking back to this page as we are constantly adding reviews.
Summaries and Customer Reviews are supplied by Amazon.com
Aims to exemplify good software engineering principles at the same time as explaining the specific techniques needed to build compilers and interpreters. Examples included. DLC: Java (Computer program language)
The best intro to compilers, period!
| Customer Rating:  | Very well organized, all source code for the compiler + Interpreter/Virtual Machine + Disassembler is available online. Good writing, good exercises (including answers to some of them), good selection of material to cover.
If you want to have a good understanding of how copilers/interpreters work, and want good working source code for a demostration and to play with, then you must have this book.
The fact that the implementation is in Java is another plus. Petty differences aside, Java is the most accessible language (in terms of reaching a wide audience), and for those who want to quibble over the authors' coding style: "Grow up!"
For those of you trying to decide whether or not to get this book, go on, download the source, take at look at the code, run it, and if you wanna know how/why it all works, then get the book and read it. You will be glad you did. |
No longer relevant thanks to Eclipse framework
| Customer Rating:  | | Now that Eclipse has an open source (LGPL) framework for building compilers, processors, refactoring tools, code generators, and interpreters, this book is hardly relevant. Eclipse's JDT is well documented, and functionality existing for Java can be ported to other languages (and some is already abstracted to the underlying Eclipse platform). Eclipse has an AST (Abstract Syntax Tree), DOM, and all the other tools this book hacks together, except Eclipse is a huge widely supported open source project. |
Simply the best Learing-by-Coding compiler book
| Customer Rating: | This is really the greatest 'Compiler for Dummies' book as of today. I own and studied all books (total arround 80) about compiler constructions you can buy in the world today plus a lot of out of print titles, so I know what you can buy on the market...
If you're looking for a learning-by-coding compiler book don't look futher. This is a great introbook for a Bachelor of Science of a Professional Bachelor student! If you have the money to buy only one compiler book buy this one. If you have the money to buy 2 books and you also know a bit C++, buy this one and 'Writting compilers and Interpreters' from Ronald Mak which also offers a pratical approach which is also nice for newbies but not that nice as this book.
If you have finished this book and want to get more theoretical insight or you're a Computer Science M.Sc student (like me), read 'Programming Language Pragmatics' from Mr. Scott, which don't present the material on a dry manner. This book covers all aspects of compilation and language design in greater detail! Be sure you have read (or master) an intro text like 'programming language processors in java' before starting books like 'programming language pragmatics'.
If you're a M.Sc. student and you're looking for a learning-by-coding book i recommend the books of Andrew Appel (Modern Compiler Implementation in Java) which covers advanced topics (optimization, register selection,etc). But beware: if you're new to compiler design forget Andrew Appels book, and buy this one because Appels would be a bit too difficult for you.
Back tot the 'Programming language processors in Java' book.
This is what I like and what not:
PROS:
* It gives some nice written theoretical introduction of the whole compilation process (e.g. what's LL and LR-parsing, how is runtime organization organized (stack, parameter passing, stackframes etc). It doesn't dive too deep, but you will be familiar with the topics. E.g. it explains how LL and LR parsing works (with some nice examples how to parse LL/LR simple English sentences), but it doesn't tell you what the advantages/disadvantages of both methods are. This is beyond the scope of this book. For these topics read later something else (e.g. 'programming language pragmiatcs')
* Not all Java code is printed to fill 1000 pages. Every codesnippet is well commented, all repeatative code is left out: you can download all the Java code. So this book is not one big listing.
* It gives you insight how to build a really nice Virtual Machine. The author is talking about an interpreter, but the compiler generates modern intermediate code (STORE,LOAD,CALL,JMP) and the VM execute this in a big WHILE-loop.
* Some learning-by-coding compiler books (e.g. 'Building your own compiler with C++' by Jim Holmes (not recommended)) explain only a silly subset of pascal (e.g. only assignment and writeline), but this book teach you 'mini Triangle-language' which also offers arrays, functions/procedures, records (structs), and parameter passing by reference/value. It also explains you those more difficult topics like parameter by reference passing is handled by the codegenerator.
* It has a nice chapter about runtime organization. This is a nice chapter for people which are new to e.g. processorarchitecture. This chapter explains you how local variables are stores (stack), how parameter passing to functions is working and how return values are passed back. Because the Interpreter (VM) which is introduced in the book, has a modern stack machine VM (STORE,LOAD,JUMP) this is an excelent way to study those VMs and code generating for a stack machine.
CONS:
* I agree to the customer review of Mr. Yegge of July 12, 2004 that the Java Code is not always supernice. E.g. there is often java.lang.Object parameter passing which is later dangerous narrative casted. I do NOT agree with Mr. Yegge about his remarks on the Visitor pattern. The author explains why he is using the visitor pattern: to reduce coupling between the CodeGenerator or TypeChecker and the AST. On this point I like the design of the author. The idea of using the visitor pattern is nice, but it is somewhat bad implemented with those narrative casts.
Conclusion: I STRONGLY recommend this book for people who are new to compiler design. |
Rushed to publication too quickly
| Customer Rating: | | It's a lot of work creating a textbook like this, and the authors did a great job along certain dimensions. The book is well-organized and much more accessible than many (in)famous compilers books. The copy editing is high-quality: there aren't many mistakes in the book. The book itself is beautifully bound and printed, making it a pleasure to read. There's lots of sample code. On the whole, it's not a bad effort. There -are- some real problems with it, though. The most obvious and central problem is that it's not a book by (or for) Java programmers. It feels very much as if the book was hastily rewritten from "Language Processors in Pascal" to "Language Processors in Java" after Java exploded in popularity, a year or two before the book was published. The mini-Triangle language is clearly a Pascal derivative, and many of the "pseudo-code" examples are really Pascal. Pascal may be a teaching language, but it looks completely alien to Java developers. My biggest concern, and it's what prompted me to write this review, is that the Java code is truly awful. Yes, it uses the Visitor pattern (as one reviewer pointed out) to traverse the AST during semantic analysis, which is a reasonable strategy. But the code is just plain bad, and you don't want students learning bad habits. The code is utterly non-polymorphic; it's filled with long cascaded if-statements that check whether an AST node is an instanceof this or an instanceof that. They pass and return parameters of type Object, and callers perform dangerous narrowing typecasts. They freely pass and return null values that have special semantics (i.e. "if this parameter is null, then it means we have this kind of situation; otherwise it's the other kind"). Types are represented as ints (no attempt to create typesafe enums), instance members are made public and accessed directly rather than through methods, and they use unconventional (and unexplained) 1-character variable names. I'm telling you: it's a complete disaster, and students will come away from the course writing the worst Java code you could imagine. Another problem: the book is written in a stilted and awkwardly formal tone - a throwback to textbooks in the 70s and 80s. The art of writing textbooks has advanced to the point where, gosh, you're supposed to be able to READ them. They're written FOR real people, BY real people. But this book reads like an actuarial report. It never says "you" and never says "we" - it's written entirely in stilted 3rd-person legalese. Not good. Oh, one more gripe: the authors decided mysteriously that they don't like the standard terminology that's been around for 3 decades, so they changed "semantic analysis" to "contextual analysis" and so on, and then acted as if the standard terminology is non-standard. They could have at least said up front that they preferred using their own terminology, but that it was nonstandard; instead they're trying to rewrite history. It's inexcusable, and will confuse students who head to other books after reading this one. Compilers are hard to write and hard to learn, and this book actually is an improvement in clarity of exposition over most of its predecessors. But it's just begging to be replaced by something better. In the meantime, I'd skip it and go straight to Programming Language Pragmatics. |
|
