Software Language Engineering
Creating Domain-Specific Languages Using Metamodels
Versandkostenfrei!
Nicht lieferbar
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.
Product 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.
Backcover
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.
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&
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.
Product 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.
Backcover
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.
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&