Review by K. Ferrio for Language Implementation Patterns: Create Your Own Domain-Specific and General Programming Languages (Pragmatic Programmers)
Rating:
This is my favorite kind of book: the harder I work, the more I get. So be prepared to work hard. And if you do, you will be rewarded with gems of insight. If you’re looking for a “cookbook” I respectfully suggest that you examine your reasons for being interested in language design. All the ingredients and kitchen implements are here, clearly labeled and explained. There are even examples of how you might consider mixing them. But it’s up to you to write the recipe you need, and a key objective of this book is getting you to that magical moment when you see how everything comes together.

Plenty of people much more educated and experienced in the art and science of language design than I am will surely write insightful reviews about the merits of this book from the perspective of specialists. I’m writing this review for the rest of us.

Terence Parr continues his campaign to make superb language-development tools accessible. Have you ever wondered how your compiler really works? Maybe you’ve dreamed about creating your own scripting language — the one that works the way *you* want — but you’re not Larry Wall. Well, take heart. Professor Parr’s second ANTLR book is here. Maybe you never took a course in compiler design (I haven’t.) or maybe you have and are still wondering how to do anything practical with it. This book is for you. You very well might not become the next Guido van Rossum, but you will come away with a deeper appreciation of language implementation — probably enough to create your personal dream language.

I call this the “second ANTLR book,” but that’s a gross oversimplification. If you already know that ANTLR stands for ANother Tool for Language Recognition, then the next thing you need to know is that this book is about much more than ANTLR. You also may know that ANTLR is written in Java. But you don’t need to know Java to get value from this book. (In fact ANTLR itself can target C, C# and several other languages besides Java.) Although the book uses ANTLR to describe example languages, and Java to implement them, the author very cleanly separates concepts from tools and implementation details, in a way which is consistently pragmatic and never drifts off into the clouds. There is no pedagogic hand-waving here. This is the real stuff. And when you grasp it, you too will be able to create everything from “simple” data format translators to script interpreters and maybe even some non-optimizing compilers. Really.

Review by Adam Keys for Language Implementation Patterns: Create Your Own Domain-Specific and General Programming Languages (Pragmatic Programmers)
Rating:
I had to read the classic Dragon book in college. I’m glad I did and feel that all software developers should go through the mental process of learning to build a compiler. Doing so ties together all the classes that come before it, from data structures to theory of computation. But, the texts on those subjects are quite dense and not quite practical for the working developer.

This book fills that gap quite nicely. It is free of excess jargon and gets right to the point of creating new languages. Each chapter builds up the reader’s repertoire of techniques and tools for writing programs that create programs. For a relatively short book, the author does a fine job of covering scanning, parsing, type checking, interpreters, virtual machines and code generation.

If you’ve ever wanted to build your own language but fell short when it came to the theory behind it, this book is the one to check out.

Review by German Viscuso for Language Implementation Patterns: Create Your Own Domain-Specific and General Programming Languages (Pragmatic Programmers)
Rating:
I was terribly interested in getting my hands on this book since I’m taking a formal course on Compilers and Interpreters at university and I really wanted to know: What’s the difference between what we (as computer scientists) are taught in a compilers’ course and the more practical approach presented in the book?

As it turns out there’s a big difference. If you want to be the ultimate guru of compilers (eg. contributing an even more efficient compiling technique for language X or creating a language that forces us all to reconsider what we know about compilers) you need both, the theory the practice (because without the theory you wouldn’t know how to improve or make obsolete an existing technique, and without the practice you wouldn’t be able to put that knowledge to work inside a language compiler). Now if you just want to be able to deal with your DSL (domain specific language), create data readers, code generators, source-to-source translators, source analyzers, etc. you’ll love the hands on information presented in this book.

Let’s be honest, how many of us developers are required or willing to create a language from scratch together with its compiler or interpreter versus the ones that just need to parse an XML file, process a DSL or create a configuration file reader? I would say that there are much more developers in the later group. But fortunately we all (or almost all) share one thing in common: we know software patterns! This is how the author structured the book, offering patterns (ala Gamma et al) that you can use when creating your language processors (an excellent approach in my opinion since each pattern focuses on different stages of language processing which helps the developer modularize the solution and understand how the different parts of the “machine” work without loosing sight of the big picture).

So, in case you’re wondering “what is this guy talking about?”. A compiler is a program that transforms code created in one language into another (eg. C source code into executable code). Normally the transformation goes from a higher level language to a lower level language (eg. to machine code)(if it’s the other way round we have a “decompiler”). When the transformation happens between languanges on the same level we’re dealing with a language translator or converter (normally called “source-to-source translator”)(eg. Sharpen, an open source framework created by the db4o team that converts Java code to C#). A compiler is likely to perform several operations such as lexical analysis, preprocessing, parsing, semantic analysis, code generation, and code optimization (which are directly or indirectly covered in the patterns offered in the book). The ultimate tool for developers interested in building compilers is a compiler-compiler or parser generator which, as you might have already guessed, provides a high level description language to help you build your own compiler (this usually involves the creation of a lexer and a parser).

However, I feel I should mention that there’s a whole lot of complexity in handling and maintaining all the intermediate information when you’re creating your own compiler for your own language which is covered only indirectly in this book. There’s also no detailed explanation of the final steps of a compiler implementation such as machine code generation and optimization, register allocation, etc. Overall this is an excellent book for day-to-day language applications (involving parsing, translations, etc).

Now I find pretty important to mention who the author is. Terence Parr created the ANTLR parser generator (antlr.org) and the StringTemplate engine (stringtemplate.org). He’s a professor of computer science that’s no theorist (this guys has real practical experience!). He has so much experience that he started to see these patterns when developing language processors coming again and again. The end result is this book that presents a compilation of those patterns.

The structure of the book is pretty straight forward. Four general parts:

* Getting Started with Parsing: where you’ll learn about the general architecture of language applications and review the patterns that involve parsing.

* Analyzing Languages: where you’ll see how to use the parsing techniques described in the previous section to build trees that hold language constructs in memory, how to walk those trees to track and identify various symbols (such as variables and functions) and how to determine the type of the expressions. Overall you’ll learn how to check whether an input stream makes sense.

* Building Interpreters: four interpreter patterns are presented that vary in terms of implementation difficulty and run-time efficiency. In the two previous parts the focus was on patterns that verify the syntax of an input sentence and make sure that it follows a set of semantic rules. In this part the focus is on patterns for processing the input sequences (not just validating them).

* Translating and Generating Languages: here you’ll learn how to translate one language to another and how to generate text using the StringTemplate engine.

The patterns are laid in the order you’d follow to implement a language (section 1.2, “A Tour of Patterns” describes how all the patterns fit together). There are 31 patterns in the book, each with four parts: purpose, discussion, implementation and related patterns. The implementation section provides illustrative code in Java (but it’s not meant to serve as a library). You don’t need a background in language theory or compilers to understand the book but you have to have a solid programming background and be confortable with the concept of recursion in algorithms.

Overall, if you’re a developer that has to deal with any of the use cases described in this review this book *must* be in your bookshelf (but if you’re really into compilers you should also have Aho’s Dragon book next to it =)

Review by Jarrod H. Roberson for Language Implementation Patterns: Create Your Own Domain-Specific and General Programming Languages (Pragmatic Programmers)
Rating:
Terrance Parr is truly an expert in this domain and his books are easy to read and easy to understand. He doesn’t assume you know all the jargon and explains everything very clearly and precisely without being patronizing. If you are interesting in how language parsing really works get this book.

Review by Joel Redman for Language Implementation Patterns: Create Your Own Domain-Specific and General Programming Languages (Pragmatic Programmers)
Rating:
This is a good book on language implementation via ANTLR, and interesting in that respect. However, if you are working in a non-Java, non-ANTLR environment (C with Bison for instance), the patterns that are spelled out are too specific. For instance, the tree-matching and tree-walking examples are given in ANTLR only with no discussion on how to accomplish this in any other environment, despite being the most common way of dealing with languages.

Great book for ANTLR, not so great for other implementation environments.