Software Language Engineering: Creating Domain-Specific Languages Using Metamodels

Description

Software practitioners are rapidly discovering the immense value of Domain-Specific Languages (DSLs) in solving problems within clearly definable problem domains. Developers are applying DSLs to improve productivity and quality in a wide range of areas, such as finance, combat simulation, macro scripting, image generation, and more. But until now, there have been few practical resources that explain how DSLs work and how to construct them for optimal use.

Software Language Engineering fills that need. Written by expert DSL consultant Anneke Kleppe, this is the first comprehensive guide to successful DSL design. Kleppe systematically introduces and explains every ingredient of an effective

language specification, including its description of concepts, how those concepts are denoted, and what those concepts mean in relation to the problem domain. Kleppe carefully illuminates good design strategy, showing how to maximize the flexibility of the languages you create. She also demonstrates powerful techniques for creating new DSLs that cooperate well with general-purpose languages and leverage their power.

Completely tool-independent, this book can serve as the primary resource for readers using Microsoft DSL tools, the Eclipse Modeling Framework, openArchitectureWare, or any other DSL toolset. It contains multiple examples, an illustrative running case study, and insights and background information drawn from Kleppe's leading-edge work as a DSL researcher.

Specific topics covered include

* Discovering the types of problems that DSLs can solve, and when to use them
* Comparing DSLs with general-purpose languages, frameworks, APIs, and other approaches
* Understanding the roles and tools available to language users and engineers
* Creating each component of a DSL specification
* Modeling both concrete and abstract syntax
* Understanding and describing language semantics
* Defining textual and visual languages based on object-oriented metamodeling and graph transformations
* Using metamodels and associated tools to generate grammars
* Integrating object-oriented modeling with graph theory
* Building code generators for new languages
* Supporting multilanguage models and programs

This book provides software engineers with all the guidance they need to create DSLs that solve real problems more rapidly, and with higher-quality code.

CONTENTS:

Background Information xvii

Preface xix

Foreword xxvii

Chapter 1: Why Software Language Engineering? 1

1.1 An Increasing Number of Languages 1

1.2 Software Languages 3

1.3 The Changing Nature of Software Languages 4

1.3.1 Graphical versus Textual Languages 5

1.3.2 Multiple Syntaxes 6

1.4 The Complexity Crisis 7

1.5 What We Can Learn From ... 8

1.5.1 Natural-Language Studies 9

1.5.2 Traditional Language Theory 10

1.5.3 Graph Theory 10

1.6 Summary 12

Chapter 2: Roles in Language Engineering 15

2.1 Different Processes, Different Actors 15

2.2 The Language User 16

2.2.1 Tool Set of the Language User 17

2.3 The Language Engineer 19

2.3.1 Tool Set for the Language Engineer 19

2.3.2 Tool Generators 20

2.4 Summary 21

Chapter 3: Languages and Mograms 23

3.1 What Is a Language? 23

3.1.1 Mogram, or Linguistic Utterance 24

3.1.2 Primitive Language Elements and Libraries 26

3.2 Abstraction Levels and Expressiveness 27

3.2.1 Abstract versus Incomplete 29

3.2.2 Raising the Level of Abstraction 29

3.2.3 Growing Business Expectations 31

3.2.4 Languages and Abstraction Levels 32

3.3 Domain-Specific Languages 33

3.3.1 Domain-Specific versus General Languages 33

3.3.2 Domain Experts versus Computer Experts 33

3.3.3 Large User Group versus Small User Group 34

3.3.4 Horizontal DSLs versus Vertical DSLs 35

3.3.5 DSLs versus Frameworks and APIs 37

3.3.6 DSLs as Software Languages 37

3.4 Summary 38

Chapter 4: Elements of a Language Specification 39

4.1 Language Specification 39

4.1.1 Forms of a Mogram 40

4.1.2 Parts 41

4.1.3 Creation Process 42

4.1.4 An Example 43

4.2 Formalisms to Specify Languages 47

4.2.1 Context-Free Grammars 47

4.2.2 Attributed Grammars 49

4.2.3 Graph Grammars 51

4.2.4 UML Profiling 52

4.2.5 Metamodeling 53

4.2.6 Formalism of Choice 53

4.3 Summary 54

Chapter 5: Metamodeling 57

5.1 Foundations of Metamodeling 57

5.1.1 Graphs 58

5.1.2 Models and Instances 61

5.1.3 Constraint Types 62

5.1.4 UML Diagrams as Notation 66

5.1.5 Metamodels 68

5.2 Relation with Model-Driven Approaches 69

5.2.1 How to Understand the Term Platform 69

5.2.1 Transformations and Language Specifications 70

5.3 Summary 73

Chapter 6: Abstract Syntax 75

6.1 The Pivotal Role of Abstract Syntax 75

6.1.1 The Hidden, Underlying, Unifying Structure 75

6.1.2 The Gateway to Semantics 76

6.2 Mogram/Language Relationship 77

6.2.1 Abstract Form of a Mogram 78

6.2.2 Concrete form of a Mogram 78

6.2.3 Syntactically, Not Semantically, Correct 79

6.2.4 Syntactically Incorrect Mograms 80

6.3 How to Create an Abstract Syntax Model 80

6.3.1 Domain Modeling for Vertical DSLs 81

6.3.2 Pattern Finding for Horizontal DSLs 82

6.4 Alan: An Example Language 83

6.4.1 Introducing Alan 83

6.4.2 The Observer Pattern in Alan 84

6.4.3 Generic Types in Alan 85

6.4.4 Alan's Standard Library 86

6.5 Alan's Abstract Syntax Model 86

6.5.1 Types 86

6.5.2 Expressions 87

6.5.3 The Observer Pattern 89

6.5.4 The Library 90

6.6 Summary 90

Chapter 7: Concrete Syntax 93

7.1 Concrete Syntax and Tool Support 93

7.1.1 Phases in the Recognition Process 94

7.1.2 Two Types of Editors 100

7.1.3 The Textual-Graphical Mismatch, or Blind Spots 101

7.2 Concrete Syntax Model 104

7.2.1 Guidelines for Creating a Concrete Syntax Model 105

7.2.2 Alan's Graphical Syntax Model 106

7.3 Summary 110

Chapter 8: Generating Textual Concrete Syntax 113

8.1 The Grasland Generator 113

8.2 The Abstract-to-Concrete Transformation 117

8.2.1 Handling References 117

8.2.2 Alan's Textual Concrete Syntax Model 118

8.2.3 Designer Input to the asm2tcsm Transformation 120

8.3 The Model-to-BNF Grammar Algorithm 121

8.3.1 Generation of the BNFset 121

8.3.2 Designer Input to the tcsm2bnf Transformation 122

8.4 The Static Semantic Analyzer 126

8.4.1 Binding 126

8.4.2 Checking 128

8.5 Summary 129

Chapter 9: Semantics: The Meaning of Language 131

9.1 Semantics Defined 131

9.1.1 Understanding Is Personal 131

9.1.2 The Nature of a Semantics Description 133

9.2 Semantics of Software Languages 134

9.2.1 Ways to Describe Semantics 135

9.2.2 The Best Semantics 138

9.3 Operational Semantics Using Graphs 138

9.3.1 Modeling Semantics 139

9.3.2 Consequences of the Von Neumann Architecture 140

9.3.3 States in the Abstract Machine 142

9.3.4 The Rules of Execution: Transitions 143

9.3.5 Example: Simple Semantics 144

9.4 Summary 148

Chapter 10: Translational Semantics: Code Generation 149

10.1 Code Generation and Language Design 149

10.1.1 Abstraction Levels 150

10.1.2 Multiple Semantics 150

10.2 Building a Code Generator 151

10.2.1 Hard-Coded or Model-Transformation Rules 151

10.2.2 Source-Driven or Target-Driven Translation 153

10.2.3 Concrete or Abstract Form Target 154

10.2.4 A Template Language Targeting Abstract Form 157

10.3 Code-Generation Patterns 158

10.3.1 Treewalkers, or the Visitor Pattern 158

10.3.2 CreateOrFind 159

10.3.3 Mappers 160

10.4 Extension Points in the Generated Code 161

10.5 Other Issues in Code Generation 163

10.5.1 Bidirectionality 163

10.5.2 Target Platform with or without Framework 164

10.5.3 Modularization of the Generation 167

10.5.4 Built-in Flexibility 167

10.6 Summary 169

Chapter 11: Combining Multiple Languages 171

11.1 Multiple Mograms for One Application 171

11.1.1 Advantages of Multiple Mograms 172

11.1.2 Multiple Mograms: One or More Languages 172

11.2 Intermogram References 173

11.2.1 Hard and Soft References 173

11.2.2 Passive and Active Languages 174

11.2.3 Information Hiding 175

11.3 Language Interfaces 176

11.3/1 Offered or Required Language Interface 177

11.4 Consequences for Language User Tool Set 179

11.4.1 Resolving and Checking References 179

11.4.2 Handling Changes 180

11.4.3 Code Generation 181

11.5 Support for Language Evolution 182

11.6 Conclusion 183

11.7 Summary 183

Appendix A Glossary 185

Appendix B References 189

Index 197