Buy new:
-48% $18.21
FREE delivery Friday, July 26 on orders shipped by Amazon over $35
Ships from: Amazon
Sold by: EXISTENCE
$18.21 with 48 percent savings
List Price: $34.95

The List Price is the suggested retail price of a new product as provided by a manufacturer, supplier, or seller. Except for books, Amazon will display a List Price if the product was purchased by customers on Amazon or offered by other retailers at or above the List Price in at least the past 90 days. List prices may not necessarily reflect the product's prevailing market price.
Learn more
FREE pickup Friday, July 26 on orders shipped by Amazon over $35

1.27 mi | ASHBURN 20147

How pickup works
Pick up from nearby pickup location
Step 1: Place Your Order
Select the “Pickup” option on the product page or during checkout.
Step 2: Receive Notification
Once your package is ready for pickup, you'll receive an email and app notification.
Step 3: Pick up
Bring your order ID or pickup code (if applicable) to your chosen pickup location to pick up your package.
Only 1 left in stock - order soon.
$$18.21 () Includes selected options. Includes initial monthly payment and selected options. Details
Price
Subtotal
$$18.21
Subtotal
Initial payment breakdown
Shipping cost, delivery date, and order total (including tax) shown at checkout.
Sold by
EXISTENCE
Sold by
EXISTENCE
Returns
Eligible for Return, Refund or Replacement within 30 days of receipt
Eligible for Return, Refund or Replacement within 30 days of receipt
Returnable Yes
Resolutions Eligible for refund or replacement
Return Window 30 days from delivery
Refund Timelines Typically, an advance refund will be issued within 24 hours of a drop-off or pick-up. For returns that require physical verification, refund issuance may take up to 30 days after drop-off or pick up. Where an advance refund is issued, we will re-charge your payment method if we do not receive the correct item in original condition. See details here.
Late fee A late fee of 20% of the item price will apply if you complete the drop off or pick up after the ‘Return By Date’.
Restocking fee A restocking fee may apply if the item is not returned in original condition and original packaging, or is damaged or missing parts for reasons not due to Amazon or seller error. See details here.
Returns
Eligible for Return, Refund or Replacement within 30 days of receipt
Returnable Yes
Resolutions Eligible for refund or replacement
Return Window 30 days from delivery
Refund Timelines Typically, an advance refund will be issued within 24 hours of a drop-off or pick-up. For returns that require physical verification, refund issuance may take up to 30 days after drop-off or pick up. Where an advance refund is issued, we will re-charge your payment method if we do not receive the correct item in original condition. See details here.
Late fee A late fee of 20% of the item price will apply if you complete the drop off or pick up after the ‘Return By Date’.
Restocking fee A restocking fee may apply if the item is not returned in original condition and original packaging, or is damaged or missing parts for reasons not due to Amazon or seller error. See details here.

Return instructions

Item must be in original condition and packaging along with tag, accessories, manuals, and inserts. Unlock any electronic device, delete your account and remove all personal information.
Read full return policy
Payment
Secure transaction
Your transaction is secure
We work hard to protect your security and privacy. Our payment security system encrypts your information during transmission. We don’t share your credit card details with third-party sellers, and we don’t sell your information to others. Learn more
Payment
Secure transaction
We work hard to protect your security and privacy. Our payment security system encrypts your information during transmission. We don’t share your credit card details with third-party sellers, and we don’t sell your information to others. Learn more
Kindle app logo image

Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.

Read instantly on your browser with Kindle for Web.

Using your mobile phone camera - scan the code below and download the Kindle app.

QR code to download the Kindle App

Follow the author

Terence Parr
Follow
Something went wrong. Please try your request again later.

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

by Terence Parr (Author)
See all formats and editions
{"desktop_buybox_group_1":[{"displayPrice":"$18.21","priceAmount":18.21,"currencySymbol":"$","integerValue":"18","decimalSeparator":".","fractionalValue":"21","symbolPosition":"left","hasSpace":false,"showFractionalPartIfEmpty":true,"offerListingId":"Lu7NN8nEbmQqR%2FiMtffT5aCOGxj3NJJV6SwP3Ggug2qzf%2FXto7OsG%2BZCmfJ25uhWezd5FebGgaEDIMwv8GlHFANqJ9AuLgVUtZnU39A0N0EipOGo1vSZtGCUtDeoYEjaYjSAZTNtHbXuqOcaXFnvUZw5mwS8vdN4qsYb0QKacWk30gOPRV4wxicYGHJQQ3MQ","locale":"en-US","buyingOptionType":"NEW","aapiBuyingOptionIndex":0}, {"displayPrice":"$12.84","priceAmount":12.84,"currencySymbol":"$","integerValue":"12","decimalSeparator":".","fractionalValue":"84","symbolPosition":"left","hasSpace":false,"showFractionalPartIfEmpty":true,"offerListingId":"Lu7NN8nEbmQqR%2FiMtffT5aCOGxj3NJJVWgKsY7h3dhcLDLnl8hHNICyrRGaOjPOrQxf9c%2B5tXj9nU5yv%2FwU7SLzB1x%2Bd0X114XJVUR4O%2FUyMAVf7RD6y3JF3YKcepHUFTJmT1TJZ1Qk45ePu23qUuV57Pjs%2Fi5oKuxwyASABRDKUVJiW3vFz0O3nyPXws2N%2F","locale":"en-US","buyingOptionType":"USED","aapiBuyingOptionIndex":1}],"desktop_buybox_group_2":[{"displayPrice":"$18.21","priceAmount":18.21,"currencySymbol":"$","integerValue":"18","decimalSeparator":".","fractionalValue":"21","symbolPosition":"left","hasSpace":false,"showFractionalPartIfEmpty":true,"offerListingId":"Lu7NN8nEbmQqR%2FiMtffT5aCOGxj3NJJV6SwP3Ggug2qzf%2FXto7OsG%2BZCmfJ25uhWezd5FebGgaEDIMwv8GlHFANqJ9AuLgVUtZnU39A0N0EipOGo1vSZtGCUtDeoYEjaYjSAZTNtHbXuqOcaXFnvUZw5mwS8vdN4qsYb0QKacWk30gOPRV4wxicYGHJQQ3MQ","locale":"en-US","buyingOptionType":"PICKUP","aapiBuyingOptionIndex":2}]}

Purchase options and add-ons

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.
Previous slide of product details
  1. ISBN-10
    193435645X
  2. ISBN-13
    978-1934356456
  3. Edition
    1st
  4. Publisher
    Pragmatic Bookshelf
  5. Publication date
    February 9, 2010
  6. Language
    English
  7. Dimensions
    7.54 x 0.75 x 9.1 inches
  8. Print length
    374 pages
  9. See all details
Next slide of product details
Amazon First Reads | Editors' picks at exclusive prices

Frequently bought together

Language Implementation Patterns: Create Your Own Domain-Specific and General Programming Languages (Pragmatic Programmers)
$18.21
Get it as soon as Friday, Jul 26
Only 1 left in stock - order soon.
Sold by EXISTENCE and ships from Amazon Fulfillment.
+
The Definitive ANTLR 4 Reference
$31.23
Get it as soon as Friday, Jul 26
Only 1 left in stock - order soon.
Sold by Burlington MA- Used Book Superstore -new books too and ships from Amazon Fulfillment.
+
Crafting Interpreters
$44.49
Get it as soon as Thursday, Jul 25
In Stock
Ships from and sold by Amazon.com.
Total price:
To see our price, add these items to your cart.
Details
Added to Cart
Some of these items ship sooner than the others.
Show details Hide details
Choose items to buy together.

Customers who bought this item also bought

Page 1 of 1 Start overPage 1 of 1
Previous page
  1. The Definitive ANTLR 4 Reference
    Terence Parr
    4.6 out of 5 stars 167
    Paperback
    $31.23
    Get it as soon as Friday, Jul 26
    FREE Shipping on orders over $35 shipped by Amazon
    Only 1 left in stock - order soon.
  2. Crafting Interpreters
  3. Programming Language Pragmatics
    Michael Scott
    4.2 out of 5 stars 85
    Paperback
    $62.07
    Get it Jul 25 - 26
    FREE Shipping
    Only 8 left in stock - order soon.
  4. Domain-Specific Languages (Addison-Wesley Signature Series (Fowler))
    Martin Fowler
    4.3 out of 5 stars 72
    Hardcover
    34% off
    Limited time deal
    $39.60
    List: $59.99
    Get it as soon as Friday, Jul 26
    FREE Shipping by Amazon
    Only 8 left in stock - order soon.
    33% Claimed
  5. Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems
  6. Patterns of Enterprise Application Architecture
    Martin Fowler
    4.5 out of 5 stars 790
    Hardcover
    $66.49
    Get it as soon as Thursday, Jul 25
    FREE Shipping by Amazon
Next page

From the brand

Previous page
  2. A Common-Sense Guide to Data Structures and Algorithms, Second Edition: Level Up Your Core Progra...
    Your Code as a Crime Scene, Second Edition: Use Forensic Techniques to Arrest Defects, Bottleneck...
    Agile Retrospectives, Second Edition: A Practical Guide for Catalyzing Team Learning and Improvement
    Programming Ruby 3.3: The Pragmatic Programmers' Guide (Pragmatic Programmers; Facets of Ruby)

    Explore our collections

    Visit the Store

  3. For Developers, By Developers

    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.

Next page

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.

Product details

  • Publisher ‏ : ‎ Pragmatic Bookshelf; 1st edition (February 9, 2010)
  • Language ‏ : ‎ English
  • Paperback ‏ : ‎ 374 pages
  • ISBN-10 ‏ : ‎ 193435645X
  • ISBN-13 ‏ : ‎ 978-1934356456
  • Item Weight ‏ : ‎ 1.57 pounds
  • Dimensions ‏ : ‎ 7.54 x 0.75 x 9.1 inches
  • Customer Reviews:

About the author

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

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

4.4 out of 5 stars
4.4 out of 5
135 global ratings

Customers say

Customers find the book didactic, concise, and well organized. They also appreciate the practical attitude and clear code examples.

AI-generated from the text of customer reviews

Select to learn more
ComplexityReadability
16 customers mention "Complexity"14 positive2 negative

Customers find the book complex, but say it's well-written and practical. They also appreciate the good theoretical foundation and precise explanations.

"...LIP is the perfect mix of theory and practice. LIP is the working ACID I did not write...." Read more

"...Even if one will not use ANTLR, the books are valuable for their overview and in depth discussion of writing compilers and parsers...." Read more

"...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...." Read more

"This book gives some good theoretical foundation for programming language implementation patterns, but many of the examples are tightly coupled to..." Read more

10 customers mention "Readability"10 positive0 negative

Customers find the book concise, clear, and organized. They also say it's informative, useful, and not math intensive.

"...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..." Read more

"...them I doubt you will ever find this book useful, not mentioning, well written." Read more

"...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..." Read more

"...aspects of Compilers and other Language Applications into easy to understand patterns. Very useful...." Read more

Ripped off - same cover different book
1 out of 5 stars
Ripped off - same cover different book
Received a book with the right cover but inside it is actually a book called "A New Introduction to Islam".
Hide
Thank you for your feedback
Sorry, there was an error
Sorry we couldn't load the review

Top reviews from the United States

A Reader
5.0 out of 5 stars Best book on ANTLR
Reviewed in the United States on November 11, 2023
Verified Purchase
Although dated established the basis for domain specific language details
Helpful
 Report
Wayne K Dawson
4.0 out of 5 stars 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
 Report
Victor Noagbodji
5.0 out of 5 stars The perfect mix of theory and practice.
Reviewed in the United States on November 5, 2010
Verified Purchase
In high school I created ACID1, an interpreter 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.
24 people found this helpful
Helpful
 Report
BookLover
5.0 out of 5 stars Great book for those who want to write and exploit parsing technology
Reviewed in the United States on June 8, 2015
Verified Purchase
This is a great book for those who want to learn how to write and exploit parsing technology to create DSL (domain specific languages) and transform programs using parsing technology when regular expressions won't do the job or are too complex to be coded easily.

The book discusses many aspects of compiler technology and interpreter technology. It will help you write a compiler or interpreter using ANTLR3. It goes in depth into the many things you need to know such as - LL(1), LL(k), and LL(*) parsers and symbol tools.

The book instructs one in how to use ANTLR - which is the lexer/parser generator which the author of the book makes freely available. ANTLR is the most powerful generator on the market today and used by many companies such as Oracle.

To get the most from this informative book, you should also buy "The Definitive ANLTR 4 Reference" which Amazon also sells.

Parr is a genius. He has produced the definitive parser generator and the definitive books that enable one to use this generator. Even if one will not use ANTLR, the books are valuable for their overview and in depth discussion of writing compilers and parsers.

Note that the book does not discuss some things necessary for writing a world class compiler such as register allocation. I'm using it to write translators from one language to another and in that application its advice is spot on and extremely helpful.
6 people found this helpful
Helpful
 Report
Zhan
4.0 out of 5 stars Did not realize that this book is an other version ...
Reviewed in the United States on December 26, 2017
Verified Purchase
Did not realize that this book is an other version for ANTLR3. But it has something that the new version does not have which I believe helps understanding of a simple compiler.
One person found this helpful
Helpful
 Report

Top reviews from other countries

Translate all reviews to English
s.py
5.0 out of 5 stars Arrivée éclair et en excellent état
Reviewed in France on March 6, 2022
Verified Purchase
Tout est dans le titre. Pour le reste, je savais ce que j'achetais et c'est un livre indispensable dans le domaine. Livre en anglais bien sûr.
Report
jamm
5.0 out of 5 stars Especialmente interesante para la escritura de DSL
Reviewed in Spain on November 21, 2019
Verified Purchase
Muy buena referencia para los interesados en el desarrollo de pequeños lenguajes específicos de dominios. Un complemento ideal de la referencia para ANTL de los mismos autores
Report
Vaibhav Sunder
3.0 out of 5 stars Not too much
Reviewed in India on March 10, 2019
Verified Purchase
Except TREE walking and similar concepts, the book had general matter
Report
Mike S.
4.0 out of 5 stars The premise of the book is that there are useful "patterns" (software design patterns) in language applications and that ...
Reviewed in Canada on November 26, 2015
Verified Purchase
The premise of the book is that there are useful "patterns" (software design patterns) in language applications and that the author will highlight them and make them relevant to practical language developers. It's not a compiler theory book by any stretch. In fact, the author concedes immediately that the focus is more on specialized languages such as file descriptions (i.e. XLST, SVG) then generalized programming languages. This seems reasonable.

The book can roughly be considered in two halves (not equal in page count) - the first half is about parsing the language to some type of intermediate representation (IR) and the second half is doing something with that IR.

First, the negative(s): The first half of the book has some serious issues with being relevant to the proposed target audience because the focus is basically on using automated grammer tools (ANTLR) for parsing and going to a generic tree format for the IR. Most people writing simple file parsers for things like JSON, XML etc. are unlikely to ever use a tool like ANTLR (even tho it is a wonderful tool) for a whole slew of reasons including:

* The need to learn the ANTLR grammar. Most developers haven't spent much time thinking about formal grammars since University (i.e. BnF) which means you pray the language applications nut on your team who integrated ANTLR into your commercial code base doesn't quit tomorrow.
* The performance and memory overheads of doing multi-stage parsing / IR generation. Parsing something like a GB's worth of XML can take minutes even on a modern computer / smart phone etc.
* The complexity of aiming for a low-level abstract IR. Abstract IRs might be helpful for porting a language to multiple backends, but realistically very few application developers have this requirement. Thus a specialized and high level IR can be far more practical to work with.
* Most file format languages etc. have to deal with malformed input. For example, real-world HTML parsing is as much \about correcting missing tags, conflicting version features usage etc. than getting from a perfect input to an abstract IR. It's pretty hard to address this with any formal grammar parser generator. Yes you could try to preprocess your input before going with your generated parser, but trust me, you'll just end up writing a partial parser implementation and adding extra complexity as a result.

So that makes the first half of the book more relevant to maybe students or hobbyists interested in experimenting with language applications, but less relevant to the average application developer. What isn't ANTLR in the first half is just second year CS material for the most part.

The second half of the book is more practical and better suited to the proposed audience (starting with approx. Ch6 "Tracking and Identifying Program Symbols") because it loses the the focus on a single approach and mostly surveys a wide variety of things you can do with your IR after parsing as well as addressing common challenges like enforcing static types. The interpreter introductions are a nice starting point for someone who has to implement a simple scripting language.

We have pretty slim pickings for books on language applications that aren't meant to be CS course textbooks. As such, this book gets a modest recommendation if you are attempting to implement a simple scripting language because there's enough useful material in the second half that most developers will get something helpful out of it.
3 people found this helpful
 Report
Kristian
5.0 out of 5 stars Sehr empfehlenswertes Buch
Reviewed in Germany on September 21, 2012
Verified Purchase
Ich kann das Buch nur jedem empfehlen, der sich mit den Themen Lexer, Parser, Interpreter, ... auseinander setzen will oder muss. Die beschrieben Verfahren und Beispiele sind sehr hilfreich und verständlich. Die Umsetzung in praktischen Anwendungen ist sehr einfach möglich. Zwar sind die Beispiele in Java geschrieben, aber eine Umsetzung in andere Programmiersprachen ist sehr einfach möglich.

Ich würde das Buch immer wieder kaufen.
2 people found this helpful
 Report