Programming Language Processors in Java: Compilers and Interpreters

by Deryck F. Brown, David Watt, Deryck Brown

Book Overview

This book provides a gently paced introduction to techniques for implementing programming languages by means of compilers and interpreters, using the object-oriented programming language Java. The book aims to exemplify good software engineering principles at the same time as explaining the specific techniques needed to build compilers and interpreters.

• Format: Hardcover
• Language: English
• ISBN: 0130257869
• ISBN13: 9780130257864
• Release Date: January 2000
• Publisher: Pearson
• Length: 436 Pages
• Weight: 1.95 lbs.
• Dimensions: 1.1" x 7.0" x 9.5"

Customer Reviews

The best intro to compilers, period!

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.

Simply the best Learing-by-Coding compiler book

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 p

Best introduction ever written.

I've purchased or borrowed 5 books on compiler design. There is no doubt that this book should be the choice for any introductory course. The authors explain everything tightly and provide a lot of actual examples in the text. All of it is in Java, of course. Don't worry if you don't use Java. It's very easy to understand if you have any experience with any OO language. I prefer Object Pascal and had no trouble whatsoever with the code.This book will not provide proofs or a lot in the way of choices for designing a compiler. This is good when you are starting out. The last thing you need if you actually want to learn about compiler design from front to back is a hundred different ways of doing the same thing. The text takes you through a small version of the "Triangle" language ("Mini-Triangle") - and the code for the entire Triangle language is available for download.This book makes learning about compilers effortless for anyone with an OO background and a little knowledge of the most common algorithms learned in any into course on algorithms. If you can't learn from this text, then don't bother with any other. The next book I'd recommend after reading this text is the Dragon Book. Then you can try on Advanced Compiler Design for size - which I am doing at present.A great book to read along (or just before of after) this text is Programming Language Pragmatics. I read it in parallel. If I had to do it again, I'd probably read it first.

A Great Book

I have recently finished writing the Triangle compiler based on this great book for a compiler class I'm taking the code amounted to roughly 5000 lines of code and it's totaly based upon the instructions given in this book. I belive this is the best book written about writing compilers it's very easy to understand and the methods used such as the visitor pattern are extremely advanced and will improve ur level of java programming. there is not much concentration on understanding how compilers work but there are tons of other books for that purpose and frankly who cares we'r more interested on how to write a compiler than how it was written by other people. the triangle language designed is easy but serves the purposes quite well and has everything C or Pascal has I've been working on this for 4 months and now I feel sad becuase I have finished the project and there is nothing more to do I recommend this book for all serious people who love writing java code.

Clear and illustrative in telling you what you need to know

My situation: I am writing this because I feel that I owe a lot to the authors. I am a University student and I developed an interest in compilation and interpretation. I had access to a wide range of texts at my University but I struggled to get a foothold in the field. I was having difficulty turning the theory presented in these academic texts into practice in my own attempts at compilers.Ideal for me: I had given up on the field for the time being when I came across this book. I could not believe it. It was not what I was looking for because I had no idea it existed, but it quickly became apparent that it was ideal for my situation. My preferred language is Java and so this just helped to make the examples jump out of the page at me that little bit more.Working through the book: I enjoyed working through the book and found it very readable and self-explanatory. The examples are excellent and reinforce every concept presented by the book. It stood out from everything I had read on the subject to this point (and since).The case-study: The case study, which runs throughout the book, uses the programming language Triangle. It has obvious links to the previous incarnations of the book when the Pascal programming language was used. Triangle is a simpler version of Pascal but is still a reasonably realistic language to look at. I found it very useful to see how each aspect of the compiler would actually look in code for an example language. The language is compiled to an abstract machine called TAM. The details of this are included in the appendix and can be transferred to other machines with a bit of careful modification.Structure of the book: The book starts off with the normal background and definitions in the first two chapters. I found the next five chapters to be the most interesting in the book. They are on Compilation, Syntactic Analysis, Contextual Analysis, Run-Time Organization and Code Generation. The last two chapters are on Interpretation and a Conclusion.Correctness of programming techniques used in the book: This book is very correct in its programming techniques. I had been a bit worried when I read that it was by a Pascal programmer that it might be Pascal-style Java but it used proper Java techniques throughout. I was especially impressed with the appendix containing Class Diagrams for the Triangle Compiler.Summary: I found that this book told me just what I wanted to know about the field when so many others were telling me everything but this.