Register your product to gain access to bonus material or receive a coupon.
Software Language Engineering: Creating Domain-Specific Languages Using Metamodels
- By Anneke Kleppe
- Published Dec 9, 2008 by Addison-Wesley Professional.
Book
- Sorry, this book is no longer in print.
Description
- Copyright 2009
- Edition: 1st
- Book
- ISBN-10: 0-321-55345-4
- ISBN-13: 978-0-321-55345-4
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
Online Sample Chapter
Why Software Language Engineering?
Sample Pages
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
More Information
Other Things You Might Like
- Book $35.99
- eBook (Watermarked) $34.39