DSLs in Action

Front cover......Page 1
brief contents......Page 7
contents......Page 8
foreword......Page 14
preface......Page 16
acknowledgments......Page 18
about the book......Page 20
Roadmap......Page 21
Typographical conventions......Page 23
Author Online......Page 24
About the cover illustration......Page 25
Part 1 - Introducing domain-specific languages......Page 26
Learning to speak the language of the domain......Page 28
1.1.2 The solution domain......Page 29
1.2 Domain modeling: establishing a common vocabulary......Page 31
1.2.1 Benefits of a common vocabulary......Page 32
1.3 Introducing DSLs......Page 33
1.3.1 WhatÆs a DSL?......Page 35
1.3.2 Popular DSLs in use......Page 37
1.3.3 Structure of a DSL......Page 39
1.4 Execution model of a DSL......Page 40
1.5 Classifying DSLs......Page 42
1.5.2 External DSLs......Page 43
1.5.3 Nontextual DSLs......Page 44
1.6.1 The advantages......Page 45
1.6.2 The disadvantages......Page 46
1.7 DSLs and abstraction design......Page 47
1.8 Summary......Page 48
1.9 References......Page 49
The DSL in the wild......Page 50
2.1 Building your first Java DSL......Page 51
2.1.1 Setting up the common vocabulary......Page 52
2.1.2 Your first Java implementation......Page 53
2.2.1 Externalizing the domain with XML......Page 57
2.2.2 Groovy: a more expressive implementation language......Page 58
2.2.3 Executing the Groovy DSL......Page 60
2.3 DSL implementation patterns......Page 61
2.3.1 Internal DSL patterns: commonality and variability......Page 62
2.3.2 External DSL patterns: commonality and variability......Page 70
2.4 Choosing DSL implementations......Page 75
2.5 Summary......Page 77
2.6 References......Page 78
DSL-driven application development......Page 79
3.1 Exploring DSL integration......Page 80
3.1.1 Why you should care about DSL integration......Page 81
3.2 Internal DSL integration patterns......Page 83
3.2.1 Using the Java 6 scripting engine......Page 85
3.2.2 Using a DSL wrapper......Page 89
3.2.3 Language-specific integration features......Page 98
3.2.4 Spring-based integration......Page 100
3.3 External DSL integration patterns......Page 101
3.4 Handling errors and exceptions......Page 103
3.4.1 Naming an exception......Page 104
3.4.2 Handling incorrect typing errors......Page 105
3.4.3 Handling exceptional business conditions......Page 106
3.5 Managing performance......Page 107
3.6 Summary......Page 108
3.7 References......Page 109
Part 2 - Implementing DSLs......Page 110
Internal DSL implementation patterns......Page 112
4.1 Filling your DSL toolbox......Page 113
4.2 Embedded DSLs: patterns in metaprogramming......Page 115
4.2.1 Implicit context and Smart APIs......Page 116
4.2.2 Reflective metaprogramming with dynamic decorators......Page 121
4.2.3 Reflective metaprogramming with builders......Page 127
4.2.4 Lessons learned: metaprogramming patterns......Page 130
4.3.1 Higher-order functions as generic abstractions......Page 131
4.3.2 Using explicit type constraints to model domain logic......Page 138
4.3.3 Lessons learned: thinking in types......Page 142
4.4.1 How generative DSLs work......Page 143
4.4.2 Ruby metaprogramming for concise DSL design......Page 144
4.5.1 Metaprogramming with Clojure......Page 147
4.5.2 Implementing the domain model......Page 148
4.5.3 The beauty of Clojure macros......Page 150
4.6 Summary......Page 151
4.7 References......Page 152
Internal DSL design in Ruby, Groovy, and Clojure......Page 153
5.1 Making DSLs concise with dynamic typing......Page 154
5.1.1 Readability......Page 155
5.1.2 Duck typing......Page 156
5.1.3 Metaprogramming-again!......Page 158
5.1.4 Why Ruby, Groovy, and Clojure?......Page 159
5.2 A trade-processing DSL in Ruby......Page 160
5.2.1 Getting started with an API......Page 161
5.2.2 A little bit of monkey-patching......Page 164
5.2.3 Rolling out a DSL interpreter......Page 165
5.2.4 Adding domain rules as decorators......Page 168
5.3.1 The order-processing DSL so far......Page 173
5.3.2 Controlling the scope of metaprogramming......Page 174
5.3.3 Rounding it off......Page 177
5.4 Thinking differently in Clojure......Page 178
5.4.1 Building a domain object......Page 179
5.4.2 Enriching domain objects using decorators......Page 180
5.4.3 A DSL session at the REPL......Page 186
5.5.2 Strive for optimal expressivity......Page 187
5.5.4 Avoid language cacophony......Page 188
5.6 Summary......Page 189
5.7 References......Page 190
Internal DSL design in Scala......Page 191
6.1 Why Scala?......Page 192
6.2.1 Testing Java objects with a Scala DSL......Page 194
6.3 LetÆs DSL in Scala!......Page 195
6.3.1 Expressive syntax on the surface......Page 196
6.3.2 Creating domain abstractions......Page 197
6.4 Building a DSL that creates trades......Page 200
6.4.1 Implementation details......Page 202
6.4.2 Variations in DSL implementation patterns......Page 206
6.5 Modeling business rules with a DSL......Page 207
6.5.1 Pattern matching as an extensible Visitor......Page 208
6.5.2 Enriching the domain model......Page 209
6.5.3 Calculating tax and fee business rules in a DSL......Page 212
6.6.1 More abstraction with traits and types......Page 215
6.6.2 Making domain components concrete......Page 217
6.7 Composing DSLs......Page 218
6.7.1 Composing using extensions......Page 219
6.7.2 Composing different DSLs using hierarchical composition......Page 224
6.8 Monadic structures in DSL......Page 228
6.9 Summary......Page 233
6.10 References......Page 234
External DSL implementation artifacts......Page 236
7.1.1 The simplest option first......Page 237
7.1.2 Abstracting the domain model......Page 238
7.2.1 Parsers and parser generators......Page 242
7.2.2 Syntax-directed translation......Page 244
7.3 Classifying parsers......Page 250
7.3.1 Simple top-down parsers......Page 251
7.3.2 Advanced top-down parsers......Page 253
7.3.3 Bottom-up parsers......Page 254
7.4 Tool-based DSL development with Xtext......Page 256
7.4.1 Grammar rules and the outline view......Page 257
7.4.2 The metamodel for your grammar......Page 258
7.4.3 Generating code for the semantic model......Page 261
7.5 Summary......Page 263
7.6 References......Page 264
Designing external DSLs using Scala parser combinators......Page 266
8.1 Parser combinators......Page 267
8.1.1 What are parser combinators?......Page 268
8.1.2 Designing DSLs the parser combinator way......Page 269
8.2 The Scala parser combinator library......Page 271
8.2.1 The base abstractions in the parser combinator library......Page 272
8.2.2 The combinators that glue parsers together......Page 273
8.2.3 Monads for DSL parser composition......Page 277
8.2.4 Packrat parsing for left recursive DSL syntax......Page 279
8.3 DSL design with parser combinators: step-by-step......Page 282
8.3.1 Step 1: Executing the grammar......Page 283
8.3.2 Step 2: Building the semantic model for the DSL......Page 284
8.3.3 Step 3: Designing the Order abstraction......Page 285
8.3.4 Step 4: Generating the AST using function application combinators......Page 286
8.4.1 Introducing the domain problem......Page 289
8.4.2 Building the grammar......Page 291
8.4.3 Designing the semantic model......Page 293
8.4.4 Parser composition for extending DSL semantics......Page 295
8.5 Summary......Page 297
8.6 References......Page 298
Part 3 - Future trends in DSL development......Page 300
DSL design: looking forward......Page 302
9.1 Growing language support for DSL design......Page 303
9.1.1 Striving to be expressive......Page 304
9.1.3 s-expressions instead of XML as the carrier......Page 306
9.2 DSL workbenches......Page 307
9.2.1 WhatÆs in a DSL workbench?......Page 308
9.2.2 The advantages of using a DSL workbench......Page 309
9.3 More tool support......Page 310
9.4.1 Versioning your DSL......Page 311
9.4.2 Best practices for a smoother evolution of DSL......Page 312
9.5 Summary......Page 314
9.6 References......Page 315
A.1 Qualities of well-designed abstractions......Page 316
A.1.3 Extensibility and composability......Page 317
A.2.1 Evolve by being generic......Page 318
A.2.2 Subtyping to prevent implementation leak......Page 319
A.2.3 Implementation inheritance done right......Page 320
A.3.2 Accidental complexity......Page 321
A.3.3 Removing the impurities......Page 323
A.3.4 Keeping away implementation details using DI......Page 324
A.4.1 WhatÆs extensibility?......Page 325
A.4.2 Mixins: a design pattern for extensibility......Page 326
A.4.3 Mixins for extending Map......Page 327
A.4.4 Functional extensibility......Page 328
A.5 Composability comes from purity......Page 329
A.5.1 Design patterns for composability......Page 330
A.5.2 Back to languages......Page 331
A.5.3 Side effects and composability......Page 332
A.5.4 Composability and concurrency......Page 334
A.6 References......Page 335
B.1 The meta in the DSL......Page 336
B.1.1 Runtime metaprogramming in DSL implementation......Page 337
B.1.2 Compile-time metaprogramming in DSL implementation......Page 339
B.2.1 WhatÆs so special about Lisp?......Page 342
B.2.3 Data as code......Page 343
B.2.4 A simple parser that parses only list structures......Page 344
B.3 References......Page 345
C.1 DSL-friendly features of Ruby......Page 346
C.2 References......Page 349
D.1 DSL-friendly features of Scala......Page 350
D.2 References......Page 354
E.1 DSL-friendly features of Groovy......Page 355
E.2 References......Page 357
F.1 DSL-friendly features of Clojure......Page 358
F.2 References......Page 361
appendix G: Polyglot development......Page 362
G.2 Bootstrapping a Java-Groovy development environment......Page 363
G.3 Bootstrapping a Java-Scala development environment......Page 364
G.4 Popular IDEs for polyglot development......Page 365
B......Page 366
D......Page 367
E......Page 369
G......Page 370
J......Page 371
N......Page 372
Q......Page 373
S......Page 374
T......Page 375
Y......Page 376
Back cover......Page 377