Programming Language Processors in Java: Compilers and Interpreters

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 RISC-processor lookalike pseudo-instructionset (LOAD,STORE, JUMP etc instructions) this book is a nice intro in low level RISC assemblyCONS:* 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.

An excellent book. I had to write the front end of a Java compiler quick for part of my final year project, and unfortunately chose Appel's unreadable dud 'Modern Compiler Implementation in Java' over this text - what a mistake!This is an excellent, comprehensive and easy initiation in compiler implementation. On the language theory side of things, it gives the least you need to know (good news in my case) and focuses on concepts and how these translate into code - which is after all, the bottom line in understanding any computer system.The style of writing of the text and code is first rate. Most other compiler texts show no guilt about using nasty hacks in impl. Its refreshing to to see an excellent object-oriented, pattern-based design and impl. used in this text that is also well documented.Whether you read this book out of curiousity or professional interest, I'm sure you'll find it a satisfying read.

I've read quite a lot of books about compilers and interpreters, but IMHO this is by far the best one. For an enthusiast in this topic like me, this book is the perfect balance between theory and practice (examples) and sits in between the "dragon book" with all its theory and other books like the one written by Ronald Mark which is very specific on the actual implementation of a language processor/compiler.This book presents this (sometimes dry) topic in a nice way along with many examples and illustrations that are very easy to follow. Also the use of the ubiquitous Java programming language makes it even easier to understand the code listings.I highly recommend this book for anyone willing to learn this "art" of writing compilers and/or interpreters.

this book was in excellent condition like brand new. I was very pleased

Status OK. It was a quite stable but I need to get it in a day next time.

Although this is a practical book that teaches you how to create a small compiler that compiles the author’s new language call Triangle, it is not concise and doesn’t use regular computer Science formal notation. The author has his own way of explaining things that I thought is too winded.