Customer Reviews

Language Implementation Patterns: Create Your Own Domain-Specific and General Programming Languages (Pragmatic Programmers)

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

 

 

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 =)

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.

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.

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.

In high school I created ACID1, a clone for the BASIC programming language. ACID1 was never completed but I felt I could take the world down with my very own programming language. That did not happen. ACID2 was born some years later in a college dorm. It did not work either.

These failures taught me an important lesson. ACID1 was created with no prior knowledge of language building whatsoever. ACID2 was, however, created with a surplus of theories (the Dragon Book, anyone?). I needed a middle ground.

I found Language Programming Patterns by Terence Parr about a month ago. LIP, if you may, since we are quite pleased with K&R, CLRS, TAOCP, etc... When I picked up LIP, my internal alarm went off, I felt it was going to be a good read.

Guido van Rossum, creator of Python (Python forever!), commented: Throw away your compiler theory book! So I knew. I also found out that professor Parr has been teaching language applications programming for years. Then I knew. The book itself came from the famous Pragmatic Bookshelf. And I knew: LIP would be a good read.

The book did not disappoint me, and will not disappoint any programmer with interests in language applications. LIP is the perfect mix of theory and practice. LIP is the working ACID I did not write.

Parr uses Java for his examples. I confess that I barely know Java. But half the patterns I have translated to Python while reading. This wouldn't have been possible without the great explanations in the book.

Each pattern has a Purpose, a Discussion, an Implementation, and Related Pattern section. Patterns are grouped together in chapters in such a way that when you've completed the chapter, you have a complete skill.

In chapter 2, Basic Patterns, for instance, I reminisced strange symbols like LA, LL(1), LL(k). Only this time they made actual sense and were put in real world examples. Professor Parr explained why you don't need LL(k) for, say, a simple list ([a,b,c]) parser. Programmers will often go miles to accomplish this.

Parr uses his popular tool ANTLR a lot in the text and this might annoy some. It is also my only regret. In his defense, good alternatives to ANTLR are scarce. Oh well. I, who have scant knowledge of Java, completed the book. So should any programmer.

There are 31 patterns in LIP. You dont have to know them all. Just where and how to find them. Chapter 10, Building Bytecode Interpreters, is easily my favorite. For long I wanted to learn how bytecode interpreters work. Chapter 10 discusses two patterns: Stack-Based Bytecode Interpreters and Register-Based Bytecode Interpreters. Popular Lua uses a Register-Based Bytecode Interpreter for example. Python (Python forever!) is Stack-Based.

Chapter 13, Putting It All Together, is the ice cream. In that chapter, Parr shows how to put your patterns together to fix real world problems: finding patterns in proteins structure, building a scripting language to generate 3D scenes, and fixing, sorry I meant tweaking, Java. Needless to say, Chapter 13 is the chapter you must not skip.

I believe chapters 1 through 6 are the core. The matter. The substance, like my chemistry professor used to say. Patterns from these first six chapters are all you need to build a simple language. We are talking no data aggregation and object orientation, right? With Chapter 13 (the one I just discussed), that's seven chapters not to skip.

Fellow dynamically typed languages lovers: Chapter 8, Enforcing Static Typing Rule, will fill our faces with smile and brighten our day, let's not skip it. It is essential knowledge.

Professor Parr has written a classic here. The book deserves a place on the golden shelf. I once asked Brian W. Kernighan what constitutes a good book. And the reply was insightful.

Kernighan wrote that he believes in books that are authoritative, are written by authors who love what they are writing about, instead of what is hot. He added that books should be pragmatic and useful rather than theoretical and philosophical.

Thank you professor Parr, for writing LIP.

I've been a Software Engineer for about 20 yrs. now. Although my work is mostly real-time, embedded systems, I've always had a fascination with compilers and I love writing parsers. The "Dragon Book" has always been a favorite of mine, but can be a bit too theoretical. I'm a meat-and-potatoes kind of guy. I prefer looking at actual code. This book is very well written and practical, less theory (which I already have a good foundation in), more implementation. It is concise and clear. Mr. Parr has a very light and easy to read style of writing. His knowledge of the subject is, of course, top-notch and his ability to convey that knowledge makes me very envious. I've always been impressed with his ANTLr tool, which is why when I went looking for more compiler books, his was one of the first names I thought of.

Focused on ANTLR and StringTemplate implementations. Others are only mentioned. but it is understandable, since the book is already dense. It would have add at least 50 pages only to have a confusing idea of others implementation, which is not the point of the book. Still I would be curious to see what is done in other implementations (I am curious about XText actually).
DSL are a topic that should have more and more attention. Knowing the underlying principles is important.
Terence is very dynamic and his motivation is palatable in the writing.

Nice concise code examples. I like the liberal style, very readable Java code. Not usual.
Repetitions: Each chapter is build on a common structure (Pattern) (except for the last two). There is a first theoretic exposure and then each part is repeated more in depth, with implementation. Nice to memorize patterns.

The book avoid to drown you into theoretical concepts. It stays very practical as it introduce parser, translators, interpreters. It provides a linear read, but can also be kept as a reference. Each pattern is put into context (configuration file reader, data reader, model driven code generator, source analyzer ...) and linked to others.
I would be curious to read it on a kindle kind of device, with hyperlinks.

The focus is also not on language creation, which I expected. It "only" describes patterns to process the language (translate, execute, check ... ). Only at the end, there is a quick overview of domains where DSL are used, but I would expect much more on the subject.

A really good books since it gives you the incentive to build grammars and rules and templates. It looks like a really fun stuff and a domain where the computer can really do some magic.

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.

I bought this book hoping for some help in writing a parser for a simple imperative language with almost 2000 keywords. Unfortunately, I got no help. There is a lot of good advice in this book for writing a compiler or interpreter for a general purpose language with a reasonable number of keywords. If you know ANTLR, it is even better. I guess I'll try Domain-Specific Languages (Addison-Wesley Signature Series) next.

Terrence Parr created ANTLR as a tool for developing "mini-languages", aka Domain Specific Languages. It's a huge improvement over tools such as lex, yacc, and bison. This book describes in a very readable and understandable way the patterns necessary to create translators, generators, interpreters, etc. and how to implement them with ANTLR. Buy along with "The Definitive ANTLR Reference".