Architecture Recovery and Software Evolution Analysis
Main
CAFÉ
Application Areas

People
TU Vienna
Partners

Publications
Papers
Technical Reports

References
Architecture Recovery
Software Evolution

For Students
Praktika
Master's Theses

Praktika and Master's Theses

Diplomarbeit: Predicting the future in software projects

Status:
Begin as soon as possible. Finish 2006.
Goal:
Development of a prediction model for bug fixing during software projects. Data from process related tools like source code management (e.g. CVS) and bug tracking systems (e.g. Bugzilla) has to be used for prediction models. The models themself should be build with data mining techniques for sequential data mining.
Description:
To support project steering based on software evolution, we are going to estimate software development based on a cost function. As cost function we select the amount of bug fixing during development. Therefore the number of bug fix events in the evolution of a software is interesting as well as the resources that are blocked during software projects.

The development of a software system can be described through a sequence of engineering events. On a higher level these events are grouped to process models of software development. In such sequences each event is seldom isolated but related to others. For example, when a class in an object oriented system has to communicate with some other classes, they are related with each other and also their production process (i.e. the designing and programming of these classes) is strongly related.

In this masters thesis the relationship of the different events during the software maintenance and the bug rate has to be investigated. Therefore, data from process IT system, such as CVS) and Bugzilla has to be extracted and analyzed with data mining approaches, where sequences of events have to be taken into account. Sequential data mining is a broad discipline where the relationship of sequences of events are used to predict future events. In our case bug frequences have to be predicted based on software process event sequences.



The thesis provides the opportunity to learn about data mining and how it can be used to steer software projects.
Tools to use:
CVS, Bugzilla, Java, Databases, Data Mining (Sequential Pattern Mining)
Betreuer:
Harald Gall
Kontakt:
Jacek Ratzinger

Praktikum: Data Extractors for Eclipse

Status:
Begin as soon as possible. Finish SS 2006.
Goal:
Development of Parsers and Tools for the extraction of data from source code versioning tools (e.g. CVS, Subversion, ClearCase) and issue tracking systems (e.g. Bugzilla, Jira, ClearQuest)
Description:
During previous work done at the Distributed Systems Group a data model for software evolution analysis was developed. This data model defines a database structure of software evolution data to assess the development and maintenance of software projects. The data is extracted from diefferent information systems used during software development like versioning and issue tracking systems.

Already parsers for CVS and Jira are in place. During the Praktikum parsers for other information sources like Subversion, ClearCase and Bugzilla, ClearQuest should be developed. Therefore, the data model and database access objects that already exist can be used. The additional parsers for the new systems have to be developed. The extraction of source code versioning information can already be done through an Eclipse plugin. A great goal of this Praktikum would be to develop such frontend (GUI) for the extraction of issue tracking systems like Bugzilla.

Tools to use:
Subversion, ClearCase, Bugzilla, ClearQuest, (two of them) Java, Databases, Eclipse
Betreuer:
Harald Gall
Kontakt:
Jacek Ratzinger

Praktikum: Evaluation of tools for Data Mining

Status:
Begin as soon as possible. Finish SS 2006.
Goal:
Evaluate different data mining tools based on their feature descriptions and try simple examples with the most promising tools.
Description:
Data Mining can be defined as "The nontrivial extraction of implicit, previously unknown, and potentially useful information from data". Data Mining is often used to build a prediction model for future events.
A simple example of data mining is its use in a retail sales department. If a store tracks the purchases of a customer and notices that a customer buys a lot of silk shirts, the data mining system will make a correlation between that customer and silk shirts. The sales department will look at that information and may begin direct mail marketing of silk shirts to that customer, or it may alternatively attempt to get the customer to buy a wider range of products.

There are several different types of data mining, including:
1.Predictive models. These types of models predict how likely an event is. For example, how likely a credit card transaction is to be fraudulent.
2.Summary models. These models summarize data. For example, a cluster model can be used to divide credit card transactions into different groups depending upon their characteristics.
3.Network models. These types of models uncover certain structures in data represented by nodes and links. For example, a credit card fraud ring may surreptitiously collect credit card numbers at a pawn shop and then use them for online computer purchases.
4.Association models. Sometimes certain events occur frequently together. For example, purchases of certain items, such as beer and pretzels, or a sequence of events associated with component failure.

At our research group we are particularly interested in seqeuntial data mining. The task of this Praktikum is to evaluate tools for their ability in sequential data mining. The tools should be analysed how they can solve the problem of sequence classification, which is the task to predict a single label y that applies to an entire input sequence (x1, x2, ..., xn). For example, during software engineering a lot of tasks have to be done (e.g. requirements analysis, design, coding, testing, ...) these tasks form a sequence of events. Such sequences could be analyzed with data mining tools to estimate the quality of the output (= software product).
Tools to use:
list of data mining tools (under free and shareware):
  • http://www.kdnuggets.com/software/suites.html
  • http://dmoz.org/Computers/Software/Databases/Data_Mining/Public_Domain_Software/
  • http://www.kdnuggets.com/software/libraries.html
  • http://www.kdnuggets.com/software/sequence.html
tool vendors
  • http://dmoz.org/Computers/Software/Databases/Data_Mining/Tool_Vendors/
Betreuer:
Harald Gall
Kontakt:
Jacek Ratzinger

Diplomarbeit: Understanding and Improving Software Projects

Status:
Beginn sobald als möglich. Abschluss SS 2006.
Ziele:
Erkennen von Regelmäßigkeiten in Software-Entwicklung, die zu Fehlern (bugs) führen, um ein Fehlervorhersagemodell zu entwickeln. Dieses kann in weiterer Folge in Softwareprojekten einerseits zur Fehlervermeidung und andererseits zur Fehlererkennung verwendet werden.
Beschreibung:
Bei Software-Entwicklung trägt jede Änderung und Erweiterung eines Programms ein gewisses Potential einen oder mehrere Fehler (bugs) zu erzeugen. Daher soll im Rahmen dieser Arbeit der Zusammenhang zwischen den Eigenschaften von Änderungen und sowohl Fehlerhäufigkeit als auch Fehlerart analysiert werden.
Bei der Entwicklung von mittleren bis großen Softwareprojekten werden aufgetretene Fehler üblicherweise durch ein Bug-Tracking-Systeme verwaltet (z.B. Bugzilla). Bei der Erfassung werden Fehlermeldungen nach Schwere und Priorität kategorisiert, woraus die Fehlerhäufigkeit bzw. -art hergeleitet werden kann.
Die Zusammenhänge zwischen den Softwareänderungen und den auftretenden Fehlern sollen als Grundlage für ein Fehlervorhersagemodell dienen. Dabei soll eine Software für neuronale Netze verwendet werden, da sich diese Systeme für sich verändernde Softwarestrukturen als sehr geeignet erweisen. Als Abschluss sollte dieses Vorhersagemodell an Hand von mehreren open-source Projekten (z.B. Mozilla, Eclipse, JBoss, Postgres, etc.) evaluiert werden, um die Effizienz dieses Modells zu überprüfen.
Aufgaben im Zuge dieser Arbeit:
  • Extraktion von Daten aus Bugzilla und CVS mittels am Institut entwickelten tools.
  • Analyse der Zusammenhänge zwischen Fehlern und deren Eigenschaften
  • Erlernen des Umgangs mit neuronalen Netzen.
  • Einsatz von existierenden Programmen für neuronale Netze, um mit den erkannten Zusammenhängen, ein Fehlervorhersagemodell aufzubauen.
  • Anwenden des Vorhersagemodells auf open-source Projekte, um Praxistauglichkeit des Vorhersagemodells zu überprüfen.
Da der Großteil der fachspezifischen Literatur in Englisch verfasst ist, erscheint es sinnvoll (und wahrscheinlich sogar einfacher), dass die Diplomarbeit ebenfalls in englischer Sprache verfasst wird.
Diese Diplomarbeit soll die Möglichkeit bieten umfassende Erfahrungen mit Projektverwaltungstools (Bugzille, CVS, u.ä.) zu sammeln. Weiters besteht die Chance Einblicke in die Entstehung und Aufbau von open-source Projekten zu gewinnen und in weiterer Folge Kenntnisse über die Optimierung von Programmen zu gewinnen.
Voraussetzungen (Grundkenntnisse):
  • Java
  • Bugzilla, CVS, etc.
Wünschenswerte Kenntnisse:
  • XML
  • Neuronale Netze
  • Eclipse
Betreuer:
Harald Gall
Kontakt:
Jacek Ratzinger

Praktikum/Diplomarbeit: Refactoring Detector

Status:
Beginn sobald als möglich. Abschluss SS 2006.
Ziele:
Entwickeln von Heuristiken, um mit Hilfe von Daten aus Softwareverwaltungssytemen (z.B. CVS) die Notwendigkeit für Refactoring zu bewerten.
Beschreibung:
Refactoring ist "state of the art" in der Software-Entwicklung, um das Design von existierenden source code zu verbessern und eine leichtere Weiterentwicklung der Software zu ermöglichen. Allerdings ist nicht eindeutig bestimmbar, an welcher Stelle im Programm Refactoring angewendet werden soll.
In einer früheren Arbeit an diesem Institut wurde allgemein das Design von verschiedenen Software-Systemen mit Hilfe einer sogenannten Software Evolution Anaysis bewertet. Dabei werden aus der Geschichte der Software-Entwicklung die Zusammenhänge zwischen Klassen extrahiert. Die Informationen für diese Art der Analyse werden aus Versionsverwaltungs-tools extrahiert (z.B. CVS, Subversion, Visual SourceSave, ClearCase, etc.), mit welchen Schwachstellen im Design erkannt werden können.
Nun soll in dieser Arbeit die Daten der Software Evolution Analysis genutzt werden, um festlegen zu können, an welcher Stelle Refactoring angewendet werden soll. Verschiedene open-source Projekte (z.B. ArgoUML) sollen verwendet werden, um die Zusammenhänge zwischen Software Evolution Daten und Refactoring zu bewerten. Da der Großteil der fachspezifischen Literatur in Englisch verfasst ist, erscheint es sinnvoll (und wahrscheinlich sogar einfacher), dass die Diplomarbeit ebenfalls in englischer Sprache verfasst wird.
Voraussetzungen (Grundkenntnisse):
Wünschenswerte Kenntnisse:
Betreuer:
Harald Gall
Kontakt:
Jacek Ratzinger


Praktikum/Diplomarbeit: Java3D Visualization and Navigation (Eclipse-Plugin)

Status:
Beginn sobald als möglich.
Ziele:
Entwicklung eines Plugins für die 2D/3D Navigation in attributierten Graphen.
Beschreibung:
Daten aus der Architektur- und Evolutions-Analyse liegen in Form von attributierten Graphen (d.h. Klassen, Komponenten, Modulen und ihre Beziehungen sowie zusätzlichen Information) vor. Für mögliche Anwender soll eine ansprechende interaktive, grafische Darstellung der Information implementiert werden. Als Datenformat innerhalb der Applikation wird XML verwendet. Folgende funktionelle Anforderungen soll die Implementierung erfüllen:
  • Darstellung von Graphen wahlweise in 2D oder 3D Darstellung.
  • Navigation: Scrollen, Rotieren, Perspektivische Ansichten.
  • Darstellung von Knoten (Klassen, Komponenten, Verzeichnisse, etc) als 2D/3D Objekte wobei unterschiedliche Formen (Würfel, Kugel, Kegel, etc.) für unterschiedliche Klassen von Knoten verwendet werden können.
  • Selektion von Kanten, Knoten.
  • Anzeige von zusätzlichen Attributen zu selektierten Kanten oder Knoten.
  • Interaktion zwischen Visualisierung und Sourcecode Browser: d.h. bei Auswahl von Knoten bzw. Kanten in der 2D/3D Ansicht, sollen die entsprechende Dateien im Browser-Fenster angezeigt werden.
Voraussetzungen (Grundkenntnisse):
  • Java
  • Eclipse
  • XML
Betreuer:
Mehdi Jazayeri, Harald Gall
Kontakt:
Michael Fischer

Praktikum/Diplomarbeit: Component Model Recovery and Component Interaction of Mozilla

Status:
Beginn sobald als möglich.
Ziele:
Ermittlung des Ist-Zustandes der Implementierung und Aufzeichnung von Interaktionsmustern von Mozilla Komponenten (XPCOM).
Beschreibung:
Für die Implementierung von Mozilla wurde ein ausgefeiltes Komponenten Modell verwendet. Für weiterführende Architektur- und Evolutions-Analysen ist die Gewinnung von aktuellen Daten über die verwendeten Komponenten und deren Interaktion vorteilhaft. Die gewonnen Daten tragen zum besseren Verständnis der logischen Zusammenhänge der untersuchten Software bei. Teilziele bei der Realisierung dieser Fallstudie:
  • Ermittlung des Komponenten-Modells über ausgewählte Versionen von Mozilla.
  • Instrumentierung des Source-Codes zur Ermittlung von Interaktionsmustern.
  • Ermittlung von Interaktionsmustern zwischen Komponenten für typische Anwendungsfälle (Seite aus dem Web laden, Mail versenden, etc.).
  • Dokumentation typischer Interaktionsmuster (Initalisierung, Netzwerkkommunikation, Seitenaufbau).
  • Vergleich der Interaktionsmuster verschiedener Versionen des Systems
  • Interaktion zwischen Applikation und Betriebssystem
Ergebnisse aus diesem Analyseschritt fließen in ein allgemeines, grafisches Modell zur Beschreibung des SW-Systems ein.
Voraussetzungen (Grundkenntnisse):
  • C/C++
  • Mozilla
Links:
XPCOM
Betreuer:
Mehdi Jazayeri, Harald Gall
Kontakt:
Michael Fischer

Praktikum/Diplomarbeit: Evolution of BSD (FreeBSD, NetBSD, OpenBSD)

Status:
Beginn sobald als möglich.
Ziele:
Fallstudie über die Entwicklung der drei ``Produktlinien´´ FreeBSD, NetBSD, OpenBSD und deren Abhängigkeiten.
Beschreibung:
Der Sourcecode des Kerns inklusive sämtlicher externer Programme (ls, passwd, etc.) steht in Form eines Source Code Repositories (CVS) über einen Zeitraum von 10 Jahren zur Verfügung. Diese geschichtlichen Daten sind zu extrahieren und in ein bestehendes Datenbankschema über zu leiten, welches als Basis für alle weiteren Analysen dient. Alle Anfragen an die Datenbank sind in Java zu implementieren (eventuell als Eclipse-Plugin). Ziel der Analysen ist das Auffinden von Differenzen, Gemeinsamkeiten und Abhängigkeiten zwischen den einzelnen Produktlinien, häufig geänderten Code-Sequenzen, Code-Fluss zwischen den Produktlinien.
Voraussetzungen (Grundkenntnisse):
  • C/C++
  • CVS
  • Java
  • SQL
Links:
http://www.bsd.org/
Betreuer:
Mehdi Jazayeri, Harald Gall
Kontakt:
Michael Fischer

Diplomarbeit: Tracking Source Code Propagation in Software Systems via Release History Data and Code Clone Detection

Status:
vergeben
Ziele:
Auffinden von dupliziertem Sourcecode (``Cut'n Paste´´).
Beschreibung:
Sourcecode wird oftmals nicht neu entwickelt, sondern bestehende Programme oder Programmteile einfach kopiert und gegebenenfalls adaptiert. Gründe dafür gibt es viele, häufig ist es aber Zeitdruck und das Wissen, dass der bestehende Code funktioniert, der Programmierer dazu veranlasst, Sourcecode einfach zu duplizieren.
Im Regelfall resultiert ein Duplizieren von Code in einer Verminderung der Qualität eines Softwareprojektes. Redundanter Sourcecode führt zu einem unnötigen Anwachsen von LOC (Lines Of Code), was sich negativ auf die Überschaubarkeit und somit auf die Wartbarkeit von Sourcecode auswirkt. Werden außerdem Fehler in solchem Code gefunden und repariert, so fehlt meist das Wissen, dass dieser Code auch in anderen Programmteilen vorhanden ist, der Fehler wird also nicht überall ausgebessert.
Bestehende Ansätze der Auffindung von dupliziertem Sourcecode in (großen) Softwareprojekten zielen darauf ab, ebensolche Codefragmente zu finden, um sie dann einem Refactoring-Schritt zu unterziehen, um somit die Qualität des Sourcecodes zu verbessern.
In dieser Diplomarbeit sollen durch Sourcecode Analyse (Suche von vordefinierten Mustern in Sourcecode) duplizierte Codefragmente ermittelt werden. Anhand einer Fallstudie sollen Machbarkeit und Probleme des Ansatzes gezeigt werden.
Zusätzlich sollen mit Hilfe von Evolutionsdaten mögliche Übereinstimmungen zwischen Häufigkeit von Änderungen im Sourcecode und Code-Clones ausfindig gemacht werden. Des Weiteren soll das Verfahren auf mehrere Versionen unterschiedlicher Systeme (z.B. Mozilla, BSD, Eclipse) angewendet und die gefundenen Code-Clones in den jeweiligen Modulen mit den Änderungsabhängigkeiten der betroffenen Module verglichen werden. Idealerweise soll durch eine Visualisierung ein besserer Einblick in die Entwicklung der betrachteten Systeme ermöglicht werden. Dazu sollen Daten wie die Häufigkeit von dupliziertem Code über unterschiedliche Module, Tendenzen zur Zu- bzw. Abnahme von dupliziertem Code innerhalb von Modulen über die Projektdauer, Änderungswahrscheinlichkeit von dupliziertem Code, etc. aufbereitet und veranschaulicht werden.
Voraussetzungen (Grundkenntnisse):
  • Java
  • C/C++
Betreuer:
Mehdi Jazayeri, Harald Gall
Kontakt:
Michael Fischer

Praktikum: Evaluation of Source Code Repositories and Defect Tracking Systems

Status:
Beginn sobald als möglich.
Ziele:
Betrachtung unterschiedlicher freier und kommerzieller Systeme zur Verwaltung von Sourcecode und Fehlerdaten.
Beschreibung:
Die Ausgangspunkte für retrospektive Analysen von Softwaresystemen bilden unter anderem Daten aus Sourcecode Repositories (CVS, BitKeeper, SourceSafe, Rational ClearCase, etc.) und Datenbanken zur Verwaltung von Fehlerdaten (Bugzilla, GNATS, Fast BugTrack, ProbelmTracker, etc.).
Aufgabe ist es, die bestehenden Systeme anhand mehrerer Kriterien hinsichtlich Qualität der zur Verfügung gestellten Daten zu vergleichen (z.B. Integration von Defect Tracking und Sourcecode Version Management) und Möglichkeiten für den Export von Daten aus diesen Systemen zu beschreiben. Als Fallstudie sind Mithilfe entsprechender Adaptoren historischen Daten aus unterschiedlichen Projekten in eine zentrale Datenbank (Release History Database) überzuleiten.
Betreuer:
Mehdi Jazayeri, Harald Gall
Kontakt:
Michael Fischer

Praktikum: UML Generator

Status:
Beginn sobald als möglich.
Ziele:
Erzeugung von UML konformen Datensätzen aus Architekturbeschreibungen großer SW-Systeme.
Beschreibung:
Derzeit liegen Architekturdaten in Form von ASCII Dateien vor, die auf Tupel-Ebene ein einfaches Modell der Beziehungen zwischen einzelnen Elementen (Funktionen, Klassen, Module, etc.) eines SW-Systems beschreiben. Ziel ist es, diese Daten in ein standardisiertes Format als UML Daten zum Austausch mit anderen Anwendungen über zuleiten. Als Meta-Beschreibungssprache wird XMI verwendet. Da UML nicht alle möglichen Zusatzinformation über ein SW-System unterstützt, muss beim Export auf entsprechende Hilfskonstruktionen zurückgegriffen werden. Solche Zusatzinformation könnten logische Abhängigkeiten durch duplizierten Code (Cut'n Paste), Informationen über Abhängigkeiten zwischen Software-Features, Häufigkeit von Änderungen im Sourcecode, etc. sein. Mögliche Anwendungsbereiche der exportierten Daten sind Visualisierung z.B. ArgoUML oder automatisches Vergleichen von in UML vorliegenden Spezifikationsdaten mit der tatsächlichen Implementierung. Die Implementierung soll als Plugin für Eclipse erfolgen.
Voraussetzungen (Grundkenntnisse):
  • Java
  • XML
  • UML
Links:
ArgoUML, XMI
Betreuer:
Mehdi Jazayeri, Harald Gall
Kontakt:
Michael Fischer

Diplomarbeit: Entwurf und Implementierung eines Datenmodells für Software Architektur Daten

Status:
vergeben
Ziele:
Ziel der Diplomarbeit ist der Entwurf und die Implementierung eines flexiblen Datenmodells für die Integration der vorliegenden Datenbestände.

Beschreibung:
Für die Analyse von Software Systemen bilden große Datenbestände über deren Implementierung und Evolution die Grundlage. Diese Datenbestände liegen sowohl in Form einer relationalen Datenbank (RDB) als auch als ASCII Datei vor. Folgende Schwerpunkte müssen abgedeckt werden: - Spezifikation des Datenmodells in XML - Generierung der Datenbank anhand der Spezifikation - Spezifikation von Import/Export Filter in XML - Generierung der Import/Export Filter anhand der Spezifikationen - Import bestehender Datenbestände

Im Zuge der Diplomarbeit ist auch ein Vergleich bestehender Datenmodell sowie existierender Techniken und Lösungen zu dieser Problematik zu diskutieren. Für die Implementierung des Datenmodells ist Java und XML vorgesehen.

Voraussetzungen:
  • Datenbanken
  • Java
  • XML

Kontakt:
Martin Pinzger , Michael Fischer

Methodology for Management Decision Support

Status:
Start date: as soon as possible
Goals:
The idea for this master's thesis is based on the so called "Pareto Analysis". Vilfredo Pareto established the 80/20 principle. There are several interpretations for this principle. One of them states that 80 percent of the work can be done within 20 percent of the overall effort. The remaining 20 percent of the workload account for 80 percent of the effort.
For companies it is important to know: Which parts of their products cause most bugs? Where does the company invest most of its effort? Based on Pareto's Law a company could decide where to invest their effort to solve 80 percent the customer requests.
The master's thesis should help to automate the Pareto Analysis. This analysis should be based on information extracted from an issue tracking system.

Description:
Issue tracking systems (e.g. Bugzilla, Jira, ...) are used in companies to organize their "to-do lists" for tracking and managing the issues and bugs that emerge during a project. Such issue and defect tracking in a project is a critically important task, but one that few teams do effectively.
An issue-tracking system basically is a database for problem reports, which may be software bugs, customer feedback , trouble tickets, or any other collections of incidents and requests from the customer. The importance of such a system is its collaborative nature and its tracking and change-management capability.
Within this master's thesis data collected by issue and defect tracking systems has to be evaluated. The customer issues have to be scanned for important categories (e.g. configuration, GUI, interaction, client-server, sql, ...). These categories help a company to decide where to invest their effort. For example a company could discover with the help of this master's thesis, that their software system is difficult be configured. With the help of such information the company could try to improve their work habits. For the analysis of the issue tracking system the student of this master's thesis could use techniques known from Data Warehouses. However, Data Warehouses are just an optional task.
(You are free to contribute your own ideas to this work :-)

Tools to use:
Java or C#, Database (e.g. MySQL), Issue Tracking Systems (e.g. Bugzilla, Jira)

Please contact:
Harald Gall Harald Gall , Jacek Ratzinger
This page was created by Martin Pinzger, 2000.

Powered by HTMLpp

Last modified: 22-June-2005 13:18:27