Technische Universität Ilmenau
Fakultät für Informatik und Automatisierung
Institut für Praktische Informatik und Medieninformatik
Fachgebiet Softwaretechnik und Programmiersprachen

Diplomarbeit

Automatisierte Softwaregenerierung aus
UML-Modellierungsinformationen

Autor: Tobias Lindig

Datum: Ilmenau, den 26. Juni 2000

Thesen

1. Die Wiederverwendung ist ein wirksames Mittel zur Verbesserung der Qualität, zur Verkürzung der Entwicklungszeit und zur Senkung des Wartungsaufwandes bei der Entwicklung von Software.
2. Entwurfs- und Architekturmuster ermöglichen eine Wiederverwendung auf der Entwurfsebene und eine effizientere Kommunikation
   zwischen den Softwareentwicklern. 
3. Der komplette Entwurf von Software wird zukünftig mittels abstrakter Beschreibungssprachen erfolgen. Damit wird ein plattform- und zielsprachenunabhängiges Design ermöglicht.
4. Zentrale Werkzeuge beim Softwareentwurf werden die CASE-Tools sein. Basierend auf einem Repository können sie verschiedene Schritte in der Softwareentwicklung unterstützen und unterschiedliche Sichten konsistent darstellen. Das Ergebnis ist eine abstrakte Beschreibung.
5. Programmcode und Anwendungen können auf Grundlage der abstrakten Modellbeschreibung mit Hilfe von Generatoren automatisch erstellt werden.
6. Bei der Entwicklung von Anwendungen wird man sich auf die Modellierung der fachlichen Aspekte beschränken können. Für die technischen Aspekte werden vorgefertigte Lösungen eingesetzt. Die Anbindung der Fachlogik an die technische Architektur erfolgt durch Generatoren.
7. Aus Punkt 6 folgt, dass Entwickler von technischen Lösungen entsprechende Generatoren bereitstellen müssen. Eine
   flexible Architektur für solche Generatoren ist das im Rahmen dieser Arbeit entwickelte Frameworkdesign FlexiGen.
8. Durch die Verwendung von FlexiGen erreicht man Wiederverwendung auf Entwurfsebene. Die Architektur selbst ist eine Kombination verschiedener Entwurfsmuster.
9. FlexiGen entkoppelt Generator und CASE-Tool in dem es Generatormodule und Adaptermodule definiert. Dadurch wird eine spätere
   Erweiterung um neue Generatoren bzw. Anpassung für weitere CASE-Tools mit nur minimalem Aufwand ermöglicht.

Inhaltsverzeichnis

Thesen iii

1. Einleitung ... 1
1.1. Motivation ... 1
1.2. Aufgabenstellung ... 2
1.3. Aufbau dieser Arbeit ... 2

2. Grundlagen ... 5
2.1. Voraussetzung zum Verständnis ... 5
2.2. Softwarequalität ... 6
2.3. Quantität ... 8
2.4. Wiederverwendung ... 9
2.5. Abstrakte grafische Beschreibungssprache ... 12
2.6. CASE-Tool ... 12
2.7. Softwaregeneratoren ... 14
2.8. Frameworks ... 18
2.9. Domain Engineering ... 19
2.10. Praxisbeispiel ... 22

3. Forschungsschwerpunkte ... 25
3.1. Object-Oriented Programming (OOP) ... 26
3.2. Subject-Oriented Programming (SOP) ... 26
3.3. Aspect-Oriented Programming (AOP) ... 28
3.4. Adaptive Programming (AP)/Demeter ... 30
3.5. Transformationssysteme ... 31
3.6. Parametrisierte Typen ... 32
3.7. GenVoca ... 32
3.8. Generative Programming ... 33
3.9. Intentional Programming (IP) ... 33
3.10. Generative Softwarekonstruktion ... 33
3.11. Softwaregenerator ... 34
3.12. Zusammenfassung ... 36

4. Umsetzung von UML in Code ... 37
4.1. Klassen, Attribute und Methoden ... 38
4.2. Vererbung und Schnittstellenimplementierung ... 42
4.3. Assoziation ... 44
4.3.1. Unidirektional ... 44
4.3.2. Bidirektional ... 49
4.4. Zusammenfassung ... 52

5. Architektur FlexiGen ... 53
5.1. Zweck ... 53
5.2. Typ ... 53
5.3. Motivation ... 53
5.4. Probleme ... 55
5.5. Lösungen ... 56
5.5.1. Lösung für inkompatible Quellen ... 56
5.5.2. Lösung für verschiedene Ausgaben ... 58
5.5.3. Lösung für Dynamik ... 59
5.5.4. Erweiterte Lösung für Dynamik ... 61
5.5.5. Lösung für Codegenerierung ... 61
5.6. Struktur ... 65
5.7. Teilnehmer ... 65
5.8. Interaktionen ... 69
5.9. Ablauf ... 70
5.10. Konsequenzen ... 70
5.11. Implementierung ... 71
5.11.1. Statischer Singleton ... 71
5.11.2. Manager ... 72
5.11.3. Adapter ... 74
5.11.4. Generator ... 75
5.12. Bekannte Verwendungen ... 78

6. Zusammenfassung ... 79
6.1. Spekulation über die zukünftige Entwicklung ... 80

A. Namenskonventionen ... 83
B. Glossar ... 85

Literaturverzeichnis ... 95

Abbildungsverzeichnis
2.1. Rolle der Softwaregeneratoren ... 15
2.2. Für Generierung geeignete Anwendungsarchitektur ... 17
2.3. Beispiel Domain Engineering ... 21
4.1. Klassendiagramm: einfache Klasse ... 38
4.2. Klassendiagramm: Vererbung ... 43
4.3. Klassendiagramm: Assoziation ... 44
4.4. Klassendiagramm: Komposition ... 46
4.5. Klassendiagramm: bidirektionale Aggregation ... 50
5.1. Kombination verschiedener Module über eine gemeinsame Schnittstelle ... 54
5.2. Komponentendiagramm ... 55
5.3. Muster Adapter ... 58
5.4. Muster Brücke ... 59
5.5. Muster Singleton ... 60
5.6. Muster Abstrakte Fabrik ... 62
5.7. Muster Fabrikmethode ... 63
5.8. Muster Schablonenmethode ... 64
5.9. Struktur ... 66
5.10. Objektbaum eines einfachen C++-Headers ... 77

1. Einleitung
1.1. Motivation
Softwareprojekte werden immer größer und komplexer. Die Anforderungen an Qualität und Quantität nehmen ständig zu. Um im Wettbewerb bestehen zu können, wird intensiv nach Mitteln und Wegen gesucht, diesen Anforderungen gerecht zu werden. Ein großes Potenzial liegt in der Verbesserung des Entwurfsprozesses, der Wiederverwendung von Software und der Automatisierung der Applikationserstellung.

Bei der Entwicklung von neuer Software wird zunehmend versucht, solange wie möglich unabhängig von der späteren Implementierung zu bleiben. Dazu bedient man sich abstrakter Beschreibungsformen wie z.B. der UML1. Auf Grundlage dieser abstrakten Modelle ist es möglich, Teile des Programmcodes automatisch zu erzeugen. Diese Entwicklung steht aber erst an ihrem Anfang.

In dieser Diplomarbeit wird auf die Vor- und Nachteile der Softwaregenerierung eingegangen und ein Überblick über den aktuellen Stand der Entwicklung gegeben. Weiterhin wird eine Architektur für einen exiblen Softwaregenerator vorgestellt. Auf Basis dieser Architektur kann z.B. ein Codegenerator erstellt werden, der auf Grundlage eines UML-Modells, welches mit einem CASE-Tool modelliert wurde, Programmcode erzeugt. Bei der Architektur wurde besonderer Wert auf Flexibilität und Erweiterbarkeit des Generators gelegt. So können z.B. verschiedene CASETools unterstützt und verschiedene Arten von Code generiert werden.

1.2. Aufgabenstellung
Die Aufgabe besteht in der Entwicklung eines Musters für einen modular
aufgebauten Softwaregenerator mit dem Ziel der automatisierten Erzeugung
von Applikationen auf Grundlage der mit UML-basierten CASETools
modellierten Informationen.

• Untersuchung vorhandener Ansätze und Lösungen zur generativen Programmierung
• Betrachtungen zur Realisierbarkeit automatischer Applikationsgenerierung, resultierende Einschränkungen und Abgrenzungen
• Architekturvorschlag; Verwendung von Architektur- bzw. Entwurfsmustern
• Prototypische Beispielimplementation eines Generators mit Anbindung an führende kommerzielle CASE-Tools, wie Rational Rose, SELECT Enterprise und OTW. (Speziell zur Erzeugung aller von einer modellierten Applikation benötigten Codeteile für Datenbankzugriffe über das Produkt GRIT Connect der Firma GFT Systems GmbH)

1.3. Aufbau dieser Arbeit
Im Kapitel 2, Grundlagen, wird auf die Notwendigkeit der Wiederverwendung von Software eingegangen, und es werden einige Begriffe und
Techniken erklärt. Das Kapitel schließt mit einem Praxisbeispiel, bei welchem CASE-Tools, Frameworks und Codegeneratoren erfolgreich eingesetzt wurden.

Kapitel 3, Forschungsschwerpunkte, stellt eine Reihe von Forschungsprojekten und Produkten aus dem Umfeld der generativen und komponentenbasierten Softwareentwicklung vor.

Kapitel 4, Umsetzung von UML in Code, erläutert, wie die Umsetzung der Elemente eines UML-Klassendiagramms in C++-Programmcode erfolgen kann.

Das vom Autor dieser Diplomarbeit entwickelte Design eines Frameworks zur Softwaregenerierung wird im Kapitel 5, Architektur FlexiGen, vorgestellt. In den Abschnitten 5.1 und 5.2, Zweck bzw. Typ, wird knapp beschrieben, welche Möglichkeiten die Architektur bietet und um welche Art von Architektur es sich handelt. Abschnitt 5.3, Motivation, beschreibt ein Anwendungsproblem, für das auf Basis des Musters eine Lösung erstellt wurde. Im Abschnitt 5.4, Probleme, werden die Probleme, bei denen das Muster angewandt werden kann, explizit aufgeführt und in 5.5, Lösungen, werden die im Muster verwendeten Problemlösungen und Variationsmöglichkeiten im Detail erläutert. Abschnitt 5.6, Struktur, enthält ein UML-Klassendiagramm, in welchem die Klassen des Musters mit ihren Beziehungen dargestellt sind. Abschnitt 5.7, Teilnehmer, beschreibt die Zuständigkeiten der am Muster beteiligten Klassen bzw. ihrer Objekte. Die Zusammenarbeit der Objekte wird im Abschnitt 5.8, Interaktionen, beschrieben und die Reihenfolge der Aktionen bei der Nutzung der Objekte im Abschnitt 5.9, Ablauf. Der Abschnitt 5.10, Konsequenzen, diskutiert einige Vor- und Nachteile, die sich bei der Anwendung des Musters ergeben, und zeigt einige Variationsmöglichkeiten auf. Schließlich werden im Abschnitt 5.11, Implementierung, konkrete Hinweise für eine Implementierung der Architektur gegeben und mit Beispielen in C++ veranschaulicht.

Im Kapitel 6, Zusammenfassung, sind eine Bewertung der vorliegenden Arbeit und eine Spekulation über die zukünftige Entwicklung der Softwareindustrie zu finden.

2. Grundlagen
Dieses Kapitel geht auf einige Probleme der Softwareentwicklung und Wartung ein. Dazu wird beschrieben, was unter Softwarequalität zu verstehen ist, und wie sie verbessert werden kann. Besonderes Augenmerk gilt dabei der Wiederverwendung von Software und einigen Techniken, die diese im besonderen Maße unterstützen. Das Kapitel schließt mit einem Beispiel aus der Praxis, bei welchem ein wesentlicher Grund für den Erfolg des Projektes der Einsatz von Frameworks und Codegeneratoren war.

[...]

1 UML = Unified Modeling Language