-16% ¥5,091¥5,091 税込
ポイント: 51pt
(1%)
配送料 ¥257 6月22日-7月3日にお届け
発送元: SuperBookDeals_ 販売者: SuperBookDeals_
¥3,367¥3,367 税込
配送料 ¥240 6月10日-12日にお届け
発送元: バリューブックス 【防水梱包で、丁寧に発送します】 販売者: バリューブックス 【防水梱包で、丁寧に発送します】
無料のKindleアプリをダウンロードして、スマートフォン、タブレット、またはコンピューターで今すぐKindle本を読むことができます。Kindleデバイスは必要ありません。
ウェブ版Kindleなら、お使いのブラウザですぐにお読みいただけます。
携帯電話のカメラを使用する - 以下のコードをスキャンし、Kindleアプリをダウンロードしてください。
Language Implementation Patterns: Create Your Own Domain-Specific and General Programming Languages (Pragmatic Programmers) ペーパーバック – 2010/1/19
購入オプションとあわせ買い
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.
- 本の長さ380ページ
- 言語英語
- 出版社Pragmatic Bookshelf
- 発売日2010/1/19
- 寸法19.15 x 1.91 x 23.11 cm
- ISBN-10193435645X
- ISBN-13978-1934356456
商品の説明
レビュー
""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
著者について
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.
登録情報
- 出版社 : Pragmatic Bookshelf; 第1版 (2010/1/19)
- 発売日 : 2010/1/19
- 言語 : 英語
- ペーパーバック : 380ページ
- ISBN-10 : 193435645X
- ISBN-13 : 978-1934356456
- 寸法 : 19.15 x 1.91 x 23.11 cm
- Amazon 売れ筋ランキング: - 300,104位洋書 (洋書の売れ筋ランキングを見る)
- - 18位Compiler Design
- - 126位Software Programming Compilers
- - 1,354位Software Development
- カスタマーレビュー:
著者について
著者の本をもっと発見したり、よく似た著者を見つけたり、著者のブログを読んだりしましょう
-
トップレビュー
上位レビュー、対象国: 日本
レビューのフィルタリング中に問題が発生しました。後でもう一度試してください。
ならない人なら(量は多いが)この本を読むのが最速だろう。研究者でも出典引用が沢山あるので、プログラムを書きながら随時論文を取り寄せるのも
いいかもしれない。
他の国からのトップレビュー
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.
Ich würde das Buch immer wieder kaufen.