When carefully selected and used, Domain-Specific Languages (DSLs) may simplify complex code, promote effective communication with customers, improve productivity, and unclog development bottlenecks. In Domain-Specific Languages, noted software development expert Martin Fowler first provides the information software professionals need to decide if and when to utilise DSLs. Then, where DSLs prove suitable, Fowler presents effective techniques for building them, and guides software engineers in choosing the right approaches for their applications. This book s techniques may be utilised with most modern object-oriented languages; the author provides numerous examples in Java and C#, as well as selected examples in Ruby. Wherever possible, chapters are organised to be self-standing, and most reference topics are presented in a familiar patterns format.

Armed with this wide-ranging book, developers will have the knowledge they need to make important decisions about DSLs and, where appropriate, gain the significant technical and business benefits they offer.

The topics covered include:

• How DSLs compare to frameworks and libraries, and when those alternatives are sufficient
• Using parsers and parser generators, and parsing external DSLs
• Understanding, comparing, and choosing DSL language constructs
• Determining whether to use code generation, and comparing code generation strategies
• Previewing new language workbench tools for creating DSLs

Martin Fowlers breakthrough practitioner-oriented book onDomain Specific Languages - will do for DSLs what Fowlerdid for refactoring.

Autorentext
Martin Fowler is Chief Scientist at ThoughtWorks. He describes himself as “an author, speaker, consultant, and general loudmouth on software development. I concentrate on designing enterprise software—looking at what makes a good design and what practices are needed to come up with good design.” Fowler’s books include Patterns of Enterprise Application Architecture; UML Distilled, Third Edition; and (with Kent Beck, John Brant, and William Opdyke) Refactoring: Improving the Design of Existing Code. All are published by Addison-Wesley.

Inhalt
Preface                            xix  

Part I: Narratives                                              1

Chapter 1: An Introductory Example                             3

Gothic Security         3

The State Machine Model        5

Programming Miss Grant’s Controller         9

Languages and Semantic Model          16

Using Code Generation         19

Using Language Workbenches         22

Visualization        24

Chapter 2: Using Domain-Specific Languages                            27

Defining Domain-Specific Languages         27

Why Use a DSL?         33

Problems with DSLs         36

Wider Language Processing         39

DSL Lifecycle        40

What Makes a Good DSL Design?       42

Chapter 3: Implementing DSLs                                   43

Architecture of DSL Processing           43

The Workings of a Parser          47

Grammars, Syntax, and Semantics        49

Parsing Data        50

Macros       52

Chapter 4: Implementing an Internal DSL                         67

Fluent and Command-Query APIs          68

The Need for a Parsing Layer         71

Using Functions         72

Literal Collections       77

Using Grammars to Choose Internal Elements       79

Closures       80

Parse Tree Manipulation       82

Annotation       84

Literal Extension      85

Reducing the Syntactic Noise         85

Dynamic Reception         86

Providing Some Type Checking      87

Chapter 5: Implementing an External DSL                                 89

Syntactic Analysis Strategy          89

Output Production Strategy        92

Parsing Concepts        94

Mixing-in Another Language        100

XML DSLs        101

Chapter 6: Choosing between Internal and External DSLs                      105

Learning Curve       105

Cost of Building        106

Programmer Familiarity       107

Communication with Domain Experts         108

Mixing In the Host Language        108

Strong Expressiveness Boundary        109

Runtime Configuration        110

Sliding into Generality       110

Composing DSLs       111

Summing Up        111

Chapter 7: Alternative Computational Models                           113

A Few Alternative Models        116

Chapter 8: Code Generation                                            121

Choosing What to Generate         122

How to…