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

by Terence Parr (Author)

101 ratings

ISBN-13: 978-1934356456

ISBN-10: 193435645X

Why is ISBN important?

Share <Embed>

Other Sellers

from

Other Sellers

See all 2 versions

Used: Good | Details

Sold by Booking-it

Fulfilled by Amazon

Access codes and supplements are not guaranteed with used items.

Get Fast, Free Shipping with Amazon Prime

FREE delivery Tuesday, May 10 if you spend $25 on items shipped by Amazon

Or fastest delivery Friday, May 6. Order within 9 hrs 12 mins

In Stock.

Ships from and sold by Amazon.com.

Available at a lower price from other sellers that may not offer free Prime shipping.

List Price: $34.95 Details

Save: $9.86 (28%)

FREE delivery Tuesday, May 10

Or fastest delivery Friday, May 6. Order within 14 hrs 57 mins

Available at a lower price from other sellers that may not offer free Prime shipping.

Learn to build configuration file readers, data readers, model-driven code generators, source-to-source translators, source analyzers, and interpreters. You don't need a background in computer science--ANTLR creator Terence Parr demystifies language implementation by breaking it down into the most common design patterns. Pattern by pattern, you'll learn the key skills you need to implement your own computer languages.

Knowing how to create domain-specific languages (DSLs) can give you a huge productivity boost. Instead of writing code in a general-purpose programming language, you can first build a custom language tailored to make you efficient in a particular domain.

The key is understanding the common patterns found across language implementations. Language Design Patterns identifies and condenses the most common design patterns, providing sample implementations of each.

The pattern implementations use Java, but the patterns themselves are completely general. Some of the implementations use the well-known ANTLR parser generator, so readers will find this book an excellent source of ANTLR examples as well. But this book will benefit anyone interested in implementing languages, regardless of their tool of choice. Other language implementation books focus on compilers, which you rarely need in your daily life. Instead, Language Design Patterns shows you patterns you can use for all kinds of language applications.

You'll learn to create configuration file readers, data readers, model-driven code generators, source-to-source translators, source analyzers, and interpreters. Each chapter groups related design patterns and, in each pattern, you'll get hands-on experience by building a complete sample implementation. By the time you finish the book, you'll know how to solve most common language implementation problems.

Total price:

To see our price, add these items to your cart.

Some of these items ship sooner than the others.

Show details Hide details

Choose items to buy together.

by Terence Parr Paperback
$25.09
In Stock.
Ships from and sold by Amazon.com.
Get it as soon as Tuesday, May 10
by Terence Parr Paperback
$30.22
In Stock.
Ships from and sold by Amazon.com.
Get it as soon as Tuesday, May 10
by Michael Scott Paperback
$66.21
Only 15 left in stock - order soon.
Sold by itemspopularsonlineaindemand and ships from Amazon Fulfillment.
Get it as soon as Tuesday, May 10

Terence Parr
124
Paperback
40 offers from $12.96
Robert Nystrom
227
Paperback
in Software Programming Compilers
14 offers from $40.00
Michael Scott
71
Paperback
26 offers from $35.75
Keith D. Cooper
89
Hardcover
30 offers from $41.49
Alfred Aho
369
Hardcover
29 offers from $79.95
Clinton L. Jeffery
16
Paperback
4 offers from $35.99

From the brand

The Pragmatic Programmers publishes hands-on, practical books on classic and cutting-edge software development and engineering management topics. We help professionals solve real-world problems, hone their skills, and advance their careers.
Explore our collections

Visit the Store

Editorial Reviews

Review

""Throw away your compiler theory book! Terence Parr shows how to write practical parsers, translators, interpreters, and other language applications using modern tools and design patterns. Whether you're designing your own DSL or mining existing code for bugs or gems, you'll find example code and suggested patterns in this clearly written book about all aspects of parsing technology.""--Guido van Rossum, Creator of the Python language

""This text is excellent. The exposition plus the examples makes otherwise complex ideas very clear and accessible. Well done!""--Tom Nurkkala, Associate Professor, Computer Science and Engineering, Taylor University

About the Author

Terence Parr is a professor of computer science and graduate program director at the University of San Francisco, where he continues to work on his ANTLR parser generator (http://www.antlr.org) and template engine (http://www.stringtemplate.org). Terence has consulted for and held various technical positions at companies such as IBM, Lockheed Missiles and Space, NeXT, and Renault Automation. Terence holds a Ph.D. in computer engineering from Purdue University and was a postdoctoral fellow at the Army High-Performance Computing Research Center at the University of Minnesota, where he built parallelizing FORTRAN source-to-source translators. He is the author of "The Definitive ANTLR Reference":http://pragprog.com/titles/tpantlr.

Start reading Language Implementation Patterns on your Kindle in under a minute.

Don't have a Kindle? Compra tu Kindle aquí, or download a FREE Kindle Reading App.

Product details

Publisher ‏ : ‎ Pragmatic Bookshelf; 1st edition (January 26, 2010)
Language ‏ : ‎ English
Paperback ‏ : ‎ 374 pages
ISBN-10 ‏ : ‎ 193435645X
ISBN-13 ‏ : ‎ 978-1934356456
Item Weight ‏ : ‎ 1.37 pounds
Dimensions ‏ : ‎ 7.5 x 0.75 x 9.25 inches

Best Sellers Rank: #295,464 in Books (See Top 100 in Books)
- #20 in Compiler Design
- #33 in Software Programming Compilers
- #60 in Microsoft .NET

Customer Reviews:
101 ratings

About the author

Follow authors to get new release updates, plus improved recommendations.

Terence Parr

Brief content visible, double tap to read full content.

Full content visible, double tap to read brief content.

Terence Parr is a professor of computer science and was founding director of the MS in Analytics program at the University of San Francisco, where he continues to work on his ANTLR parser generator (http://www.antlr.org) and template engine (http://www.stringtemplate.org). Terence has consulted for and held various technical positions at companies such as IBM, Lockheed Missiles and Space, NeXT, and Renault Automation. Terence holds a Ph.D. in computer engineering from Purdue University and was a postdoctoral fellow at the Army High-Performance Computing Research Center at the University of Minnesota.

Customer reviews

5 star		62%
4 star		24%
3 star		8%
2 star		2%
1 star		4%

How customer reviews and ratings work

Reviews with images

See all customer images

Top reviews from the United States

There was a problem filtering reviews right now. Please try again later.

Wayne K Dawson

Very helpful, but it needs a glossary or Kindle needs better keyword search definitions

Reviewed in the United States on April 28, 2019

Verified Purchase

I actually bought the book for some rather immediate and specific problems I had to solve, so I rushed through a lot of the material to find what I specifically needed. It is well enough organized that it is possible to use the book for very specific tasks and to jump around quite a bit -- though I would certainly recommend that readers actually read the whole book in a more linear fashion as it was intended (if they have the luxury of time to do so). Scanning some of the material in between, It appears well worth the effort to really learn this material.

One weakness I noticed that was not helped by Kindle was that there are a fair number of acronyms. Most of the time, they are defined and then used, but it took me quite some effort to find exactly what "IR" (intermediate representation) meant; though the context provided tentative hints. Kindle's search engine proved little help with these acronyms on several occasions -- particularly I remember that one, but there were others. I found the exact definition in a later chapter by the hard slog.

For the serious student or researcher who has the time to study the book more methodically, I'd recommend the printed version as almost all of these e-readers are still rather poor substitutes for hard paper and the single strongest advantage they might offer (the electronic search engine) is often unhelpful. It is also hard to find your comments written on the margins because all you are granted is a small speck in the text that you'll never find when searching back over the material. Dropping this one star is mostly due to the frustrations I had with Kindle and maybe not entirely the fault of the author. On the other hand, being available in electronic form was something I appreciated.

One person found this helpful

Helpful

S. Rajagopalan

Not a simple book to go through. Not for noobs. For advanced readers with a solid background in compiler technology.

Reviewed in the United States on April 24, 2018

Verified Purchase

This is NOT a text for understanding a quick, rudimentary introduction to writing simple grammars, getting lexers and parsers for it in your programming language of choice as the introduction will have you believe. Having a hard background in computer science (granted, it is over a decade old), I still found this book a very heavy read. The online help and community for ANTLR is slow or non-existent. It would be tremendously useful if the author wrote a very simple book, without the theory, and directly to applications, and concentrated on implementations on languages like JavaScript. The problem is that this book may have some pretense of being a basic book, but is very far from being basic and befuddles the reader with too much information you likely will find in a graduate text in compiler technology.

4 people found this helpful

Helpful

Larry

Where have you been all my career?!

Reviewed in the United States on July 28, 2016

Verified Purchase

For any computer scientist, there comes a moment when you need to convert languages, refactor, make small but large scale changes, parse a bunch of log and to analytics. You can do that by using Perl, regular expression of coding in your language of choice. Or you can read this book and go it 100x faster!

Working with embedded devices I never looked into how to implement a compiler, but I which I did! This book was an eye opener and timer saver, with concrete techniques on how to implement and work with trees, parsers, lexer, symbol table. This book is a must for all computer geeks. Go get Antlr4 book too https://amzn.com/1934356999!

The combination will save you lots of time and give you the edge to reach top tier and make you a guru!

7 people found this helpful

Helpful

Amazon Customer

I really liked this book

Reviewed in the United States on April 24, 2018

Verified Purchase

I really liked this book. I have read the chapter on creating a byte code interpreter and assembler many, many times. I wrote my own assembler and byte code interpreter using this book. If you want to learn how to build your on compiler or interpreter, this book is a good book. Granted, I did not use the compiler generator ANTLR for my lexer because I created my own hand-crafted interpreter. But nevertheless, the book does not focus solely on this ANTLR compiler generator. So, even if you do not use ANTLR, the book will be a valuable asset in your journey for creating a compiler. But if you do use ANTLR, even the better for you because this is the tool the author uses.

3 people found this helpful

Helpful

C. Howard

Informative and Useful, even for an Aerospace Engineer

Reviewed in the United States on November 24, 2016

Verified Purchase

Excellent book. As someone who has been curious about the inner workings of building languages and as one who builds interpreters every so often, this book really helped me learn better fundamentals to tackle this problem.

Since studying this book, I have built custom interpreters mapping data stored in a custom human readable syntax into object instances at work. This has also allowed for working on an interpreter to map voice commands into executed actions on applications. While I certainly am no expert, this book really helped bring me out of the dark into being fairly proficient at building lexers and parsers and using them in real world applications.

Note that I studied Aerospace Engineer formally and study computer science and software engineering outside of that since I love it, so you don't need to be some Computer Science or Software Engineer by education to get a lot of value out of this book.

2 people found this helpful

Helpful

Top reviews from other countries

C Seidman

I've worn this book out to a fray

Reviewed in the United Kingdom on July 28, 2019

Verified Purchase

I'm an experienced programmer who was new to compiler development. You can't expect any individual book to cover everything, so this one is one of a few compiler design books I have - but it's been the most useful one for me. The condition of the book is a testament to the extent to which it's become my "go-to" book for compiler design.

The book steers clear of fancy mathematical notation, instead, it uses clear examples and plain English explanations of otherwise complex problems. Compiler design is not easy, so it's a lot to ask that any book clears it all up for you, but I can say that I generally read this book first before attacking the same concepts in the other books which in turn makes me able to understand them better.

This book is brilliantly organized into chapters that target a specific topic regarding compiler design. So when I was attacking a problem regarding symbol tables, I found it easy to navigate to the section specifically targeting this subject. Same goes for generating bytecode, reading bytecode, managing memory, etc.

All I can say is if you're looking to construct a programming language, you shouldn't do without this book.

Sam Brown

Practical, clear and well written

Reviewed in the United Kingdom on August 16, 2012

Verified Purchase

This book is a good introduction when you want to write your own Domain Specific Language (DSL). I have several books about compiler writing and this has turned out to be the most directly useful. If I were doing this as part of a degree course, I would probably choose the Dragon book. But for my purposes, Language Implementation Patterns is far more useful. If someone wanted to learn how to implement a compiler for an actual project and just wanted nuts and bolts without too much theory, I would choose this book. It is easy to read and it concentrates on actionable programming steps rather than compiler theory. That allows you to get programming early on with small projects to get experience. Then it uses a popular compiler generator tool, ANTLR, to build more comprehensive examples. This made sense to me.

In my experience of writing compilers, the tool you use for the lexer and parser parts is only as important as getting you past those steps in the development. The more difficult part of writing a compiler is usually what you do after your language is parsed and you now have to do something with the parsed tokens. This book describes that stage as well. The book is well written and easy to read, which helps a lot. The book is medium thickness so not too daunting but substantial enough. I would recommend this book for a programmer who needs to implement a compiler or interpreter and doesn't want to get too bogged down in academic theory.

6 people found this helpful

Julio

Very good if you already know about the topic

Reviewed in the United Kingdom on November 17, 2012

Verified Purchase

Very useful book for people with a computer science background. Lots of things are taken for granted (Java, grammar definition, data structures, ...).

If you have used flex/bison (yacc/lex) this book will open your eyes to new modern technologies for language implementation

I find the writing style quite refreshing. I never felt bored while reading the book. The way the book is organized into patterns make it very easy to consume. Once you get used to the structure it is very easy to jump back and forth looking for the pattern that will solve your problem.

I'd recommend it to professionals rather than programming hobbyists.

Perfect in combination with the "dragon" book.

2 people found this helpful

Michal Pryslopski

I've never considered creating a custom programming language until I read this book and my projects benefited a lot since then

Reviewed in the United Kingdom on June 5, 2014

Verified Purchase

The biggest gain from reading this book is that it adds to your toolbox of programming techniques one often not even considered: custom, domain-specific programming language.

Creating a language seems at first like a daunting task that takes a lifespan but this book shows that it is not, especially if you need it just for giving some extra power to configuration scripts, in-application macros and the like.

This book presents in details, one by one, all the algorithms needed to read and execute a source code written in your own language.

You don't need knowledge of formal grammars and the like to use this book but it'd help. Or this book might be an inspiration to learn more.

Amazon Customer

Great Book

Reviewed in the United Kingdom on September 12, 2018

Verified Purchase

Just need to read the parts I need

See all reviews

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

Frequently bought together

Customers who viewed this item also viewed

From the brand

Explore our collections