FACULTY OF SCIENCE Department of Computer Science System and Software Engineering Lab Inconsistency Management in Model-Driven Engineering An Approach using Description Logics Ragnhild Van Der Straeten A dissertation submitted in partial fulfilment of the requirements of the degree of Doctor in Science September 2005 Advisors: Prof. Dr. Viviane Jonckers, Prof. Dr. Tom Mens FACULTEIT VAN DE WETENSCHAPPEN Vakgroep Informatica Laboratorium voor Systeem en Software Engineering Inconsistentiebeheer in modelgebaseerde ontwikkeling Een benadering gebruikmakend van Description Logics Ragnhild Van Der Straeten Proefschrift ingediend met het oog op het behalen van de graad van Doctor in de Wetenschappen September 2005 Promotoren: Prof. Dr. Viviane Jonckers, Prof. Dr. Tom Mens Abstract Model-driven engineering (MDE) is an approach to software development where the pri- mary focus is on models, as opposed to source code. Models are built representing different views on a software system. Models can be refined, evolved into a new version, and can be used to generate executable code. The ultimate goal is to raise the level of abstraction, and to develop and evolve complex software systems by manipulating models only. The ma- nipulation of models is achieved by means of model transformation. Because model-driven engineering is still in its infancy, there is a need for sophisticated formalisms, techniques and associated tools supporting model development, evolution and transformation. The main concern of the research presented in this dissertation, is the definition, detec- tion and resolution of model inconsistencies. We focus on two aspects of these activities: defining and resolving inconsistencies, and a feasibility study of Description Logics (DLs) as a formalism for supporting these activities. Since the Unified Modeling Language (UML) is the generally accepted object-oriented modelling language, it ought to play an essential role in MDE. A software design is typically specified as a collection of different UML diagrams. Because different aspects of the software system are covered by different UML diagrams, there is an inherent risk that the overall specification of the system is inconsistent. Also model transformations, such as (arbitrary) model evolutions, can transform a model into an inconsistent state. Unfortunately, current- day UML CASE tools provide poor support for managing inconsistencies between (evolving) UML models. Inconsistency management is a complex process consisting of different activities. It is a well-studied process that is also well-known within software engineering. However, in the UML context, little research has been done taking into account a wide range of inconsistencies over different kinds of UML diagrams. Inconsistency management in the UML context, is quite complicated due to several reasons. The most obvious reasons are the missing formal semantics for the UML and the UML being a general purpose language that can be applied to several application domains and in several software development processes. To be able to define the occurrence of UML model inconsistencies precisely and unam- biguously, there is first of all a need to formalise the UML’s abstract syntax and concepts. A first contribution is to formalise an important fragment of the abstract syntax. The stud- ied UML fragment allows the specification of the static structure of an application and the specification of behaviour of individual objects and the possible interactions between objects. As a second contribution, we propose a classification of inconsistencies. The defi- nitions of these inconsistencies are based on our formalisation. Inconsistency management, as a process, also includes the activity of resolving inconsistencies. Different resolution strategies are known in literature. The resolution of inconsistencies gives rise to some par- ticular challenges. We give an overview of these challenges in the context of our classified inconsistencies. From the formalisation of a fragment of the UML abstract syntax, from our classification of inconsistencies, from the definition of different inconsistencies and from the different resolution strategies, we distil a set of key criteria. The requirements for each of these criteria can be used to evaluate a formalism and tool support supporting the detection and resolution of inconsistencies. Through the second focus of this dissertation, we discovered that Description Logics (DLs) and DL systems are suited (or can be made suited) for the detection and resolution of inconsistencies on a fairly high-level of model abstraction. DL is a two-variable fragment of first-order predicate logic, defining a family of logic languages, offering a classification task based on the subconcept-superconcept relationship. DLs are very suited for reasoning about hierarchies and about the satisfiability of knowledge bases. Different DL systems are developed and can be used to validate this formalism for the purpose of inconsistency detection and resolution. DLs are validated against our key criteria in three successive steps. First, we investigate to which extent it is possible to encode the fragment under study of the abstract syntax of the UML. We also answer the question if DLs can be used as a semantic domain for some possible semantics for UML diagrams. Second, we show how inconsistencies can be detected using this formalism. Finally, we investigate if it is possible to resolve inconsistencies using DLs and the capabilities of state-of-the-art DL systems. Model transformations are considered to be the heart and soul of MDE. One partic- ular kind of model transformation and evolution is model refactoring. Model refactorings restructure models as opposed to source code refactorings, which restructure source code and are well-known and well-studied. Model refactorings preserve behaviour. We show how some of the classified inconsistencies correspond to behaviour preserving properties that can be expressed between a UML model and its refactored version. A second idea about model refactorings introduced in this dissertation, is to use inconsistency detection and resolution techniques for supporting a software engineer in executing model refactorings. Our ideas are illustrated and validated on a simplified, yet complex enough, set of models of an Automatic Teller Machine (ATM) simulation application using a prototype tool, called RACOoN. This tool is integrated in a commercial UML CASE tool using the latter’s built-in plugin mechanism. Samenvatting Modelgebaseerde ontwikkeling is een bepaalde benadering van software ontwikkeling waarbij de nadruk ligt op modellen in plaats van op broncode. Modellen worden gebouwd vanuit een bepaalde kijk op het software systeem. Modellen kunnen verfijnd worden, evolueren naar nieuwe versies en kunnen, bijvoorbeeld, gebruikt worden om broncode te genereren. Het ultieme doel van modelgebaseerde ontwikkeling is om het abstractieniveau te verhogen en om complexe software systemen te ontwikkelen en te laten evolueren enkel door modelma- nipulatie. Deze modelmanipulaties worden bekomen door middel van modeltransformaties. Modelgebaseerde ontwikkeling staat echter nog in zijn kinderschoenen waardoor er een nood is aan gesofisticeerde formalismen, technieken en geassocieerde programma-ondersteuning voor het ontwerpen van modellen, de evolutie van modellen en transformatie van modellen. De hoofdinteresse van het onderzoek dat gepresenteerd wordt in deze thesis, is de defini- tie, detectie en resolutie van model inconsistenties. De aandacht wordt gevestigd op twee aspecten van deze activiteiten, nl., de definitie van inconsistenties en resolutie strategie¨en, en een onderzoek naar de haalbaarheid van “Description Logics” (DLs) ter ondersteuning van deze activiteiten. Vermits de “Unified Modeling Language” (UML) de standaard objectgeori¨enteerde mod- elleertaal is, zou het een belangrijke rol moeten spelen in modelgebaseerde ontwikkeling. Een software ontwerp is meestal een collectie van UML diagrammen, waardoor er een in- herent risico is dat de globale specificatie van het systeem inconsistent is. Modeltransfor- maties, zoals bijvoorbeeld een willekeurige evolutie van het model, kunnen inconsistenties veroorzaken. De bestaande UML ondersteunende programma’s bieden echter onvoldoende ondersteuning voor het beheren van inconsistenties tussen (evoluerende) UML modellen. Inconsistentiebeheer is een complex proces bestaande uit verschillende activiteiten. Het is een goed bestudeerd proces dat bekend is binnen software ontwikkeling. In de context van UML is er nog niet zo veel onderzoek gedaan naar verschillende soorten inconsistenties over een aantal overlappende UML diagrammen. En dit omwille van een aantal redenen. De belangrijkste zijn: UML heeft geen formele semantiek, daarbovenop kan ´e´en enkel diagram op verschillende manieren ge¨ınterpreteerd worden en UML is een taal voor algemeen ge- bruik in de zin dat ze kan gebruikt worden voor verschillende applicatiedomeinen en binnen verschillende software ontwikkelingsprocessen. Om UML model inconsistenties op een precieze manier te kunnen defini¨eren,hebben we nood aan een formalisatie van de abstracte syntax van UML en een mogelijke semantiek. Een eerste bijdrage van dit werk is de formalisatie van een belangrijk deel van de abstracte syntax van UML. Dit deel van UML laat toe om de statische structuur van een applicatie te specificeren en eveneens de specificatie van het gedrag van een bepaald object en de mogelijke interacties tussen objecten. Een tweede bijdrage van dit werk bestaat