Zum Hauptinhalt springen

Abschlussarbeiten

Bachelorarbeiten

Visualisierung für eine Software-Architekturprüfung in Virtual Reality - David Wagner (09, 2020)

PDF

Visualisierung von Warnsignalen - Eine empirische Studie zur Sicherheit mithilfe des Dual-Task-Paradigmas - Niclas Prock (09, 2020)

PDF

Modellierung einer Softwarearchitektur in Virtual Reality mithilfe der Leap Motion - Kevin Döhl (09, 2020)

PDF

Development of a Server for Code Smell Data - Felix Frederick Becker (02, 2020)

PDF

Modellgetriebene Entwicklung soll aus formalen Modellen ausführbare Software erzeugen. Solche Modelle sind jedoch nicht im Stande ein System komplett zu beschreiben, sondern reduzieren sich lediglich auf Aspekte, wie beispielsweise die Architektur. Daher muss der Entwickler des Systems Teile selbst implementieren, nachdem er aus dem Modell lauffähigen Quelltext generiert hat. Hierbei kann es passieren, dass der Entwickler entgegen der im Modell spezifizierten Protokolle handelt oder sich nicht an im Modell festgelegte Konventionen hält.

Ziel dieses Bachelor-Reports ist es, dem Entwickler ein Werkzeug zu bieten, mit dem er während der Entwicklung automatisiert Abweichungen des Quelltextes vom Modell identifizieren kann.

In diesem Kontext wird die modellgetriebene Softwareentwicklung, insbesondere mittels openArchitectureWare-Plattform, sowie die in Bauhaus-Suite implementierte Reflexionsanalyse untersucht.

Masterarbeiten

Eine der täglichen Aufgaben eines Wartungsprogrammierers ist es, die Orte der Realisierung eines Features im Quelltext eines Programms zu finden, um dieses zu erweitern oder Fehler zu korrigieren. Ziel dieser Arbeit ist es, eine integrierte Sicht über eine Softwareproduktlinie zu erstellen, die die aus Benutzersicht ausführbaren Features einer Softwareproduktlinie auf den Ort der Implementierung im Quelltext abbildet und gleichzeitig die Variabilität der Softwareproduktlinie, d.h. gemeinsame, optionale und sich unterscheidende Features, dokumentiert. Dies soll realisiert werden durch eine Instrumentierung des Quelltextes und darauf aufbauenden dynamischen Programmanalysen.

Diplomarbeiten

Als ein Vorteil tokenbasierter Verfahren zur Erkennung von Softwareklonen gilt, dass zur Vorbereitung nur eine lexikalische Analyse für die zu untersuchende Software durchgeführt werden muss. Ein Parser, der einen konkreten oder gar einen abstrakten, annotierten Syntaxbaum erstellt ist nicht nötig. Dadurch wird es möglich, Software zu analysieren ohne zuerst komplizierte Build-Systeme nachbilden zu müssen. Auch Quellcode mit Präprozessoranweisungen und syntaktischen Fehlern kann so untersucht werden.

Aus diesem Vorteil tokenbasierter Verfahren resultiert jedoch auch ein Nachteil. Aufgrund der lexikalischen Eingabe bestehen die erkannten Klone auch lediglich aus Sequenzen von Token. Syntaktische Informationen, die eine bessere Bewertung der erhobenen Daten ermöglichen könnten sind nicht vorhanden.

Das Ziel dieser Arbeit ist es, ein Verfahren zu entwickeln das ebendiese Informationen für die erkannten Klone erheben kann. Hierfür sollen die Klone oder die Dateien in denen sie enthalten sind mit Hilfe eines robusten Parse-Verfahrens untersucht werden, welches dabei den oben beschriebenen Vorteil tokenbasierter Klonerkenner erhalten und tolerant mit Problemen wie Präprozessoranweisungen oder syntaktischen Fehlern umgehen soll.

Moderne Software Herstellungs- und Distributionsprozesse führen in der heutigen Zeit immer häufiger zur Nutzung von Drittsoftware anderer Anbieter. Diese Modularisierung proprietärer Software führt immer häufiger zu Copyrightverletzungen im Open Source Bereich. Vielfach wurden in der Vergangenheit Fälle aufgedeckt in denen Software bzw. Hardwarehersteller Open Source Bibliotheken oder Teile davon nutzten und diese nicht nach den gegebenen Lizenzbestimmungen verwendeten. Das Problem bei einem Nachweis einer Verletzung ist aber, dass die nötigen Beweismittel in der Regel lediglich in Binärcode vorliegen. Diese Daten zu analysieren ist Ziel der Ausarbeitung. Es sollen Möglichkeiten erarbeitet werden, Binärclone in verschiedenen Dateien nachzuweisen. Diess könnten dann gegebenenfalls zum Nachweis von Copyrightverletzungen verwendet werden.

Aufgrund der Entwicklungen der letzten zehn Jahre - getrieben durch das Internet - gewinnen große, serverseitig betriebene und verteilte Systeme immer mehr an Bedeutung. Die Anforderungen an diese Systeme sind besonders in der Entwicklung durch Kriterien wie Wartbarkeit, Robustheit und Erweiterbarkeit geprägt und dahingehend angepasst worden. Ein gutes Beispiel für diese Entwicklung bietet das JavaEE Framework. Die Strukturen, welche zur Umsetzung der genannten Gütekriterien in dieses Framework integriert wurden, haben jedoch einen erheblichen Nachteil für die Analysierbarkeit des Sourcecodes der Software, die sich dieser Strukturen bedienen.

Durch die Komplexität und starke Kapselung von JavaEE-Applikationen sind aktuelle statische Analysen unpräzise und unvollständig. Da viele Komponenten erst zur Laufzeit vom Framework erzeugt werden, oder vom JavaEE-Framework in die Applikationen injiziert werden, ist hier das Laufzeitverhalten auf der Basis des Quellcodes für den Programmierer nicht offensichtlich. Das spezifische Verhalten von Klassen im JavaEE-Kontext wird lediglich durch Code-Annotationen und/oder statische Konfigurationsdateien (sog. Deployment Deskriptoren) festgelegt und entzieht sich somit der Betrachtung durch statische Codeanalysen.

Idee der Diplomarbeit ist es im Grundsatz, zur Verbesserung statischer Analysen, Informationen aus o.g. Elementen in entsprechende programmiersprachliche Konstrukte, die von statischen Analysen erfasst werden können, zu transformieren, bzw. den Quellcode an den entsprechenden Codestellen anzureichern. Diese Codestellen gilt es - als Teil der Diplomarbeit - automatisiert zu identifizieren und mit analysierbarem Code, der das Laufzeitverhalten - so die Hoffnung - ausreichend simuliert, anzureichern und qualifizierte Aussagen über die Güte dieser Herangehensweise zu treffen. Wesentliche Aspekte dieser Arbeit sollen vor allem die Prüfbarkeit als Qualitätsmerkmal von Software verbessern, die für den Hersteller eines Produktes sehr wichtig sein kann.

Motivation

Das Kopieren aus anderen Dokumenten ist beim Schreiben eine gängige Praxis. In vielen Fällen ist dies jedoch unerwünscht oder nicht legal - sei es, wegen des Urheberrechts oder weil in Prüfungssituationen fremde Leistungen nicht verwendet werden dürfen, ohne dass dies kenntlich gemacht wird.

In den Lehrveranstaltungen der AG Softwaretechnik erstellen die Studenten umfangreiche Textdokumente. Hierbei bleibt es nicht aus, dass Inhalte aus Abgaben früherer Semester kopiert werden, ohne dass dies kenntlich gemacht wird. Dies muss als Täuschungsversuch bewertet werden.

Aufgabe

Im Rahmen der ausgeschriebenen Arbeit gilt es ein Software-System zu implementieren, dass die Lehrenden bei der Erkennung solcher Plagiate unterstützt. Für die Arbeit bestehen folgende Rahmenbedingungen:

  • Die AG Softwaretechnik forscht intensiv im Bereich der Klonerkennung in Programmquelltexten. Werkzeuge hierzu sind vorhanden. Diese müssen für die Erkennung von Klonen in natürlichsprachlichen (deutschen) Texten angepasst und erweitert werden.
  • Suche in einem definierten und begrenzten Suchraum bestehend aus Dokumenten vorheriger Jahre.
  • Ein semi-automatischer Prozess zur Plagiaterkennung ist vorhanden. Auf diesem kann aufgebaut werden.
  • Neben der Erkennung von Klonen ist die Filterung der Ergebnisse notwendig:
    • Klone innherhalb von Dokumenten sind auszuschließen.
    • Klone zu Vorlagedokumenten - aus denen kopiert werden darf - sind auszuschließen.
    • Ausschluß von Klonen desseblen Autors
    • ...
  • Die Ergebnisse müssen in geeigneter Form visualisiert werden.
  • Testdaten zur Evaluierung der Implementierung stehen zur Verfügung.

Sowohl die Erkennung von Klonen in natürlichsprachlichen Texten, als auch die Plagiatserkennung sind aktuelle Themen in der Klon-Forschung.

Diese Arbeit kann als Diplomarbeit sowie Bachelor- oder Master-Report bearbeitet werden und wird ggf. im Umfang angepasst.

Die Evolution einer Software nachvollziehen zu können, ist in vielen Bereichen der Informatik eine ebenso interessante wie auch bedeutende Aufgabe. Es gibt sowohl wissenschaftliche Aspekte, zu denen vor allem die Analyse der Codequalität und die damit verbundenen Codeeigenschaften gehören, als auch praktische Einsatzgebiete, zu denen in erster Linie die Restrukturierung einer Software gehört. Das Projekt Bauhaus, das in Zusammenarbeit der Universität Bremen und der Universität Stuttgart entwickelt und gepflegt wird, beschäftigt sich genau mit dieser Aufgabenstellung und bietet verschiedene Werkzeuge zur Analyse von Code und Architektur einer Software.

Ziel dieser Forschungsarbeit ist es, eine möglichst effiziente Methode zu entickeln, die es ermöglicht nach spezifischen Codefragmenten in der gesamten Entwicklungshistorie einer Software zu suchen. Unabhängig davon, ob das gesuchte Codefragment in einer Programmversion als Klon auftritt oder nicht, soll jedes Vorkommen ermittelt und das Ergebnis in einer verständlichen Ausgabeform präsentiert werden.

Der Algorithmus zur Suche gleicher Codefragmenten soll dabei auf Basis bestehender Techniken entwickelt werden. Zu diesem Zweck eignet sich primär das Werkzeug clones, dessen Aufgabe es ist, Klone zu finden. Umgesetzt wurde die Klonerkennung in clones mit Hilfe von sogenannten Suffixbäumen, die eine besonders zeiteffiziente Suche, auf Kosten eines erhöhten Speicherbedarfs, erlauben. Aus diesem Grund gilt es insbesondere Aufmerksamkeit darauf zu verwenden, dass der Speicherbedarf nicht mehr als unbedingt nötig erhöht wird und ein Einsatz in der Praxis weiterhin gewährleistet ist.

Ein großes Problem für viele globale Code-Analysen ist die Größe der Projekte, auf die sie in der Praxis angewendet werden. Die auf der Grundlage von idealisierten Rechnern (Turingmaschine) entworfenen Algorithmen und Datenstrukturen stoßen bei der Analyse von Projekten mit Millionen von Zeilen an Quellcode schnell an die Grenzen der Rechenkapazität und des zur Verfügung stehenden schnellen Speichers (Arbeitsspeicher). Für die Klonerkennung in Bauhaus wird eine Datenstruktur namens Suffix-Baum eingesetzt, die extrem viel Laufzeit auf Kosten von erhöhtem Speicherverbrauch einspart. In dieser Diplomarbeit soll die dem Klonerkenner von Bauhaus zugrundeliegende Datenstruktur Suffix-Baum durch die ebenso mächtige Datenstruktur Suffix-Array ersetzt werden, die laut Literatur dieselben positiven Eigenschaften mit sich bringt, aber weniger Speicher benötigt.

Im einzelnen sollen hierfür bestehende Varianten der Suffix-Arrays verglichen und auf deren Eignung für die Klonerkennung hin überprüft werden. Anschließend soll die Datenstruktur für den gewählten Algorithmus möglichst speichersparend für Bauhaus entworfen und mit Routinen für den Aufbau der Datenstruktur und das Auslesen und die Übergabe der Informationen an den Klonerkenner implementiert werden. Eine Schwierigkeit der Aufgabe liegt dabei darin, dass der Aufbau der Datenstruktur in Linearzeit erfolgen soll, wie es auch schon beim bestehenden Algorithmus der Fall ist. Anschließend soll die Implementierung anhand großer Eingabeprogramme mit den bestehenden verglichen werden, um die Richtigkeit der Arbeit zu prüfen, sowie die Unterschiede in Laufzeit- und vor allem Speicherverbrauch zu sehen.

Ein Protokoll deniert die Sequenzeinschränkungen für die auf einer Software-Komponente ausgeführten atomaren Operationen. Ein im Bauhaus-Projekt entwickeltes Protokollerkennungsverfahren extrahiert solche Protokolle aus existierender Software mittels dynamischer Analyse. Java- Anwendungen mit mehreren Threads können jedoch nur eingeschränkt analysiert werden. In der vorliegenden Diplomarbeit werden daher Ansätze für die Erweiterung des existierenden Verfahrens zur Unterstützung von Multithreading entwickelt und evaluiert.

PDF

Ziel dieser Arbeit ist es die Ergebnisse der Klonerkennung - Werkzeuge, die duplizierten Programmquelltext identifizieren - dem Programmiererverfügbar zu machen, indem sie in die IDE Eclipse integriert werden. Der Software-Entwickler soll durch ein Plug-In auf existierende oder neu entstandene Klone hingewiesen werden. Insbesondere soll er bei der konsistenten Änderung von Duplikaten unterstützt werden.

Code-Duplikation ist ein ernst zu nehmendes Problem in industrieller Software, weil dadurch die Arbeit von Programmierer und Wartungs-Ingenieur erschwert wird. Kopierte Code-Fragmente bleiben jedoch nicht immer identisch erhalten. Sie werden an unterschiedlichen Stellen geändert, dadurch entstehen eine Menge kleiner Klone (Typ-1, Typ-2), die von vielen Klonerkennungstools erkannt werden. Einige Ansätze versuchen größere Klone – Typ-3 Klone – zu finden, indem sie die kleinen Klone zusammenfassen. Dabei wird lediglich der Zeilenabstand zwischen den Klonen betrachtet. Typ-3 Klone sind im Vergleich zu Typ-1 und Typ-2 Klonen relevanter und könnten leicht zu entfernen sein. Untersuchungen zufolge sind nur 25 Prozent der erkannten Typ-3 Klone als echt bezeichnet worden. Ziel dieser Arbeit ist, ein neues Verfahren zu entwickeln, mit dem bessere Typ-3 Klone gefunden werden. Dabei sollen Kriterien, nach denen zwei oder mehrere Typ-1 und Typ-2 Klone zusammengefasst werden, ermittelt sowie die Zusammenfassung von Klonen implementiert und evaluiert werden.

Es wurden bereits viele Metriken und auch verschiedene Vorhersagemodelle auf ihre Tauglichkeit bei der Vorhersage von Software-Fehlern untersucht. In dieser Arbeit werden drei ausgewählte und bisher nicht beachtete Kontrollflussmetriken auf ihre Vorhersagekraft von Software-Fehlern untersucht. Zur Vorhersage werden Klassifikationsverfahren eingesetzt, die ausschließlich durch überwachtes Lernen trainiert werden. Die Bewertung der Metriken wird anschließend mit Hilfe verschiedener Performanz Maße vorgenommen. Dabei werden die Ergebnisse der untersuchten Kontrollflussmetriken mit den Ergebnissen objektorientierter Metriken sowie einfacher intraprozeduraler Metriken verglichen. Dabei stellte sich heraus, dass die untersuchten Metriken für sich alleine betrachtet schlechter abschneiden als die anderen Metriken. In Kombination mit den anderen Metriken führen sie allerdings zu einer Verbesserung der Ergebnisse.

Duplikate im Quelltext von Programmen - so genannte Klone - haben negative Auswirkungen auf die Wartbarkeit von Software. Der Umgang mit ihnen wird dadruch erschwert, dass Kopien im Nachhinen verändert werden können, so dass eine Entfernung des Klons nicht ohne weitere Modifikationen möglich ist. Ziel dieser Arbeit ist es solche Klone zu vergleichen und den Software-Entwickler dabei zu unterstützten sie zu entfernen.

PDF

Die Werkzeuge des Bauhausprojektes bieten umfassende Möglichkeiten zur Analyse von bestehenden Softwaresystemen. Mit Gravis existiert eine Workbench für diese Werkzeuge, in der allerdings eine Rückverknüpfung von der Modellsicht zum ursprünglichen Code zur Zeit nur unzureichend vorhanden ist. Eine Rückverknüpfung in den Kontext der Programmerstellung ist wünschenswert, da viele Softwaresysteme innerhalb einer Integrierten Entwicklungsumgebung wie z.B. Eclipse erstellt und weiterbearbeitet werden, und eine blosse Anzeige des Quelltextes in einem einfachen Texteditor der Benutzererwartung nicht gerecht wird.

Bei dieser Diplomarbeit soll es darum gehen, vor dem geschilderten Hintergrund einen angemessenen Integrationsweg zwischen den Bauhaus Werkzeugen und Eclipse zu schaffen. Dazu soll aus der Java Umgebung von Eclipse heraus eine native Schnittstelle zu dem Resource Flow Graphen (RFG), einer grundlegenden Datenstruktur für die Analysemethoden, definiert werden. Ziel ist es, eine in die Eclipse Umgebung integrierte Visualisierung der RFG Modellsicht zu erhalten, für die beispielhaft eine Analysemethode als Use Case implementiert werden soll. Abschliessend soll evaluiert werden, welche weiteren Anwendungen sich aus der Integration zwischen Anforderungen aus dem Bauhausprojekt und den Möglichkeiten der Eclipse Plattform ergeben.

Ein Software-Projekt basiert in den seltensten Fällen auf einer grundlegenden Neuentwicklung. Durch Wiederverwendung von Komponenten und Anpassungen des Codes an neue Bedürfnisse entstehen Software-Varianten. Existieren mehrere Varianten einer Basissoftware, so spricht man von einer Software-Produktlinie. Je größer die Anzahl dieser Software-Varianten, desto teurer und schwieriger wird die Wartung. Außerdem birgt die Entwicklung von Software-Produktlinien ein großes Risiko: Die Komponenten werden mit den darin enthaltenen Fehlern wieder verwendet. Ein Fehler in der Basissoftware befindet sich also in allen Varianten, die den betroffenen Teil der Software benutzen. Um den Fehler zu finden und mit möglichst geringem Aufwand beheben zu können, ist es hilfreich, die Gemeinsamkeiten und Unterschiede zwischen den einzelnen Varianten zu kennen.

Ziel dieser Arbeit ist es, eine Produktlinie mit Gemeinsamkeiten und Unterschieden zwischen Software-Varianten mit Hilfe des Ressource Flow Graph (RFG) abzubilden um Software-Varianten zu konsolidieren.

Mit der Java-Version 1.5 (oder 5.0) kamen einige neue Konstrukte zum Sprachumfang der Programmiersprache hinzu. Programme, die diese Konstrukte nutzen, können also nicht mit den bisherigen Frontends zur Erzeugung der IML - einer Programmrepräsentationsform, die Kontroll- und Datenfluss darstellt - übersetzt werden. Um weiterhin alle Java-Programme in IML abbilden zu können, muss also 1. eine Modellierung der neuen Konstrukte in der IML gefunden und 2. ein neues Frontend implementiert werden. Die Modellierung sollte dabei die Semantik korrekt und so weit wie möglich vergleichbar mit ähnlichen Konstrukten derselben und anderer Sprachen abbilden, gleichzeitig aber einen Rückschluss auf das Aussehen des Quelltexts zulassen. Zusätzlich sollte sich die neue Modellierung nahtlos einfügen, so dass möglichst wenig Anpassungen an bestehenden Analysen und sonstigen Benutzern der IML nötig sind. Das neue Frontend sollte alle gültigen Programmtexte in valide IML überführen können und dies in angemessener Zeit tun.

Ziel der Arbeit ist es, diese beiden Aufgaben zu lösen. Als Vorbereitung soll ein Tool implementiert werden, dass einen Vergleich von IML-Teilgraphen durchführt und Unterschiede aufzeigt. Mit dessen Hilfe sollen generierte IMLs existenter Frontends verglichen werden um Unterschiede oder Fehler in der Generierung zu entdecken, vor allem aber um die vom neuen Frontend genutzte Modellierung festzulegen.

Dass das Finden, Verstehen und Entfernen von Klonen - dupliziertem Quelltext - in Software-Systemen von Interesse ist, haben viele Arbeiten gezeigt. Bisherige Analysen zum Vorhandensein von Klonen beschränken sich zumeist auf einen konkreten Stand des zu untersuchenden Systems. Da sich Software-Systeme über die Zeit jedoch ändern, stellt sich auch die Frage nach der Evolution von Klonen. Um diese Frage zu beantworten, müssen existierende Analysemethoden erweitert werden.

Ziel der Arbeit ist es ein Verfahren zu entwickeln und umzusetzen, das es erlaubt mehr als eine Version eines Software-Systems auf Klone hin zu untersuchen. Die Herausforderung besteht zum einen in der Beschleunigung der Erkennung und zum anderen in der Aussage darüber, welche Klone hinzugefügt, entfernt bzw. unverändert sind. Hierzu werden Ergebnisse der Analyse einer Version für die Analyse der nächsten Version wiederverwendet. Die Umsetzung geschieht durch Anpassung eines Werkzeugs, welches ein token-basiertes Erkennungsverfahren implementiert.

PDF

Die Praxis zeigt, dass die meisten Ressourcen in der Softwareentwicklung nicht für die Erstellung von neuen Systemen verwendet werden, sondern für die Wartung von bestehenden Programmen. Hierbei hat die Software-Qualität einen entscheidenden Einfluss auf die Produktivität der Weiterentwicklung und Wartung. Um die kontinuierliche, kosteneffiziente Durchführung von Qualitätssicherungsmaßnahmen zu gewährleisten, bedarf es an Unterstützung durch Werkzeuge. Ziel dieser so genannten IT-Dashboards oder Software-Leitstände ist es, Entwicklern, Architekten, technischen Projektleitern und Qualitätsverantwortlichen, die wesentlichen Informationen über den Qualitätszustand eines Softwareprodukts anzuzeigen.

Ziel dieser Diplomarbeit war die Entwicklung eines web-basierten Dashboards für das Bauhaus-Projekt, dass die von den verschiedenen Analyse-Werkzeugen generierten Daten sammelt und in geeigneter Form visualisiert. Zusätzlich zur Betrachtung eines Softwaresystems zu einem bestimmten Zeitpunkt, sollte der zeitliche Verlauf der Messgrößen verfolgt werden können. Da diese Funktionalität im Vorfeld nicht existierte, wurde ein Datenbankschema entwickelt, das die Speicherung von Informationen über ein Softwaresystem für mehrere Versionen ermöglicht.

PDF

Fünf Jahre nach dem ersten Release des .NET-Framework, ist dieses in der nächsten Generation der Windowsbetriebssysteme (Windows Vista und Windows Server 2003) fest verankert und somit nicht mehr nur noch ein "kann", sondern schon fast ein "muss" für die Windowsapplikationsentwicklung geworden.

Das .NET-Framework ist eine einheitliche, objektorientierte Plattform mit eigener Laufzeitumgebung ähnlich zum Java-Framework. Die Laufzeitumgebung zeichnet sich durch eine standardisierte Sprachspezifikation (Common Language Specification), sowie ein einheitliches Typesystem (Common Type System) aus. Beides ermöglicht das Entwickeln von Programmkomponenten in verschiedenen Sprachen und somit z.B. die Verwendung von Fertigkomponenten egal in welcher Sprache sie geschrieben wurden. Derzeit kann zum Entwickeln unter ca. 70 Sprachen gewählt werden, deren Compiler bereits an diese Plattform angepasst wurden.

Ziel dieser Arbeit ist es, die mit dem .NET-Framework zusammen entwickelte Sprache C# in einem Resource Flow Graph (RFG) und somit die Kernstruktur der Common Language Specification abzubilden.

PDF

Der Graph-Visualisierer "Gravis" als Bestandteil des Bauhaus-Frameworks erstellt Darstellungen der architektonischen Sichten eines Systems, bietet aber bisher keine Manipulationsmöglichkeiten des Quellcodes an. Während der Wartung sind jedoch nicht nur die Architektursichten eines Systems von Interesse, sondern vor allem auch der Quellcode. Um jedoch Eingriffe im Quellcode vornehmen zu könnnen, muss neben Gravis ein Editor herangezogen werden.

Inhalt der Diplomarbeit soll die Durchführung einer Machbarkeitsstudie sein, die eine Einbettung von Gravis in die integrierte Entwicklungsumgebung Eclipse untersucht. Damit soll neben der Darstellung der Graphen auch das Verändern des Sourcecodes innerhalb von Eclipse unterstützt werden. Eclipse eignet sich im Besonderen, weil es bis auf einen kleinen Kern aus Plugins besteht und daher für die Integration und Entwicklung weiterer Plugins prädestiniert ist.

Kernfragen der Diplomarbeit sind neben der technischen Implementierung des Plugins die Kommunikationsschnittstelle zwischen den beiden Prozesse und die Anpassung von Gravis für eine Einbettung in Eclipse.

Duplizierter Quellcode, auch Klon genannt, ist ein weit verbreitetes Problem in Softwaresystemen und ist unter anderem aus diesem Grund auf Platz eins von Beck und Fowlers "Stink Parade of Bad Smells". Klone verschlechtern im Allgemeinen die Wartbarkeit der Software und erschweren die Fehlerkorrektur, da Fehler unter Umständen auch geklont wurden und das Softwaresystem größer und damit schwerer zu verstehen ist. Es gibt eine Reihe von Möglichkeiten Klone zu entfernen, welche zum Teil durch Refactorings beschrieben sind. In vielen Systemen ist das Entfernen aller Klone jedoch zum einen zeitaufwendig, zum anderen auch nicht immer erwünscht oder möglich. Gerade im embedded Bereich sind Speicherverbrauch und Performance wichtige Anforderungen, die eventuell durch zusätzlichen Funktionen und Funktionsaufrufe nicht mehr erreicht werden können. Zudem gibt es eine Reihe von Klonen, die ein Entwickler nicht als solche ansehen würde und die er deshalb gar nicht gemeldet bekommen möchte und auch nicht entfernen möchte.

Ziel der Diplomarbeit soll es sein anhand eines Beispielsystems aus dem embedded Bereich zu untersuchen, wie ein Entwickler beim Umgang mit Klonen in größeren Systemen unterstützt werden kann. Hierzu soll das bestehende Bauhaus-Framework so erweitert werden, dass es auf der einen Seite dem Entwickler ein Überblick über die vorhandenen Klone geben kann und auf der anderen Seite versucht automatisiert zu bewerten, ob es möglich ist einen Klon zu beseitigen und wie sinnvoll dies ist.

PDF

Die Wartbarkeit eines Systems objektiv zu beurteilen ist ein relevantes Problem. Die Frage stellt sich nicht nur bei der Übernahme fremder Software oder Beurteilung von Software im Falle von Outsourcing, sondern auch stets für die selbst entwickelte Software, um kontinuierlich Trends in der Entwicklung beobachten und Schwachstellen aufdecken zu können.

In einem unlängst erschienenen Buch von Frank Simon et al. [1] wird eine Methode zur Bestimmung eines so genannten Softwarequalitätsindex vorgestellt, der einen Indikator für die interne Produktqualität darstellen soll. Der Index beruht auf der Messung von Code-Anomalien (von Fowler auch "Bad Smells" genannt). Die Autoren haben insgesamt 167 Projekte vermessen und die Daten in einer Datenbank abgelegt, die für das Benchmarking verwendet werden kann. Diese Datenbank befindet sich im Besitz der Firma SQS, für die einer der Autoren tätig ist.

In dieser Diplomarbeit soll ein Werkzeug entwickelt werden, das auf der Basis der Bauhaus-Infrastruktur den Softwarequalitätsindex für C++ und Java-Programme (soweit sich die IML-Repräsentation der Java-Programme mit der von C++ Programmen deckt) berechnet. Dazu kann auf die Scripting-Fähigkeiten für den RFG und die IML zurück gegriffen werden. Es ist aber auch möglich, die Metrikerhebung in Ada direkt zu implementieren. Das Werkzeug soll die Daten in Form generierter statischer HTML-Seiten so aufbereiten, dass das Zustandekommen des Softwarequalitätsindex auf allen Ebenen nachvollziehbar ist. Insbesondere sollen die entdeckten Code-Anomalien leicht zugänglich und verständlich aufgelistet werden. Während die Ausgabe in HTML einen prototypischen Charakter haben kann, legen wir besonderen Wert auf die Qualität der Metrikerhebung.

Zur Evaluation des entwickelten Werkzeugs soll eine Reihe von Softwaresystemen vermessen werden und in Absprache mit der Firma SQS mit der SQS-Benchmark verglichen werden.


[1] Frank Simon, Olaf Seng und Thomas Mohnhaupt: "Code-Quality-Management - Technische Qualität industrieller Softwaresysteme transparent und vergleichbar gemacht", dpunkt.verlag, 2006.

PDF

Welche Maßnahmen, dargestellt an einer praktischen Umsetzung, führen zu einer Verbesserung innerhalb der Softwareentwicklung am Beispiel eines IT- Großprojektes der Volkswagen AG?

Abstract:

Wie die Marktforscher der Standish Group ermittelt haben, dauern 53 Prozent der Projekte länger und kosten viel mehr als geplant. 18 Prozent der IT-Projekte scheitern gänzlich. [Titel der Untersuchung: 'Chaos Report'] Der häufigste Grund für das Scheitern von IT-Projekten sind nach einer Studie unklare Formulierung der Anforderungen und Ziele. Auch das Produkt des dieser Untersuchung zu Grunde liegenden Projektes wurde nach mehrmaligen Terminverschiebungen in einem instabilen und inakzeptablen Zustand an den Kunden ausgeliefert. Ziel der Diplomarbeit ist es, diese Probleme zu identifizieren und unter der praktischen Umsetzung eines Lösungsvorschlages eine Entwicklungsverbesserung zu erzielen.

Im Rahmen des Bauhaus-Projekts wurden bisher vornehmlich kompilierte Programmiersprachen untersucht und integriert. In der Arbeit "Statische Programmanalyse für Perl" hingegen wurde die interpretierte und sehr dynamische Programmiersprache Perl hinsichtlich ihrer statischen Analysierbarkeit und möglichen Integration in das Bauhaus-Projekt untersucht. Dabei wurden zum einen die allgemeinen Probleme beim Parsen von Perlprogrammen erläutert und zum anderen eine prototypische Implementierung entwickelt, welche ein Perlprogramm in einen RFG überführen soll.

Es soll ein Interpreter für die sprachenübergreifende Programmrepräsentation IML erstellt werden. Zweck des Interpreters ist die Laufzeitanalyse eines beliebigen Programms anhand von dessen Quelltext. Des Weiteren sollen Korrektheitsüberprüfungen sowie das Debuggen und Profilen des Programms möglich sein.

PDF

Visual Basic ist eine populäre Programmiersprache, die in ihrer jüngeren Entwicklung so weitgehenden Veränderungen unterworfen wurde, dass die Abwärtskompatibilität zu den vorherigen Versionen gebrochen wurde. Vorhandene Altsysteme, die vor diesem Umbruch entstanden sind, lassen sich nur durch manuelles Zutun zu den neueren Versionen oder gänzlich anderen Sprachen migrieren. Diese Aufgabe erfordert ein umfassendes Verständnis der zu migrierenden Softwaresysteme. Hierbei können die Werkzeuge des Bauhaus-Projekts helfen, indem sie verschiedene Aspekte von Software analysieren und durch geeignete Darstellungen verständlich machen. Eine solches Darstellungsform ist der Resource Flow Graph, der Programme auf einer globalen Abstraktionsebene repräsentiert. Ziel dieser Arbeit war es daher Werkzeuge zu schaffen, die es ermöglichen den Resource Flow Graph für Visual Basic 6 Programme zu erzeugen.

Die Analyse von Visual Basic 6 Programmen wurde durch viele Besonderheiten, vor allem aber durch die unvollständige Dokumentation der Sprache, erschwert. So existierte im Vorfeld keine vollständige Grammatikdefinition, ebenso sind semantische Aspekte zum Teil nicht dokumentiert. Dieses fehlende Wissen musste zunächst hergeleitet werden, um schließlich Werkzeuge zur Extraktion der für den RFG benötigten Fakten zu realisieren. Die Arbeit betrachtet verschiedene Herangehensweisen und wählt ein Vorgehen, bei dem zunächst initiale Modelle für Syntax und Semantik aufgrund von Handbüchern und Annahmen erstellt und dann schrittweise durch Tests verfeinert wurden. Neben der statischen Analyse war auch die Abbildung von Visual Basic 6 auf die Konzepte des RFG, sowie die Generierung von konkreten Graphen aufgrund der extrahierten Fakten Teil der Arbeit. Das bestehende RFG-Modell musste hierzu erweitert werden, um die Visual Basic 6 Programme vollständig abbilden zu können.

PDF

Untersuchungen zu Folge sind 5–15% eines industriellen Software-Systems redundant. Solche Redundanzen wirken sich nachteilig auf die Entwicklung eines Software-Systems aus, denn sie erhöhen den Wartungsaufwand. Änderungen an duplizierten Codefragmenten müssen an allen vorkommenden Stellen im Quellcode vorgenommen werden. Gleichzeitig erhöhen sie unnötigerweise die Größe des Systems und reduzieren damit die Übersichtlichkeit für den Softwareentwickler.

Ziel dieser Arbeit ist es, adäquate Visualisierungsformen zur Darstellung der Ergebnisse verschiedener Klonerkennungs-Algorithmen zu konzipieren. Diese sollen in das bereits existierende Reengineering-Werkzeug Gravis integriert werden.

PDF