Home > Store > Software Development & Management > Architecture and Design

Software Language Engineering: Creating Domain-Specific Languages Using Metamodels

Register your product to gain access to bonus material or receive a coupon.

Software Language Engineering: Creating Domain-Specific Languages Using Metamodels

eBook (Watermarked)

  • Your Price: $25.59
  • List Price: $31.99
  • Includes EPUB, MOBI, and PDF
  • About eBook Formats
  • This eBook includes the following formats, accessible from your Account page after purchase:

    ePub EPUB The open industry format known for its reflowable content and usability on supported mobile devices.

    MOBI MOBI The eBook format compatible with the Amazon Kindle and Amazon Kindle applications.

    Adobe Reader PDF The popular standard, used most often with the free Adobe® Reader® software.

    This eBook requires no passwords or activation to read. We customize your eBook by discreetly watermarking it with your name, making it uniquely yours.

Description

  • Copyright 2009
  • Pages: 240
  • Edition: 1st
  • eBook (Watermarked)
  • ISBN-10: 0-13-265134-3
  • ISBN-13: 978-0-13-265134-9

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.

Sample Content

Table of 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

Updates

Submit Errata

More Information

Unlimited one-month access with your purchase
Free Safari Membership