summersale2015 Hier klicken Jetzt Mitglied werden studentsignup Cloud Drive Photos UHD TVs Learn More HI_PROJECT Fire HD 6 Shop Kindle Artist Spotlight SummerSale
In weniger als einer Minute können Sie mit dem Lesen von Language Implementation Patterns: Create Your Own Domain-... auf Ihrem Kindle beginnen. Sie haben noch keinen Kindle? Hier kaufen oder mit einer unserer kostenlosen Kindle Lese-Apps sofort zu lesen anfangen.

An Ihren Kindle oder ein anderes Gerät senden

 
 
 

Kostenlos testen

Jetzt kostenlos reinlesen

An Ihren Kindle oder ein anderes Gerät senden

Der Artikel ist in folgender Variante leider nicht verfügbar
Keine Abbildung vorhanden für
Farbe:
Keine Abbildung vorhanden
 

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

Terence Parr
5.0 von 5 Sternen  Alle Rezensionen anzeigen (4 Kundenrezensionen)

Kindle-Preis: EUR 19,51 Inkl. MwSt. und kostenloser drahtloser Lieferung über Amazon Whispernet

Kostenlose Kindle-Leseanwendung Jeder kann Kindle Bücher lesen  selbst ohne ein Kindle-Gerät  mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.

Geben Sie Ihre E-Mail-Adresse oder Mobiltelefonnummer ein, um die kostenfreie App zu beziehen.

Weitere Ausgaben

Amazon-Preis Neu ab Gebraucht ab
Kindle Edition EUR 19,51  
Taschenbuch EUR 22,95  

Kunden, die diesen Artikel gekauft haben, kauften auch

Seite von Zum Anfang
Diese Einkaufsfunktion wird weiterhin Artikel laden. Um aus diesem Karussell zu navigieren, benutzen Sie bitte Ihre Überschrift-Tastenkombination, um zur nächsten oder vorherigen Überschrift zu navigieren.

Produktbeschreibungen

Pressestimmen

""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

Kurzbeschreibung

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.


Produktinformation

  • Format: Kindle Edition
  • Dateigröße: 1341 KB
  • Seitenzahl der Print-Ausgabe: 374 Seiten
  • Gleichzeitige Verwendung von Geräten: Keine Einschränkung
  • Verlag: Pragmatic Bookshelf; Auflage: 1 (31. Dezember 2009)
  • Verkauf durch: Amazon Media EU S.à r.l.
  • Sprache: Englisch
  • ASIN: B00A376HGG
  • Text-to-Speech (Vorlesemodus): Aktiviert
  • X-Ray:
  • Word Wise: Nicht aktiviert
  • Erweiterte Schriftfunktion: Nicht aktiviert
  • Durchschnittliche Kundenbewertung: 5.0 von 5 Sternen  Alle Rezensionen anzeigen (4 Kundenrezensionen)
  • Amazon Bestseller-Rang: #154.944 Bezahlt in Kindle-Shop (Siehe Top 100 Bezahlt in Kindle-Shop)

  •  Ist der Verkauf dieses Produkts für Sie nicht akzeptabel?

Mehr über den Autor

Entdecken Sie Bücher, lesen Sie über Autoren und mehr

Welche anderen Artikel kaufen Kunden, nachdem sie diesen Artikel angesehen haben?


Kundenrezensionen

4 Sterne
0
3 Sterne
0
2 Sterne
0
1 Sterne
0
5.0 von 5 Sternen
5.0 von 5 Sternen
Die hilfreichsten Kundenrezensionen
21 von 21 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Praxisrelevant, verständlich, guter Einstieg 22. August 2010
Format:Taschenbuch
Ein sehr gutes Buch, leicht verständlich und doch mit ausreichender Tiefe.

Im Vergleich zu vielen (vor allem älteren Werken), z.B. dem berühmten "Roter-Drachen"-Buch ist es deutlich moderner. Es besitzt eindeutig den Anspruch, auch theoretisch vielleicht nicht sehr vorgebildeten Software-Entwicklern zu ermöglichen, domänenspezifische Sprachen, einfache Interpreter, Bytecode-Compiler usw. zu bauen.

Für die meisten Probleme der Sprachentwicklung bietet das Buch einen ausreichenden Umfang und selbst wenn man eine anspruchsvollere Aufgabe hat (sagen wir, C++ neu zu erfinden), weiß man nach dem Lesen dieses Buches zumindest die nötigen Begrifflichkeiten und Grundkenntnisse, um tiefer einzusteigen.

Der Fokus liegt eindeutig auf dem praktischen Einsatz. Wer Sprachtheorie, Formalismen und mathematische Beschreibungen in ihrer ganzen Pracht sehen möchte, sollte ein anderes Buch kaufen. Wer verstehen möchte, wie ein Parser/Interpreter/Compiler funktioniert, um seinen eigenen schreiben zu können, findet in dem Buch alles, was er braucht.
War diese Rezension für Sie hilfreich?
10 von 13 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Tolles Buch 1. Dezember 2010
Format:Taschenbuch
Ich will keine Romane schreiben. Mir hat das Buch unheimlich geholfen. Fantastisch wenn man sich für Compiler/Interpreter interessiert und sich nicht die abartig hochgestochene Fachliteratur deutscher Professoren antun will. Bei diesem Buch hat man nicht den Eindruck dass es sich um eine Geheimwissenschaft handelt.
War diese Rezension für Sie hilfreich?
1 von 2 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Sehr empfehlenswertes Buch 21. September 2012
Von Kristian
Format:Taschenbuch|Verifizierter Kauf
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.
War diese Rezension für Sie hilfreich?
2 von 4 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Good 8. Oktober 2011
Format:Taschenbuch
Very good book. Easy to read and understanding.
Recommended for one who want to learn Domain Specific Language (DSL).
Another recommended book is ANTLR 3
War diese Rezension für Sie hilfreich?
Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)
Amazon.com: 4.5 von 5 Sternen  24 Rezensionen
33 von 36 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen A must have for developers 4. Juni 2010
Von German Viscuso - Veröffentlicht auf Amazon.com
Format:Taschenbuch
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 =)
12 von 12 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen The perfect mix of theory and practice. 5. November 2010
Von K. Noagbodji - Veröffentlicht auf Amazon.com
Format:Taschenbuch|Verifizierter Kauf
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.
30 von 36 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Language Design for the rest of us 7. Januar 2010
Von K. Ferrio - Veröffentlicht auf Amazon.com
Format:Taschenbuch
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.
19 von 22 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Way better than sifting through textbooks 17. März 2010
Von Adam Keys - Veröffentlicht auf Amazon.com
Format:Taschenbuch
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.
28 von 37 Kunden fanden die folgende Rezension hilfreich
3.0 von 5 Sternen Too specific to be a patterns book 17. Februar 2010
Von Joel Redman - Veröffentlicht auf Amazon.com
Format:Taschenbuch
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.
Waren diese Rezensionen hilfreich?   Wir wollen von Ihnen hören.
Kundenrezensionen suchen
Nur in den Rezensionen zu diesem Produkt suchen

Kunden diskutieren

Das Forum zu diesem Produkt
Diskussion Antworten Jüngster Beitrag
Noch keine Diskussionen

Fragen stellen, Meinungen austauschen, Einblicke gewinnen
Neue Diskussion starten
Thema:
Erster Beitrag:
Eingabe des Log-ins
 

Kundendiskussionen durchsuchen
Alle Amazon-Diskussionen durchsuchen
   


Ähnliche Artikel finden