logo

You are here

Warning message

Attention! This event has already passed.

Inconsistency Management in Model-Driven Engineering An Approach using Description Logics

Friday, 23 September, 2005 - 16:00
Campus: Brussels Humanities, Sciences & Engineering campus
Faculty: Science and Bio-engineering Sciences
D
0.05
Ragnhild Van Der Straeten
phd defence

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 modelmanipulatie.
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 definitie,
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 modelleertaal
is, zou het een belangrijke rol moeten spelen in modelgebaseerde ontwikkeling.
Een software ontwerp is meestal een collectie van UML diagrammen, waardoor er een inherent
risico is dat de globale specificatie van het systeem inconsistent is. Modeltransformaties,
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 gebruik
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 uit een
classificatie van mogelijke inconsistenties tussen en binnen modellen die beantwoorden aan
het geformaliseerde deel van UML. Deze inconsistenties worden gedefinieerd op een precieze
manier aan de hand van de vooropgestelde formalisatie. Inconsistentiebeheer omvat niet
alleen de definitie maar ook het oplossen van inconsistenties. Deze activiteit brengt een
aantal specifieke uitdagingen met zich mee. We geven dan ook een overzicht van deze
uitdagingen.

Gebaseerd op onze formalisatie, op de classificatie van een verzameling inconsistenties
en op de verschillende uitdagingen gepaard gaande met het oplossen van inconsistenties,
kunnen een aantal sleutelcriteria gedistilleerd worden. Elk van deze criteria heeft een aantal
specifieke vereisten die gebruikt kunnen worden om een formalisme en ondersteuning voor
de definitie, detectie en oplossing van inconsistenties, te evalueren.

Het tweede aspect waarop de aandacht gevestigd wordt in deze thesis, is de evaluatie van
“Description Logics” als formalisme voor inconsistentie detectie en resolutie en dit aan de
hand van de sleutelcriteria. DL is een fragment van eerste-orde predikatenlogica en definieert
een familie van logische talen. Deze talen bieden een classificatietaak aan gebaseerd op een
subconcept-superconcept relatie. Ze zijn zeer geschikt voor het redeneren over hi¨erarchie¨en
en over de consistentie van kennisbanken.

In dit werk gaan we niet alleen na in hoeverre DLs geschikt zijn voor het representeren
van het door ons geformaliseerde UML fragment, maar ook in hoeverre de gedefinieerde
inconsistenties kunnen gedetecteerd worden en in hoeverre het mogelijk is om inconsistenties
op te lossen gebruik makende van deze logica’s en de bestaande ondersteunende systemen.

Modeltransformaties worden beschouwd als zijnde het hart en de ziel van modelgebaseerde
ontwikkeling. Modelherstructureringen zijn ´e´en welbepaalde soort van modeltransformaties.
Deze transformaties herstructureren modellen. De tegenhanger van modelherstructureringen
zijn broncodeherstructureringen. Deze herstructureringen zijn bekend
en goed bestudeerd. Herstructureringen bewaren gedragseigenschappen die uitgedrukt kunnen
worden tussen het originele model en het geherstructureerde. Wij tonen hoe een aantal
van onze gedefinieerde consistenties corresponderen met bepaalde gedragseigenschappen.
Een tweede idee is om inconsistentie detectie en resolutie technieken te gebruiken ter ondersteuning
van het uitvoeren van modelherstructureringen door een software ontwikkelaar.

Om de idee¨en en benadering voorgesteld in deze thesis te illustreren en te valideren wordt
gebruik gemaakt van een verzameling modellen die de specificatie van een geldautomaat
simulatie voorstellen. Hiervoor hebben we een prototype programma ontwikkeld, genaamd
RACOoN, dat ge¨ıntegreerd is in een bestaand UML ondersteunend progroamma.