Refactoring of UML models using AGG

Model refactoring is an emerging research topic that is heavily inspired by refactoring of object-oriented programs. Current-day UML modeling environments provide poor support for evolving UML models and applying refactoring techniques at model level. As UML models are intrinsically graph-based in nature we propose to use graph transformations to specify and apply model refactoring. More in particular, we use a specific graph transformation tool, AGG, and provide recommendations of how AGG may be improved to better support model refactoring. These recommendations are based on a small experiment that we have carried out with refactoring of UML class diagrams and state machines

Removal of redundant elements within UML activity diagrams

As the complexity of systems continues to rise, the use of model-driven development approaches becomes more widely applied. Still, many created models are mainly used for documentation. As such, they are not designed to be used in following stages of development, but merely as a means of improved overview and communication. In an effort to use existing UML2 activity diagrams of an industry partner (Daimler AG) as a source for automatic generation of software artifacts, we discovered, that the diagrams often contain multiple instances of the same element. These redundant instances might improve the readability of a diagram. However, they complicate further approaches such as automated model analysis or traceability to other artifacts because mostly redundant instances must be handled as one distinctive element. In this paper, we present an approach to automatically remove redundant ExecutableNodes within activity diagrams as they are used by our industry partner. The removal is implemented by merging the redundant instances to a single element and adding additional elements to maintain the original behavior of the activity. We use reachability graphs to argue that our approach preserves the behavior of the activity. Additionally, we applied the approach to a real system described by 36 activity diagrams. As a result 25 redundant instances were removed from 15 affected diagrams

Towards the systematic construction of domain-specific transformation languages

The final publication is available at Springer via http://dx.doi.org/10.1007/978-3-319-09195-2-13Proceedings of 10th European Conference, ECMFA 2014, Held as Part of STAF 2014, York, UK, July 21-25, 2014General-purpose transformation languages, like ATL or QVT, are the basis for model manipulation in Model-Driven Engineering (MDE). However, as MDE moves to more complex scenarios, there is the need for specialized transformation languages for activities like model merging, migration or aspect weaving, or for specific domains of wide use like UML. Such domain-specific transformation languages (DSTLs) encapsulate transformation knowledge within a language, enabling the reuse of recurrent solutions to transformation problems. Nowadays, many DSTLs are built in an ad-hoc manner, which requires a high development cost to achieve a full-featured implementation. Alternatively, they are realised by an embedding into general-purpose transformation or programming languages like ATL or Java. In this paper, we propose a framework for the systematic creation of DSTLs. First, we look into the characteristics of domain-specific transformation tools, deriving a categorization which is the basis of our framework. Then, we propose a domain-specific language to describe DSTLs, from which we derive a ready-to-run workbench which includes the abstract syntax, concrete syntax and translational semantics of the DSTL.This work has been funded by the Spanish Ministry of Economy and Competitivity with project “Go Lite” (TIN2011-24139

A heuristic-based approach to code-smell detection

Encapsulation and data hiding are central tenets of the object oriented paradigm. Deciding what data and behaviour to form into a class and where to draw the line between its public and private details can make the difference between a class that is an understandable, flexible and reusable abstraction and one which is not. This decision is a difficult one and may easily result in poor encapsulation which can then have serious implications for a number of system qualities. It is often hard to identify such encapsulation problems within large software systems until they cause a maintenance problem (which is usually too late) and attempting to perform such analysis manually can also be tedious and error prone. Two of the common encapsulation problems that can arise as a consequence of this decomposition process are data classes and god classes. Typically, these two problems occur together – data classes are lacking in functionality that has typically been sucked into an over-complicated and domineering god class. This paper describes the architecture of a tool which automatically detects data and god classes that has been developed as a plug-in for the Eclipse IDE. The technique has been evaluated in a controlled study on two large open source systems which compare the tool results to similar work by Marinescu, who employs a metrics-based approach to detecting such features. The study provides some valuable insights into the strengths and weaknesses of the two approache

Handling High-Level Model Changes Using Search Based Software Engineering

Model-Driven Engineering (MDE) considers models as first-class artifacts during the software lifecycle. The number of available tools, techniques, and approaches for MDE is increasing as its use gains traction in driving quality, and controlling cost in evolution of large software systems. Software models, defined as code abstractions, are iteratively refined, restructured, and evolved. This is due to many reasons such as fixing defects in design, reflecting changes in requirements, and modifying a design to enhance existing features. In this work, we focus on four main problems related to the evolution of software models: 1) the detection of applied model changes, 2) merging parallel evolved models, 3) detection of design defects in merged model, and 4) the recommendation of new changes to fix defects in software models. Regarding the first contribution, a-posteriori multi-objective change detection approach has been proposed for evolved models. The changes are expressed in terms of atomic and composite refactoring operations. The majority of existing approaches detects atomic changes but do not adequately address composite changes which mask atomic operations in intermediate models. For the second contribution, several approaches exist to construct a merged model by incorporating all non-conflicting operations of evolved models. Conflicts arise when the application of one operation disables the applicability of another one. The essence of the problem is to identify and prioritize conflicting operations based on importance and context – a gap in existing approaches. This work proposes a multi-objective formulation of model merging that aims to maximize the number of successfully applied merged operations. For the third and fourth contributions, the majority of existing works focuses on refactoring at source code level, and does not exploit the benefits of software design optimization at model level. However, refactoring at model level is inherently more challenging due to difficulty in assessing the potential impact on structural and behavioral features of the software system. This requires analysis of class and activity diagrams to appraise the overall system quality, feasibility, and inter-diagram consistency. This work focuses on designing, implementing, and evaluating a multi-objective refactoring framework for detection and fixing of design defects in software models.Ph.D.Information Systems Engineering, College of Engineering and Computer ScienceUniversity of Michigan-Dearbornhttp://deepblue.lib.umich.edu/bitstream/2027.42/136077/1/Usman Mansoor Final.pdfDescription of Usman Mansoor Final.pdf : Dissertatio

Transformación de modelos de la vista estructural de un sistema

En este Trabajo de Fin de Grado exploramos las transformaciones de modelos, un componente clave dela Ingeniería de Software basada en modelos. Las transformaciones de modelos son necesarias por diferentesmotivos. En primer lugar, la adaptación a cambios en los requisitos del sistema es un motivo importante pararealizar transformaciones. A medida que evoluciona un proyecto, es común que surjan nuevos requisitos oque los existentes se modifiquen. Mediante las transformaciones de modelos, podemos ajustar los modelosexistentes para reflejar estos cambios, garantizando así la coherencia entre el modelo y los requisitos delsistema. Otro motivo para realizar transformaciones en los modelos es la mejora de la calidad del modelo.Los modelos pueden contener elementos redundantes o ineficientes que pueden afectar la comprensión,mantenibilidad y eficacia del sistema. Mediante las transformaciones de modelos, podemos aplicar técnicaspara eliminar redundancias, simplificar estructuras complejas y mejorar la legibilidad y mantenibilidad delmodelo.En nuestro enfoque, proponemos tratar los modelos como grafos y las transformaciones de modeloscomo transformaciones de grafos, lo que nos permite aplicar teorías y técnicas de la teoría de grafos. Comenzamos por introducir los conceptos fundamentales de modelo y metamodelo, sentando así las bases paracomprender las transformaciones de modelos. A continuación, exploramos diferentes tipos de transformaciones de modelos y posteriormente presentamos diversas definiciones de grafos y de transformaciones degrafos, las cuales nos sirven de base teórica para estudiar las transformaciones de modelos. En particular,nos centramos en dos tipos de transformaciones: endógenas y exógenas.En el ámbito de las transformaciones endógenas, nos centramos en la refactorización de modelos y demostramos cómo la teoría de transformación de grafos brinda soporte formal para esta actividad. Presentamosun ejemplo específico de un modelo de red de área local (LAN) y describimos el proceso de refactorizaciónutilizando un ejemplo concreto llamado Ascender Método. Además, presentamos una secuencia de reglasadicionales que nos permitirán llevar a cabo la transformación completa.En cuanto a las transformaciones exógenas, nos enfocamos en la transformación del diagrama de clases alesquema relacional, una transformación ampliamente explorada en la literatura. Establecemos un conjuntode reglas con un orden concreto que nos permiten llevar a cabo la transformación al esquema relacional.Como ejemplo particular, aplicamos estas reglas a un diagrama de clases que modeliza los profesores yestudiantes de los centros de una universidad.Para llevar a cabo estas transformaciones hemos utilizado el software AGG. A lo largo de este trabajo, sepresentan varias opciones que ofrece AGG, así como sus dos modos de ejecución, que nos permiten realizary visualizar las transformaciones de modelos de manera más cómoda y visual.<br /