Thesisvoorstel : Software Refactoring met en Reverse Engineering naar UML

Promotor

prof. Albert Hoogewijs

Vakgroep

Zuivere Wiskunde en Computeralgebra

Inleiding

Oudere software (lees: in een 3de generatie programmeertaal geschreven) kan dezer dagen nauwelijks gepast worden in modern systeemontwerp. Tot vandaag toe, wordt zeer snel naar een 3de generatie, eventueel object georiŽnteerde, programmeertaal gegerepen om ideeŽn te verwezenlijken. Modern systeemontwerp maakt echter gebruik van diagrammen, schakelschema's, organigrammen, enz. Een logisch geformuleerde en gestructureerde ontwerpomgeving, zoals UML, wordt hierbij gebruikt. Het is niet ondenkbaar dat op een gegeven moment in een project handgeschreven code gepast moet worden in het diagrammatisch ontwerp. Men heeft echter meestal geen tijd om zulke stukken code te herdenken en te herformuleren als logische diagrammen. Daarbij komt nog dat men uit handgeschreven, object georiŽnteerde code niet op een eenvoudige manier een diagramrepresentatie kan afleiden. Men verliest immers meestal informatie bij de transformatie van ťťn denksysteem in een ander. Deze scriptie gaat over de omzetting van object georiŽnteerde code naar UML-diagrammen.

Doelstelling

Deze scriptie formuleert een studie in de transformatie van javacode naar UML-diagrammen. Deze omzetting is reeds voor een stuk gerealiseerd en gedocumenteerd. Er werd ook toolsupport voorzien. Als inleiding op het onderwerp zal deze informatie bestudeerd worden. Nadien willen we ons toespitsen op het dynamisch gedrag van software en de omzetting ervan naar dynamische UML-diagrammen. Er zal een techniek ontwikkeld worden om (dynamische gedeelten van) javacode om te zetten naar zogenaamde statecharts.

Hierbij willen we ons beperken tot "eenvoudige code". Met "eenvoudige code" denken we aan: het gedrag van een memory-controller (met interrupt-gebaseerde io), programma's geschreven voor microjava, gedrag van embedded systems. In het kort: systemen met weinig objecten en eenvoudige communicatie(protocollen).Het zal zaak zijn deze communicatie tussen objecten (naar type en temporeel gedrag) automatisch af te leiden uit de javacode voor een systeem. Attribuutwaarden van objecten zullen moeten worden nagegaan en gegroepeerd worden als states in statecharts. Een vrij naieve implementatie van deze functionaliteit zal in eerste instantie worden nagestreefd. Van zodra we over statecharts beschikken (die bij naieve implementatie zeer veel states zullen tellen) willen we verderwerken met transformaties op deze naieve statecharts om zo tot realistische en logisch verstaanbare versies te komen. Transformaties zullen concurrency, hierarchy, pseudostates, enz. introduceren om zo de naieve statecharts te verduidelijken. Een duidelijke (formele) definitie van "eenvoudige code" en de beperkingen die gelegd moeten worden op de code, om geldig omgezet te kunnen worden naar statecharts, zal gezocht moeten worden.

Er wordt een case-study aangeboden om de ontwikkelde technieken op uit te proberen. De practische uitwerking van dit voorbeeld is ook een doelstelling van deze scriptie.

Achtergrond

Software refactoring en reverse engineering zijn zeer hedendaagse begrippen in modern software-ontwerp.

Software refactoring maakt gebruik van statische en structurele eigenschappen van object georiŽnteerde software om automatisch "vernieuwingen" aan te brengen in oudere softwaremodules (verandering van datatypes, methodecreatie als macro voor een stuk veel terugkerende code, met de daarbij hordende analyse van tijdelijke variabelen, globale variabelen en input en output van deze methodes). Men wil zulke veranderingen in modern ontwerp eenvoudiger maken door met diagrammen en automatisch gegenereerde uitvoerbare code te werken. Software-refactoringsexperts willen verder gaan in de analyse en aanpassing van oudere code. Men wil het dynamisch gedrag van code analyseren en tranformeren. De omzetting van javacode naar statecharts kan de weg naar deze doelstelling openen. Daarom ook zijn verschillende bedrijven (waaronder Rational Corporation, IBM) aan het zoeken naar reverse-engineeringstechnieken, juist omdat manipulatie van het gedrag van objecten eenvoudiger is in diagramrepresentatie (door abstractie).

Reverse engineering probeert object georiŽnteerde code om te zetten naar diagrammen, meestal UML-diagrammen. Er bestaan reeds enkele CASE-tools (waaronder Rose van Rational Corporation en Rhapsody van ILogix) met UML-support die reverse engineering (importeren van java source-code-bestanden) ondersteunen. Sommige van deze tools gebruiken we ook in ander onderzoek.

Deze scriptie legt een link tussen software refactoring en reverse engineering. We willen met reverse engineeringstechnieken, een dynamische analyse maken van code op basis van statecharts. Hierdoor zal de impact van veranderingen aan dynamische code doorheen het totale systeem kunnen worden afgeleid. En dit is nu net de eigenschap waar men naar streeft bij software refactoring.

Voorkennis

Studierichting

Layout