Paige / Aalst / Meyer Objects, Components, Models and Patterns

46th International Conference, TOOLS EUROPE 2008, Zurich, Switzerland, June 30-July 4, 2008, Proceedings
1. Auflage 2008
ISBN: 978-3-540-69824-1
Verlag: Springer Berlin Heidelberg
Format: PDF
Kopierschutz: 1 - PDF Watermark

E-Book, Englisch, Band 11, 422 Seiten

Reihe: Lecture Notes in Business Information Processing

This book constitutes the thoroughly refereed proceedings of the 46th International Conference on Objects, Components, Models and Patterns, TOOLS EUROPE 2008, held in Zurich, Switzerland, in June/July 2008. The 21 papers presented in this book were carefully reviewed and selected from 58 submissions. TOOLS played a major role in the spread of object-oriented and component technologies. It has now broadened its scope beyond the original topics of object technology and component-based development to encompass all modern, practical approaches to software development. At the same time, TOOLS kept its traditional spirit of technical excellence, its acclaimed focus on practicality, its well-proven combination of theory and applications, and its reliance on the best experts from academia and industry.

Autoren/Hrsg.

Aalst, Will

Mylopoulos, John

Szyperski, Clemens

Paige, Richard F.

Meyer, Bertrand

Inhaltsverzeichnis

1;Preface;5
2;Organization;7
3;Table of Contents;9
4;The End of the Computing Era: Hephaestus Meets the Olympians;11
5;Modeling of Component Environment in Presence of Callbacks and Autonomous Activities;12
5.1;Introduction;12
5.1.1;Goals and Structure of the Paper;16
5.2;Behavior Protocols;16
5.2.1;Modeling Environment via Behavior Protocols;17
5.3;Calling Protocol vs. Callbacks and Autonomous Activities;20
5.3.1;Calling & Trigger Protocol;22
5.3.2;Construction of Calling and Trigger Protocol;23
5.4;Tools and Experiments;24
5.5;Evaluation and Related Work;25
5.6;Conclusion;27
5.7;References;27
6;Efficient Model Checking of Networked Applications;32
6.1;Introduction;32
6.2;Intuition of the Caching Algorithm;33
6.2.1;SoftwareModel Checking;33
6.2.2;Handling Redundant Actions After Backtracking;34
6.2.3;Extension to More Complex Protocols;37
6.3;Formalization of the Caching Algorithm;37
6.3.1;Stream Abstraction;38
6.3.2;Execution Semantics;38
6.3.3;Example Execution Scenario;39
6.3.4;Limitations of Our Approach;41
6.4;Implementation;42
6.5;Experiments;43
6.5.1;Example Applications;44
6.5.2;Results;44
6.5.3;Summary;46
6.6;Related Work;47
6.7;Conclusions;48
6.8;Future Work;49
6.9;References;49
7;Controlling Accessibility in Agile Projects with the Access Modifier Modifier;51
7.1;Introduction;51
7.2;Motivation;52
7.3;Sufficient and Excessive Accessibility;54
7.3.1;Accessibility Status and APIs;55
7.3.2;Accessibility Status and Subtyping;57
7.3.3;Interface Implementation;57
7.3.4;Anonymous Subclasses;58
7.4;Accessibility and Program Semantics;58
7.4.1;Dynamic Binding: Overriding with Open Recursion;58
7.4.2;Static Binding: Overloading and the Most Specific Method;60
7.5;The Access Modifier Modifier Tool;60
7.5.1;Full Build;61
7.5.2;Incremental Build;62
7.5.3;Reducing Accessibility or Adding an @API Annotation;62
7.5.4;Increasing Accessibility;62
7.6;Evaluation;63
7.6.1;Usefulness;63
7.6.2;Cost;65
7.7;Discussion;65
7.7.1;Related Work;66
7.7.2;Future Work;67
7.8;Conclusion;68
7.9;References;68
8;Towards Raising the Failure of Unit Tests to the Level of Compiler-Reported Errors;70
8.1;Introduction;70
8.2;Problem;72
8.3;Fault Locators;73
8.3.1;Fault Locators Based on Prior Knowledge;74
8.3.2;Fault Locators Based on Posterior Knowledge;74
8.4;Evaluation;76
8.4.1;Evaluation Based on Flawed Historical Releases;76
8.4.2;Evaluation Based on Error Seeding;79
8.4.3;Evaluation in Practice;81
8.5;Architecture of EZUNIT;83
8.5.1;Call Graph Computation;83
8.5.2;Adding New Fault Locators;84
8.6;Other Possible Fault Locators;85
8.7;Related Work;86
8.8;Conclusion;87
8.9;References;88
9;Virtual Machine Support for Stateful Aspects;90
9.1;Introduction;90
9.2;Stateful Aspects Examples;92
9.3;Steamloom SA Interface;94
9.4;Steamloom SA Implementation;96
9.4.1;Stateful Aspect Semantics;96
9.4.2;Deployment Procedure;97
9.4.3;Stateful Shared Object;98
9.4.4;Woven Code Details;99
9.5;Evaluation;99
9.5.1;Performance Criteria;99
9.5.2;Results and Analysis;103
9.6;Related Work;106
9.7;Conclusion;107
9.8;References;108
10;Guarded Program Transformations Using JTL;110
10.1;Introduction;110
10.2;A Brief Overview of JTL;113
10.3;JTL Extensions for Program Transformation;115
10.3.1;Simple BaggageManagement;116
10.3.2;Multiple Baggage;117
10.3.3;String Literals;119
10.3.4;Baggage Management in Quantifiers;119
10.4;Transformation Examples;120
10.4.1;Using JTL in an IDE and for Refactoring;120
10.4.2;JTL as a Lightweight AOP Language;121
10.4.3;Templates, Mixins and Generics;122
10.4.4;Non-JAVA Output;123
10.5;Implementation Issues;124
10.5.1;Translating JTL into Datalog;124
10.5.2;Calculating String Results;125
10.5.3;List Processing;126
10.6;Output Validation;127
10.7;Related Work and Discussion;128
10.8;References;129
11;A Multiparadigm Study of Crosscutting Modularity in Design Patterns;131
11.1;Introduction;131
11.2;Background;132
11.2.1;Language Mechanisms Used in the Case Study;132
11.2.2;Categories of Design Patterns;134
11.2.3;Evaluation Criteria;135
11.3;Case Study;138
11.3.1;Initial Implementations;138
11.3.2;Optimized Implementations;142
11.4;Consequences, Insights, and Guidelines;144
11.5;Related Work;146
11.6;Conclusions;147
11.7;References;148
12;Representing and Operating with Model Differences;151
12.1;Introduction;151
12.2;Rewriting Logic and Maude;152
12.2.1;Introduction to Maude;152
12.2.2;Object-Oriented Specifications: Full Maude;153
12.3;Formalizing Models and Metamodels with Maude;154
12.4;Model Difference;156
12.4.1;Representation: The Difference Metamodel;156
12.4.2;Specification of the Difference Operation;157
12.4.3;An Example;162
12.5;Further Operations;163
12.5.1;The “do” Operation;164
12.5.2;The “undo” Operation;165
12.5.3;Sequential Composition of Differences;165
12.5.4;Tool Support;166
12.6;Related Work;167
12.7;Conclusions;168
12.8;References;169
13;Optimizing Dynamic Class Composition in a Statically Typed Language;171
13.1;Introduction;171
13.2;Informal Semantics;173
13.2.1;The Basic Classifier Entity Structure;173
13.2.2;Class Composition;175
13.3;The Virtual Machine Realization of the Semantics;178
13.3.1;Improving the Linearization Algorithm;178
13.4;Benchmarks;183
13.5;Related and Future Work;184
13.6;Conclusion;185
13.7;References;186
14;Ownership, Uniqueness, and Immutability;188
14.1;Introduction;188
14.2; Meet Joe3;190
14.2.1;Motivating Examples;191
14.3;3A Formal Definition of Joe3;196
14.3.1;Joe3’s Static Semantics;196
14.3.2;Potentially Identical Owners with Different Modes;201
14.3.3;Invariants and Meta Theory;201
14.4;Extensions and Encodings;202
14.4.1;Object-Based Regions and Method-Scoped Regions;202
14.4.2;Encoding Modes from Flexible Alias Protection;203
14.5;Related Work;203
14.6;Concluding Remarks;206
14.7;References;206
15;Object Incompleteness and Dynamic Composition in Java-Like Languages;208
15.1;Introduction;208
15.2;Incomplete Featherweight Java;211
15.2.1;Subtyping;213
15.2.2;Programming Examples;214
15.2.3;Typing;215
15.2.4;Operational Semantics;217
15.3;Properties;220
15.4;Dealing with Imperative Features;221
15.5;Ongoing Extensions;223
15.6;Conclusions and RelatedWorks;224
15.7;References;226
16;The Meta in Meta-object Architectures;228
16.1;Introduction;228
16.2;Context and Example;230
16.2.1;Partial Behavioral Reflection;230
16.2.2;A Simple Example;231
16.3;Infinite Meta-object Call Recursion;231
16.4;Solution: A Metacontext;233
16.4.1;Modeling Context;233
16.4.2;The Problem Revisited;234
16.4.3;The Contextual Tower;235
16.4.4;The MetaContext Revised;237
16.5;Implementation;237
16.5.1;Implementation of MetaContext;237
16.5.2;Realizing Contextual Links;238
16.6;Evaluation and Benchmarks;239
16.6.1;The Problem Is Solved;239
16.6.2;Benefits for Dynamic Analysis;240
16.6.3;Benchmarks;241
16.7;Related Work;243
16.8;Conclusion and Future Work;244
16.9;References;245
17;An AsmL Semantics for Dynamic Structures and Run Time Schedulability in UML-RT;248
17.1;Introduction;248
17.2;UML-RT;251
17.3;AsmL;253
17.4;SURTA Architecture;254
17.5;An Executable Semantics;256
17.5.1;Actor Classes;256
17.5.2;State Machines;257
17.5.3;Protocol;258
17.5.4;Actor References;258
17.5.5;Ports;258
17.5.6;Actor Instances;259
17.5.7;Controllers;261
17.5.8;Run Time Environment;261
17.5.9;Model Descriptions;262
17.6;Validating Models with SURTA;264
17.7;Conclusion;265
17.8;References;266
18;Component Reassembling and State Transfer in MaDcAr-Based Self-adaptive Software;268
18.1;Introduction;268
18.2;Requirements for Assembling Engines;269
18.2.1;Definition of an Assembling Engine;270
18.2.2;Evaluation Criteria;270
18.3;TheMaDcAr Model;271
18.3.1;Requirements and Restrictions;271
18.3.2;The Assembling Engine;272
18.3.3;The Context Manager;273
18.3.4;Specification of Valid Assemblies;274
18.3.5;The Assembling Policy;276
18.3.6;The (Re)Assembling Process;277
18.4;State Transfer During Adaptations;278
18.4.1;State of an Application;278
18.4.2;State Transfer Net;279
18.4.3;State Transfer Links;279
18.4.4;Consistency Rules;281
18.4.5;State Transfer Process;281
18.5;Discussion;283
18.5.1;Related Work;283
18.5.2;Comparison and Evaluation of MaDcAr;284
18.6;Conclusion and Future Work;284
18.7;References;285
19;A Comparison of State-Based Modelling Tools for Model Validation;288
19.1;Introduction;288
19.1.1;Contribution;289
19.2;Background;290
19.3;Case Study: Course Assignment System;291
19.3.1;Modelling the Static Structure of the System;291
19.3.2;Modelling in UML and OCL with USE;292
19.3.3;Modelling in Alloy with Alloy Analyzer;294
19.3.4;Modelling in Z with ZLive and ProZ;296
19.3.5;Remarks;297
19.4;Course Assignment - Extended Version;298
19.4.1;Validation in UML and OCL with USE;298
19.4.2;Validation in Alloy with Alloy Analyzer;300
19.4.3;Validation in Z with ZLive;300
19.4.4;Validation in Z with ProZ;301
19.5;Conclusion;302
19.6;References;305
20;MontiCore: Modular Development of Textual Domain Specific Languages;307
20.1;Introduction;307
20.2;Related Work;309
20.3;Language Definition Using MontiCore;310
20.4;Concepts of Modularity;313
20.4.1;Language Inheritance;313
20.4.2;Language Embedding;317
20.5;Modular Development of Domain Specific Tools;321
20.6;Conclusion and Outlook;322
20.7;References;323
21;Proof-Transforming Compilation of Eiffel Programs;326
21.1;Introduction;326
21.2;Source Language and Logic;329
21.2.1;Basics;329
21.2.2;Routine and Instruction Specifications;330
21.2.3;Axiomatic Semantics;331
21.3;Bytecode Language and Logic;331
21.3.1;Bytecode Basics;332
21.3.2;Method and Instruction Specifications;332
21.3.3;Rules;333
21.4;Specification Translator;333
21.4.1;Translation Basics;333
21.4.2;Datatype Definitions;334
21.4.3;Object Store and Values;335
21.4.4;Mapping Eiffel Types to CIL;335
21.4.5;Contract Translation;336
21.4.6;Example Translation;337
21.5;Proof Translation;338
21.5.1;Transformation Function Basics;338
21.5.2;Compound Instruction;339
21.5.3;Loop Instruction;339
21.5.4;Rescue Clause;340
21.6;Example;340
21.7;Soundness Theorems;341
21.8;Related Work;343
21.9;Conclusion;344
21.10;References;344
22;Engineering Associations: From Models to Code and Back through Semantics;346
22.1;Introduction;346
22.1.1;The Problem;346
22.1.2;The Causes;347
22.1.3;The Approach and Results;348
22.2;Background and Relation to Other Works;349
22.3;Formal Semantics Framework;350
22.3.1;Class Diagrams, Informally;350
22.3.2;Instances;351
22.3.3;Formal Class Diagrams, I: Nodes, Arrows and Their Extension;352
22.3.4;Formal Class Diagrams, II: Diagram Predicates;353
22.4;Problems of Binary Associations;354
22.4.1;Navigation: Is It That Simple?;354
22.4.2;Navigation and Extension;357
22.5;Qualified and N-ary Associations;360
22.5.1;The General Case;361
22.5.2;The Common Case;361
22.5.3;Precise Modeling with Diagram Predicates and Operations;362
22.6;Discussion and Conclusions;363
22.7;References;365
23;On the Efficiency of Design Patterns Implemented in C# 3.0;366
23.1;Introduction;366
23.2;Relationship between Patterns and Languages;367
23.2.1;Replacing Patterns by Features;367
23.2.2;Libraries of Design Patterns;370
23.3;The Impact of C# 3.0;371
23.3.1;Features in C#;371
23.3.2;Pattern Implementation in C#;372
23.4;Experimenting with the Visitor Pattern;374
23.4.1;Double Dispatch;374
23.4.2;Reflection;375
23.4.3;Type Testing;376
23.4.4;Delegates;377
23.4.5;Results;377
23.5;Conclusions and Future Work;379
23.6;References;380
24;A Framework for Model Transformation By-Example: Concepts and Tool Support;382
24.1;Introduction;382
24.2;MTBE at a Glance;384
24.2.1;Motivation;384
24.2.2;MTBE Process;385
24.3;MTBE Concepts Revisited;385
24.3.1;Model Mapping Language;386
24.3.2;Reasoning Based on Pattern Matching;387
24.3.3;Metamodel Mapping Language;390
24.4;An Eclipse Based Implementation for MTBE;391
24.4.1;Integration of GMF;393
24.5;A Tour on the MTBE Framework;394
24.5.1;Integration Problem: ER2UML;394
24.5.2;User Defined Model Mappings;396
24.5.3;Reasoning and Metamodel Mappings;397
24.5.4;ATL Code Generation;397
24.5.5;Lessons Learned;399
24.6;Related Work;399
24.7;Conclusion and Future Work;400
24.8;References;400
25;Web Applications Design and Development with WebML and WebRatio 5.0;402
25.1;Introduction;402
25.2;The WebML Methodology;403
25.3;The WebML Language;405
25.3.1;WebML Data Model;405
25.3.2;WebML Hypertext Model;405
25.3.3;Support of Web Services and Business Processes in WebML;408
25.4;WebRatio: A Tool for Designing WebML Models;412
25.5;Conclusions;419
25.6;References;420
26;Author Index;422