Customer Reviews

The Definitive Antlr Reference: Building Domain-Specific Languages (Pragmatic Programmers)

5 star:		(10)
4 star:		(5)
3 star:		(1)
2 star:		(1)
1 star:		(3)

 

 

If you have any interest in compiler design, building translators, building intelligent editors, code generation, understanding what goes into building your own computer language, or just how to use ANTLR v3 then you may want to get a copy of this book.

This book is all about ANTLR. ANTLR is a tool you can use to build compilers and interpreters for computer languages, but don't let that scare you off. With the increasing interest in domain specific languages, bulding intelligent editors, code generation, and model driven development books like this are becoming ever more important. Terence Parr has made the topic far more approachable than any other book I have read (or attempted to read) on the topic.

In the first few chapters the author walks readers through the phases of parser construction using language that is approachable and easy to understand. He explains the needed principles and demonstrates their application with well chosen examples.

This is followed by a quick tour of how one might use ANTLR. I love the approach taken in this chapter as it takes a small example and shows two different ways to approach the problem using ANTLR. This is coupled with explanations describing when you want to use one approach over another.

The middle section of the book goes into depth on the various aspects of ANTLR. This is the reference section. Don't expect to be able to read these chapters one after another in quick succession. There's just too much to take in all at once!

The text is littered with references both forward and back to other sections and topics of interest. You can tell the author has spent a lot of time working with compiler construction by the breadth and depth of information presented. I really liked the motivating examples he gives for certain ANTLR features such as the need to emit imaginary tokens when lexing python (see page 94 in chapter 4).

The first chapter of part three of the book delves into the depths of the parsing algorithm used in ANTLR since you will need to understand it when you run into parsing errors and need to make sense of them.

The remaining chapters are devoted to ways to deal with the problems you may run into when trying to parse various language constructs.

This book has left a very lasting impression on me. I can visualize what goes into an editor like eclipse more fully. I no longer feel that the topic of abstract syntax trees is above my head and I feel I am better equipped to tackle the dragon book. I also understand why lisp programmers say that lisp has no syntax (take a look at the serialized form of the AST from chapter 3 on page 62, it looks like a bunch of s-expressions!).

One more note: ANTLR itself is a domain specific language (DSL) and serves as a prime example of how a DSL can greatly increase the clarity of the solution to a problem if the solution is described in terms native to the problem domain. (I think that's what the folks in the lisp camp have been saying for a long time.) ANTLR helps show the value of having DSLs and this book shows how easy it can be to write one!

If you're working with ANTLR then you need "The Definitive ANTLR Reference". It's a reference work, but only in part; the vast majority of the book consists of explanations and examples rather than dry reference material. The reference material is in there, of course, but there's really not a lot of it because ANTLR itself has a very minimal design.

But despite the fact that ANTLR looks like a simple tool on the surface (the rules for building a grammar are few and simple) in reality it is fiendishly difficult to use until you get the knack for it. This book will help you through the difficult early stages of learning how to write ANTLR grammars; it really is the only resource out there that does this in a comprehensive way. Terence Parr somehow manages to take the incredibly dry subject matter of lexer and parser generation and turn it into a witty and entertaining conversation; you really feel as though Terence is speaking to you from across the table.

My only complaint about the book is that it is almost totally Java-centric (all the examples are in Java) despite the fact that ANTLR can target multiple languages (if the book had a little more information about other target languages then it would be a five-star title).

The release of ANTLR version 3 represents a major milestone in compiler-compiler technology. LALR and LL(k) parsers, useful as they are, are difficult to master, and often require significant effort to overcome simple problems. Not only does ANTLR's LL(*) parser technology allows one to churn out problem-specific parsers with amazing speed, it also provides an arsenal of tools not found in other compiler-compiler tools: easy AST generation, tree parsers, rewrite rules, multiple language backends, templating. The scope and breadth of ANTLR puts it in a category all by itself.

I'm convinced that ANTLR will become an indispensible tool in any programmer's toolbox. And, by extension, the Definitive ANRL Reference will become an indispensible part of serious programmers' bookshelf.

Breathtaking.

Before leaving for a business trip to Florida, I decided to do some research on ANTLR for work. The book is very well written and brings you into the world of writing your own Lex without having any prior experience. It makes no assumptions about knowing Yacc, Javacc, or any of the other tools out there. I highly recommend this book to anyone in need of creating a DSL (Domain Specific Language), parser, or if you're even attempting to a program to migrate from one language to another.

Very well written, very organized and provides excellent insight into parsers.

Best Regards,
Richard L. Burton III

I have just finished reading the ANTLR ref book and I thought it was helpful, yes I also agree that it was a bit too much Java being more of a C++/C# person but I am not that picky. The one thing that I didn't like with the book was the structure. The four last chapters contain the actual theory, and one chapter in the middle was the reference. I didn't like this, it didn't feel natural. I would have liked to have the theory first and then gotten on with the details, building upon examples with increasing complexity (preferably not only in Java ;-). Also the index wasn't good, it should have been more detailed. e.g. where can I find what input.LT(1) means?

A good thing was there exists a mailing list and of course the website which helps to fill the holes that book unfortunately sometimes leaves.

Well, really, how many *casual* ANTLR users are there? The ANTLR community might be broadly divided into three groups: (1) Terence Parr, the self-described maniac behind ANTLR; (2) the demigods of ANTLR who are slightly more numerous than Terence and have already learned at the School of Really Hard Knocks; and (3) the rest of us, who want to become productive with ANTLR. It's that last group of us who can benefit from this text which softens some of the knocks. To be sure, this book is not a shortcut or substitute for getting your hands dirty and experiencing some frustration. Creating languages is not for slackers. No book can change that. The real value of this text is as an in-depth guide to the guts of ANTLR. It's a very "pragmatic" book and might have been called "The ANTLR Missing Manual" if another publisher had not already locked up that motif. Although the author tries to start from zero knowledge, I think you really need to have worked through at least the main examples at [...] first. Then, you'll be prepared to appreciate what this book has to offer. It's a great field manual for people in the thick of operating the tool.

The critiques (and criticisms) of the strong Java flavor of this book have some basis in fact. But this is, after all, a book about a programming tool written in Java. Professionals should be able to overcome this obstacle, and anyone who tries to find an equal to ANTLR without the Java baggage will quickly discover that learning enough Java to use ANTLR is a comparatively small price to pay.

Final words: Read the second book ("Language Implementation Patterns") first. Actually, read chapters 1, 2, 4, 9 and 10 of that book. Twice. That second book is hardly Java-centric at all and indeed only incidentally about ANTLR. Then get this first book ("The Definitive ANTLR Reference") and get to work. From there, you won't need any more advice from a book review.

I think ANTLR is a great tool and the author did a great job in developing it.
Unfortunately, I cannot say the same about the book. The text is written in a colloquial way (which need not be bad by itself) and is often quite unprecise or ambigous. In order to understand many statements in the book it is probably necessary to reverse engineer ANTLR to quite some extent and spend some time with the author for learning his terminology and way of thinking.

This USF CS professor has two main inventions to his credit, ANTLR and string template. This book gives Java developers almost everything you might need to learn how to use these two technologies.

ANTLR is ANother Tool for Language Recognition which empowers developers to embed the ability to use domain specific languages into their applications. With ANTLR, you specify a grammar, run a tool to generate the parser and lexer code from the specification, and call that parser and lexer from within your application.

Terrence Parr is the consummate educator and the book's organization shows it. He starts with a high-level overview into the computer science problem of formal language parsing. Then he follows up with a quick start tutorial on how to get your first ANTLR program written. Now that he has whetted your appetite, you get the complete reference materials on all features of ANTLR. After that comes a deep dive into compiler theory as it relates to ANTLR.

The guide is definitive but let's not over promise on what any single book can do. If you have never taken any college level courses on Chomsky's Theory of Formal Languages or compiler theory, then you may not come to completely understand and appreciate every nuance of ANTLR. Even so, if any book can get you up and running with ANTLR, then it will be this book. With this book, I was able to get a research project in server side ANTLR [...]

If you know nothing about parsers, lexers, or DSLs in general, this book does a fantastic job getting you from nowhere to BOOM pretty quickly. For pretty mind-bending material, that's really important. The book is a fantastic reference and I was able to put together a truly complicated grammar in a few days. Worth every penny, and then some.

This is a book I would highly recommend to anyone writing a translator with ANTLR. Although there is no shortage of information regarding ANTLR on the Web, there is a lot more in the book itself.

Creating grammars for language recognition is one of those complex topics that have been theorized a lot. Mastering them seems the privilege of academics and PhD s.

Terence Parr is definitely one of these gifted academics. Part III of the book is proof enough that he knows this topic in and out. But unlike other academic brains, Terence also profoundly understands software developers. That gives an extremely practical and example-rich part I and II. The samples provided are much more detailed and clearly explained than the online material I could find. This mixture of science, pedagogy and software engineering is very unique.

Like many other software developers who burnt their fingers with LEX and YACC, I tended to stay away from grammar-based language recognition. After reading this book, I feel much more comfortable with the subject.