Objects, Components, Models and Patterns (eBook)

Preface 5
Organization 7
Table of Contents 9
The End of the Computing Era: Hephaestus Meets the Olympians 11
Modeling of Component Environment in Presence of Callbacks and Autonomous Activities 12
Introduction 12
Goals and Structure of the Paper 16
Behavior Protocols 16
Modeling Environment via Behavior Protocols 17
Calling Protocol vs. Callbacks and Autonomous Activities 20
Calling & Trigger Protocol
Construction of Calling and Trigger Protocol 23
Tools and Experiments 24
Evaluation and Related Work 25
Conclusion 27
References 27
Efficient Model Checking of Networked Applications 32
Introduction 32
Intuition of the Caching Algorithm 33
SoftwareModel Checking 33
Handling Redundant Actions After Backtracking 34
Extension to More Complex Protocols 37
Formalization of the Caching Algorithm 37
Stream Abstraction 38
Execution Semantics 38
Example Execution Scenario 39
Limitations of Our Approach 41
Implementation 42
Experiments 43
Example Applications 44
Results 44
Summary 46
Related Work 47
Conclusions 48
Future Work 49
References 49
Controlling Accessibility in Agile Projects with the Access Modifier Modifier 51
Introduction 51
Motivation 52
Sufficient and Excessive Accessibility 54
Accessibility Status and APIs 55
Accessibility Status and Subtyping 57
Interface Implementation 57
Anonymous Subclasses 58
Accessibility and Program Semantics 58
Dynamic Binding: Overriding with Open Recursion 58
Static Binding: Overloading and the Most Specific Method 60
The Access Modifier Modifier Tool 60
Full Build 61
Incremental Build 62
Reducing Accessibility or Adding an @API Annotation 62
Increasing Accessibility 62
Evaluation 63
Usefulness 63
Cost 65
Discussion 65
Related Work 66
Future Work 67
Conclusion 68
References 68
Towards Raising the Failure of Unit Tests to the Level of Compiler-Reported Errors 70
Introduction 70
Problem 72
Fault Locators 73
Fault Locators Based on Prior Knowledge 74
Fault Locators Based on Posterior Knowledge 74
Evaluation 76
Evaluation Based on Flawed Historical Releases 76
Evaluation Based on Error Seeding 79
Evaluation in Practice 81
Architecture of EZUNIT 83
Call Graph Computation 83
Adding New Fault Locators 84
Other Possible Fault Locators 85
Related Work 86
Conclusion 87
References 88
Virtual Machine Support for Stateful Aspects 90
Introduction 90
Stateful Aspects Examples 92
Steamloom SA Interface 94
Steamloom SA Implementation 96
Stateful Aspect Semantics 96
Deployment Procedure 97
Stateful Shared Object 98
Woven Code Details 99
Evaluation 99
Performance Criteria 99
Results and Analysis 103
Related Work 106
Conclusion 107
References 108
Guarded Program Transformations Using JTL 110
Introduction 110
A Brief Overview of JTL 113
JTL Extensions for Program Transformation 115
Simple BaggageManagement 116
Multiple Baggage 117
String Literals 119
Baggage Management in Quantifiers 119
Transformation Examples 120
Using JTL in an IDE and for Refactoring 120
JTL as a Lightweight AOP Language 121
Templates, Mixins and Generics 122
Non-JAVA Output 123
Implementation Issues 124
Translating JTL into Datalog 124
Calculating String Results 125
List Processing 126
Output Validation 127
Related Work and Discussion 128
References 129
A Multiparadigm Study of Crosscutting Modularity in Design Patterns 131
Introduction 131
Background 132
Language Mechanisms Used in the Case Study 132
Categories of Design Patterns 134
Evaluation Criteria 135
Case Study 138
Initial Implementations 138
Optimized Implementations 142
Consequences, Insights, and Guidelines 144
Related Work 146
Conclusions 147
References 148
Representing and Operating with Model Differences 151
Introduction 151
Rewriting Logic and Maude 152
Introduction to Maude 152
Object-Oriented Specifications: Full Maude 153
Formalizing Models and Metamodels with Maude 154
Model Difference 156
Representation: The Difference Metamodel 156
Specification of the Difference Operation 157
An Example 162
Further Operations 163
The “do” Operation 164
The “undo” Operation 165
Sequential Composition of Differences 165
Tool Support 166
Related Work 167
Conclusions 168
References 169
Optimizing Dynamic Class Composition in a Statically Typed Language 171
Introduction 171
Informal Semantics 173
The Basic Classifier Entity Structure 173
Class Composition 175
The Virtual Machine Realization of the Semantics 178
Improving the Linearization Algorithm 178
Benchmarks 183
Related and Future Work 184
Conclusion 185
References 186
Ownership, Uniqueness, and Immutability 188
Introduction 188
Meet Joe3 190
Motivating Examples 191
3A Formal Definition of Joe3 196
Joe3’s Static Semantics 196
Potentially Identical Owners with Different Modes 201
Invariants and Meta Theory 201
Extensions and Encodings 202
Object-Based Regions and Method-Scoped Regions 202
Encoding Modes from Flexible Alias Protection 203
Related Work 203
Concluding Remarks 206
References 206
Object Incompleteness and Dynamic Composition in Java-Like Languages 208
Introduction 208
Incomplete Featherweight Java 211
Subtyping 213
Programming Examples 214
Typing 215
Operational Semantics 217
Properties 220
Dealing with Imperative Features 221
Ongoing Extensions 223
Conclusions and RelatedWorks 224
References 226
The Meta in Meta-object Architectures 228
Introduction 228
Context and Example 230
Partial Behavioral Reflection 230
A Simple Example 231
Infinite Meta-object Call Recursion 231
Solution: A Metacontext 233
Modeling Context 233
The Problem Revisited 234
The Contextual Tower 235
The MetaContext Revised 237
Implementation 237
Implementation of MetaContext 237
Realizing Contextual Links 238
Evaluation and Benchmarks 239
The Problem Is Solved 239
Benefits for Dynamic Analysis 240
Benchmarks 241
Related Work 243
Conclusion and Future Work 244
References 245
An AsmL Semantics for Dynamic Structures and Run Time Schedulability in UML-RT 248
Introduction 248
UML-RT 251
AsmL 253
SURTA Architecture 254
An Executable Semantics 256
Actor Classes 256
State Machines 257
Protocol 258
Actor References 258
Ports 258
Actor Instances 259
Controllers 261
Run Time Environment 261
Model Descriptions 262
Validating Models with SURTA 264
Conclusion 265
References 266
Component Reassembling and State Transfer in MaDcAr-Based Self-adaptive Software 268
Introduction 268
Requirements for Assembling Engines 269
Definition of an Assembling Engine 270
Evaluation Criteria 270
TheMaDcAr Model 271
Requirements and Restrictions 271
The Assembling Engine 272
The Context Manager 273
Specification of Valid Assemblies 274
The Assembling Policy 276
The (Re)Assembling Process 277
State Transfer During Adaptations 278
State of an Application 278
State Transfer Net 279
State Transfer Links 279
Consistency Rules 281
State Transfer Process 281
Discussion 283
Related Work 283
Comparison and Evaluation of MaDcAr 284
Conclusion and Future Work 284
References 285
A Comparison of State-Based Modelling Tools for Model Validation 288
Introduction 288
Contribution 289
Background 290
Case Study: Course Assignment System 291
Modelling the Static Structure of the System 291
Modelling in UML and OCL with USE 292
Modelling in Alloy with Alloy Analyzer 294
Modelling in Z with ZLive and ProZ 296
Remarks 297
Course Assignment - Extended Version 298
Validation in UML and OCL with USE 298
Validation in Alloy with Alloy Analyzer 300
Validation in Z with ZLive 300
Validation in Z with ProZ 301
Conclusion 302
References 305
MontiCore: Modular Development of Textual Domain Specific Languages 307
Introduction 307
Related Work 309
Language Definition Using MontiCore 310
Concepts of Modularity 313
Language Inheritance 313
Language Embedding 317
Modular Development of Domain Specific Tools 321
Conclusion and Outlook 322
References 323
Proof-Transforming Compilation of Eiffel Programs 326
Introduction 326
Source Language and Logic 329
Basics 329
Routine and Instruction Specifications 330
Axiomatic Semantics 331
Bytecode Language and Logic 331
Bytecode Basics 332
Method and Instruction Specifications 332
Rules 333
Specification Translator 333
Translation Basics 333
Datatype Definitions 334
Object Store and Values 335
Mapping Eiffel Types to CIL 335
Contract Translation 336
Example Translation 337
Proof Translation 338
Transformation Function Basics 338
Compound Instruction 339
Loop Instruction 339
Rescue Clause 340
Example 340
Soundness Theorems 341
Related Work 343
Conclusion 344
References 344
Engineering Associations: From Models to Code and Back through Semantics 346
Introduction 346
The Problem 346
The Causes 347
The Approach and Results 348
Background and Relation to Other Works 349
Formal Semantics Framework 350
Class Diagrams, Informally 350
Instances 351
Formal Class Diagrams, I: Nodes, Arrows and Their Extension 352
Formal Class Diagrams, II: Diagram Predicates 353
Problems of Binary Associations 354
Navigation: Is It That Simple? 354
Navigation and Extension 357
Qualified and N-ary Associations 360
The General Case 361
The Common Case 361
Precise Modeling with Diagram Predicates and Operations 362
Discussion and Conclusions 363
References 365
On the Efficiency of Design Patterns Implemented in C# 3.0 366
Introduction 366
Relationship between Patterns and Languages 367
Replacing Patterns by Features 367
Libraries of Design Patterns 370
The Impact of C# 3.0 371
Features in C# 371
Pattern Implementation in C# 372
Experimenting with the Visitor Pattern 374
Double Dispatch 374
Reflection 375
Type Testing 376
Delegates 377
Results 377
Conclusions and Future Work 379
References 380
A Framework for Model Transformation By-Example: Concepts and Tool Support 382
Introduction 382
MTBE at a Glance 384
Motivation 384
MTBE Process 385
MTBE Concepts Revisited 385
Model Mapping Language 386
Reasoning Based on Pattern Matching 387
Metamodel Mapping Language 390
An Eclipse Based Implementation for MTBE 391
Integration of GMF 393
A Tour on the MTBE Framework 394
Integration Problem: ER2UML 394
User Defined Model Mappings 396
Reasoning and Metamodel Mappings 397
ATL Code Generation 397
Lessons Learned 399
Related Work 399
Conclusion and Future Work 400
References 400
Web Applications Design and Development with WebML and WebRatio 5.0 402
Introduction 402
The WebML Methodology 403
The WebML Language 405
WebML Data Model 405
WebML Hypertext Model 405
Support of Web Services and Business Processes in WebML 408
WebRatio: A Tool for Designing WebML Models 412
Conclusions 419
References 420
Author Index 422