8 research outputs found
UML consistency rules: a systematic mapping study
Context: The Unified Modeling Language (UML), with its 14
different diagram types, is the de-facto standard tool for objectoriented
modeling and documentation. Since the various UML
diagrams describe different aspects of one, and only one, software
under development, they are not independent but strongly depend
on each other in many ways. In other words, the UML diagrams
describing a software must be consistent. Inconsistencies between
these diagrams may be a source of the considerable increase of
faults in software systems. It is therefore paramount that these
inconsistencies be detected, ana
Example-based model refactoring using heuristic search
Software maintenance is considered the most expensive activity in software systems development: more than 80% of the resources are devoted to it. During the maintenance activities, software models are very rarely taken into account. The evolution of these models and the transformations that manipulate them are at the heart of model-driven engineering (MDE). However, as the source code, the model changes and tends to become increasingly complex. These changes generally have a negative impact on the quality of models and they cause damage to the software.
In this context, refactoring is the most used technique to maintain an adequate quality of these models. The refactoring process is usually done in two steps: the detection of elements of the model to correct (design defects), then the correction of these elements.
In this thesis, we propose two main contributions related to detection and correction of defects in class diagrams.
The first contribution aims to automate the design defect detection. We propose to adapt genetic algorithms (e.g., genetic programming) to detect parts of the model that may correspond to design defects.
The second contribution concerns the automation of the correction of these design defects. We propose to adapt three heuristic methods to suggest refactorings:
1. A single-objective optimization method based on structural similarities between a given model (i.e., the model to be refactored) and a set of examples of models (i.e., models that have undergone some refactorings);
2. An interactive single-objective optimization method based on structural similarity and the opinion of the designer; and
3. A multi-objective optimization method that maximizes both the structural and semantic similarities between the model under study and the models in the set of examples.
All the proposed methods were implemented and evaluated on models generated from existing open-source projects and the obtained results confirm their efficiency
Generic Quality-Aware Refactoring and Co-Refactoring in Heterogeneous Model Environments
Software has been subject to change, at all times, in order to make parts of it, for instance, more reusable, better to understand by humans, or to increase efficiency under a certain point of view. Restructurings of existing software can be complex. To prevent developers from doing this manually, they got tools at hand being able to apply such restructurings automatically. These automatic changes of existing software to improve quality while preserving its behaviour is called refactoring. Refactoring is well investigated for programming languages and mature tools exist for executing refactorings in integrated development environments (IDEs).
In recent years, the development paradigm of Model-Driven Software Development (MDSD) became more and more popular and we experience a shift in the sense that development artefacts are considered as models which conform metamodels. This can be understood as abstraction, which resulted in the trend that a plethora of new so-called model-based Domain-Specific Languages (DSLs) arose. DSLs have become an integral part in the MDSD and it is obvious that models are subject to change, as well. Thus, refactoring support is required for DSLs in order to prevent users from doing it manually.
The problem is that the amount of DSLs is huge and refactorings should not be implemented for new for each of them, since they are quite similar from an abstract viewing. Existing approaches abstract from the target language, which is not flexible enough because some assumptions about the languages have to be made and arbitrary DSLs are not supported. Furthermore, the relation between a strategy which finds model deficiencies that should be improved, a resolving refactoring, and the improved quality is only implicit. Focussing on a particular quality and only detecting those deficiencies deteriorating this quality is difficult, and elements of detected deficient structures cannot be referred to in the resolving refactoring.
In addition, heterogeneous models in an IDE might be connected physically or logically, thus, they are dependent. Finding such connections is difficult and can hardly be achieved manually. Applying a restructuring in a model implied by a refactoring in a dependent model must also be a refactoring, in order to preserve the meaning. Thus, this kind of dependent refactorings require an appropriate abstraction mechanism, since they must be specified for dependent models of different DSLs.
The first contribution, Role-Based Generic Model Refactoring, uses role models to abstract from refactorings instead of the target languages. Thus, participating structures in a refactoring can be specified generically by means of role models. As a consequence, arbitrary model-based DSLs are supported, since this approach does not make any assumptions regarding the target languages.
Our second contribution, Role-Based Quality Smells, is a conceptual framework and correlates deficiencies, their deteriorated qualities, and resolving refactorings. Roles are used to abstract from the causing structures of a deficiency, which then are subject to resolving refactorings.
The third contribution, Role-Based Co-Refactoring, employs the graph-logic isomorphism to detect dependencies between models. Dependent refactorings, which we call co-refactorings, are specified on the basis of roles for being independent from particular target DSLs.
All introduced concepts are implemented in our tool Refactory. An evaluation in different scenarios complements the thesis. It shows that role models emerged as very powerful regarding the reuse of generic refactorings in arbitrary languages. Role models are suited as an interface for certain structures which are to be refactored, scanned for deficiencies, or co-refactored. All of the presented approaches benefit from it.:List of Figures xv
List of Tables xvii
List of Listings xix
1. Introduction 1
1.1. Language-Tool Generation Without Consideration Of Time And Space . . . . . 4
1.2. Challenges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.3. Generic Quality-Aware Refactoring and Co-Refactoring in Heterogeneous Model
Environments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2. Foundations 15
2.1. Refactoring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.2. Model-Driven Software Development . . . . . . . . . . . . . . . . . . . . . . . . 16
2.2.1. Levels of Abstraction and Metamodelling . . . . . . . . . . . . . . . . . 17
2.2.2. Model Transformations . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.3. Role-Based Modelling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3. Related Work 23
3.1. Model Refactoring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.1.1. Requirements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.1.2. Literature Review . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.1.3. Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.2. Determination of Quality-Related De ciencies . . . . . . . . . . . . . . . . . . . 32
3.2.1. Requirements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.2.2. Literature Review . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.2.3. Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.3. Co-Refactoring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.3.1. Requirements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.3.2. Literature Review . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.3.3. Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.4. Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
4. Role-Based Generic Model Refactoring 51
4.1. Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
4.2. Specifying Generic Refactorings with Role Models . . . . . . . . . . . . . . . . . 53
4.2.1. Specifying Structural Constraints using Role Models . . . . . . . . . . . 55
4.2.2. Mapping Roles to Language Concepts Using Role Mappings . . . . . . . 57
4.2.3. Specifying Language-Independent Transformations using Refactoring
Speci cations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
4.2.4. Composition of Refactorings . . . . . . . . . . . . . . . . . . . . . . . . . 67
4.3. Preserving Semantics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
4.4. Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
5. Suggesting Role Mappings as Concrete Refactorings 73
5.1. Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
5.2. Automatic Derivation of Suggestions for Role Mappings with Graph Querying . 74
5.3. Reduction of the Number of Valid Matches . . . . . . . . . . . . . . . . . . . . . 76
5.4. Comparison to Model Matching . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
5.5. Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
6. Role-Based Quality Smells as Refactoring Indicator 79
6.1. Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
6.2. Correlating Model De ciencies, Qualities and Refactorings . . . . . . . . . . . . 80
6.2.1. Quality Smell Repository . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
6.2.2. Quality Smell Calculation Repository . . . . . . . . . . . . . . . . . . . . 85
6.3. Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
6.4. Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
7. A Quality Smell Catalogue for Android Applications 89
7.1. Quality Smell Catalogue Schema . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
7.2. Acquiring Quality Smells . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
7.3. Structure-Based Quality Smells—A Detailed Example . . . . . . . . . . . . . . . 92
7.3.1. The Pattern Language . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
7.3.2. Quality Smell: Interruption from Background . . . . . . . . . . . . . . . 93
7.4. Quality Smells for Android Applications . . . . . . . . . . . . . . . . . . . . . . 96
7.4.1. Quality Smell: Data Transmission Without Compression . . . . . . . . . 96
7.4.2. Quality Smell: Dropped Data . . . . . . . . . . . . . . . . . . . . . . . . 98
7.4.3. Quality Smell: Durable WakeLock . . . . . . . . . . . . . . . . . . . . . 98
7.4.4. Quality Smell: Internal Use of Getters/Setters . . . . . . . . . . . . . . . 99
7.4.5. Quality Smell: No Low Memory Resolver . . . . . . . . . . . . . . . . . 101
7.4.6. Quality Smell: Rigid AlarmManager . . . . . . . . . . . . . . . . . . . . 101
7.4.7. Quality Smell: Unclosed Closeable . . . . . . . . . . . . . . . . . . . . . 102
7.4.8. Quality Smell: Untouchable . . . . . . . . . . . . . . . . . . . . . . . . . 103
7.5. Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
8. Role-Based Co-Refactoring in Multi-Language Development Environments 105
8.1. Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
8.2. Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
8.3. Dependency Knowledge Base . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
8.3.1. Categories of Model Dependencies . . . . . . . . . . . . . . . . . . . . . 108
8.3.2. When to Determine Model Dependencies . . . . . . . . . . . . . . . . . 110
8.3.3. How to Determine Model Dependencies . . . . . . . . . . . . . . . . . . 111
8.4. Co-Refactoring Knowledge Base . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
8.4.1. Specifying Coupled Refactorings with Co-Refactoring Speci cations . . 114
8.4.2. Specifying Bindings for Co-Refactorings . . . . . . . . . . . . . . . . . . 116
8.4.3. Determination of Co-Refactoring Speci cations . . . . . . . . . . . . . . 118
8.5. Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
8.6. Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
9. Refactory: An Eclipse Tool For Quality-Aware Refactoring and Co-Refactoring 121
9.1. Refactoring Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
9.1.1. Role Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
9.1.2. Refactoring Speci cation . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
9.1.3. Role Model Mapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
9.1.4. Refactoring Composition . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
9.1.5. Custom Refactoring Extensions . . . . . . . . . . . . . . . . . . . . . . . 129
9.1.6. Pre- and Post-conditions . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
9.1.7. Integration Into the Eclipse Refactoring Framework . . . . . . . . . . . . 130
9.2. Quality Smell Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
9.3. Co-Refactoring Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
9.3.1. Concrete Syntax of a CoRefSpec . . . . . . . . . . . . . . . . . . . . . . . 138
9.3.2. Expression Evaluation by Using an Expression Language . . . . . . . . . 138
9.3.3. UI and Integration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
9.4. Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
10. Evaluation 143
10.1. Case Study: Reuse of Generic Refactorings in many DSLs . . . . . . . . . . . . . 143
10.1.1. Threats to validity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
10.1.2. Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
10.1.3. Experience Report . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
10.2. Case Study: Suggestion of Valid Role Mappings . . . . . . . . . . . . . . . . . . 147
10.2.1. Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
10.2.2. Evaluation and Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . 151
10.3. Proof of Concept: Co-Refactoring OWL and Ecore Models . . . . . . . . . . . . 155
10.3.1. Coupled OWL-Ecore Refactorings . . . . . . . . . . . . . . . . . . . . . 156
10.3.2. Realisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
10.3.3. Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
11. Summary, Conclusion and Outlook 161
11.1. Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
11.2. Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
11.3. Outlook . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
Appendix 169
A. List of Role Models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
B. Comparison to Role Feature Model . . . . . . . . . . . . . . . . . . . . . . . . . 171
C. Complete List of Role Mappings . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
D. List of all IncPL Patterns for Detecting Quality Smells . . . . . . . . . . . . . . . 176
E. Post-Processor of the Extract CompositeState refactoring for UML State Machines 183
F. Speci cation of the Conference Language . . . . . . . . . . . . . . . . . . . . . . 185
List of Abbreviations 187
Bibliography 19
Supporting software evolution in agent systems
Software maintenance and evolution is arguably a lengthy and expensive phase in the life cycle of a software system. A critical issue at this phase is change propagation: given a set of primary changes that have been made to software, what additional secondary changes are needed to maintain consistency between software artefacts? Although many approaches have been proposed, automated change propagation is still a significant technical challenge in software maintenance and evolution. Our objective is to provide tool support for assisting designers in propagating changes during the process of maintaining and evolving models. We propose a novel, agent-oriented, approach that works by repairing violations of desired consistency rules in a design model. Such consistency constraints are specified using the Object Constraint Language (OCL) and the Unified Modelling Language (UML) metamodel, which form the key inputs to our change propagation framework. The underlying change propagation mechanism of our framework is based on the well-known Belief-Desire-Intention (BDI) agent architecture. Our approach represents change options for repairing inconsistencies using event-triggered plans, as is done in BDI agent platforms. This naturally reflects the cascading nature of change propagation, where each change (primary or secondary) can require further changes to be made. We also propose a new method for generating repair plans from OCL consistency constraints. Furthermore, a given inconsistency will typically have a number of repair plans that could be used to restore consistency, and we propose a mechanism for semi-automatically selecting between alternative repair plans. This mechanism, which is based on a notion of cost, takes into account cascades (where fixing the violation of a constraint breaks another constraint), and synergies between constraints (where fixing the violation of a constraint also fixes another violated constraint). Finally, we report on an evaluation of the approach, covering both effectiveness and efficiency