GULP >> GULP Knowledge Base >> Produkte & Technologien >> Generative Softwareentwicklung


Generative Softwareentwicklung mit der Model Driven Architecture (MDA)

Rechtzeitig mit einer neuen Technologie vertraut machen

(Mai 2004)
Inhalt dieses Artikels:
Softwareentwicklung - Stand der Praxis | Generative Softwareentwicklung | Der MDA-Ansatz der OMG | Werkzeugunterstützung | Bewertung und Fazit | Neue Tätigkeitsfelder
Ihre Meinung zum Artikel
 
sehr gut
1
2
3
4
5
6
schlecht
 

Der MDA-Ansatz der OMG (Object Management Group) ist in aller Munde und wird als Allheilmittel für die Lösung vieler Probleme in der Softwareentwicklung angepriesen. Oliver Höß, Leiter der Business Unit Software Technology am Fraunhofer-Institut für Arbeitswirtschaft und Organisation (IAO), stellt für GULP die wesentlichen Grundelemente dieser neuen Technologie vor und diskutiert ihre Reife für den praktischen Einsatz.

Betrachtet man die Art und Weise, wie Anwendungen heutzutage entwickelt werden, wird man feststellen, dass in den meisten Fällen die Software manuell programmiert wird, d.h. ein oder mehrere Entwickler schreiben Programmcode in Programmiersprachen, wie z.B. Java, C++ oder C#, der die geforderten Funktionalitäten der Software realisiert.

 

Softwareentwicklung - Stand der Praxis nach oben
   

Da dies eine sehr niedrige Abstraktionsebene der Softwareentwicklung ist, kann die große Komplexität von modernen Systemen mit dieser Vorgehensweise der Programmierung nur relativ schwierig bewältigt werden, vor allem im geforderten Zeit- und Kostenrahmen sowie mit der geforderten Qualität.

Die seit 1994 vor allem im englischsprachigen Raum kontinuierlich durchgeführte CHAOS-Studie der Standish
Group
extern für das Jahr 2003 ergab, dass 51 Prozent der Entwicklungsprojekte das Zeit- oder Kostenbudget überzogen haben bzw. nicht alle funktionalen Anforderungen erfüllen. Rund 15 Prozent der Projekte werden vorzeitig abgebrochen. Nur 34 Prozent der Projekte werden als Erfolg gewertet.

In vielen Fällen ist die Schuld dem mangelhaften Projektmanagement oder von vorn herein unrealistischen Zeitplänen zuzuschreiben. Es ist jedoch auch die Meinung vieler Experten, dass die manuelle Programmierung, wie sie schon seit Jahrzehnten praktiziert wird, nicht mehr dazu geeignet ist, komplexe Systeme zu beherrschen.

Diese prinzipielle Problematik wurde bereits in den 90er Jahren erkannt – und es wurden eine Reihe von objektorientierten Modellierungsmethoden entwickelt, die inzwischen in der Unified Modeling Language
(UML)
externzusammengefasst wurden. Durch die Modellierung mit der UML können komplexe Systeme auf einem abstrakten Niveau graphisch beschrieben werden. Dadurch kann ihre Funktionsweise besser erfasst und somit die Komplexität beherrscht werden.

In den meisten Fällen ist es heutzutage jedoch immer noch so, dass der in die Modellierung investierte Aufwand nur in kleinen Teilen für die Umsetzung in Programmcode verwendet wird. So bieten viele UML-Modellierungs-Werkzeuge derzeit zwar die Möglichkeit, basierend auf Klassendiagrammen eine Klassenstruktur mit den entsprechenden Attributen und Methoden in einer objektorientierten Programmiersprache zu generieren. Die eigentliche Funktionalität wird jedoch meist manuell programmiert, obwohl sie in den Aktivitäts- und Zustandsdiagrammen der UML-Modelle bereits enthalten ist.

In vielen Fällen wird der Programmcode jedoch auch völlig unabhängig von den Modellen entwickelt, also ohne eine Generierung der Klassenstruktur. Dies birgt die Gefahr, dass der Programmcode sich nicht synchron mit der Modellierung entwickelt und somit Inkonsistenzen entstehen.

 

 

Generative Softwareentwicklung nach oben
   

Der Ansatz der generativen Softwareentwicklung hat die Zielstellung, die oben genannten Problemfelder anzugehen, indem der Programmcode automatisch aus abstrakten Modellen generiert wird, d.h. es wird eine Reduktion der manuellen Programmierarbeiten zugunsten einer Generierung des Programmcodes angestrebt. Am Programmcode selbst werden im Idealfall keine Änderungen vorgenommen, stattdessen werden die Änderungen im Modell durchgeführt und es wird eine neue Version des Programmcodes generiert.

Auf diese Art und Weise wird der in die Modellierung des Systems investierte Aufwand direkt für die eigentliche Implementierung genutzt und es wird verhindert, dass Modell und Programmcode auseinanderlaufen.

Die Generierung wird durch Generatoren durchgeführt, die das abstrakte Modell, evtl. in mehreren Schritten, in den Programmcode umsetzen (siehe Abbildung 1). Das Modell muss dazu in einer maschinell verarbeitbaren Form vorliegen, d.h. graphische Darstellungen sind nur bedingt geeignet und müssen vorher in eine strukturierte Repräsentation umgewandelt werden.

 
Generierung durch Generatoren  
Abbildung 1: Vom Modell in den Programmcode
 


Es existieren bereits seit längerer Zeit im wissenschaftlichen Umfeld eine Vielzahl von unterschiedlichen Ansätzen zur generativen Softwareentwicklung, die jedoch meist keine große Anwendung in der Praxis fanden. Eine Ausnahme ist der Bereich der Embedded Software. Dort wird bereits seit mehreren Jahren Steuergerätesoftware aus Modellen in Form von Zustandsdiagrammen generiert.

 

 

Der MDA-Ansatz der OMG nach oben
   

Mit der Definition des Model Driven Architecture Ansatzes (MDA) extern der Object Management Group (OMG) extern besteht die begründete Hoffnung, dass sich der Ansatz der generativen Softwareentwicklung auf einer breiteren Front durchsetzen kann.

Die MDA setzt den Ansatz der generativen Softwareentwicklung unter Verwendung der UML um, d.h. die Funktionalität der Anwendung wird mit UML modelliert und der eigentliche Programmcode wird auf Basis dieser Modelle generiert. Dabei wird insbesondere auch die Generierung von Programmcode für unterschiedliche Zielplattformen berücksichtigt (siehe Abbildung 2).

 
Umsetzung mit der MDA
 
Abbildung 2: Die Generierung für mehrere Zielplattformen
 

Um technologieunabhängige Modelle zu erzeugen, wird in einem ersten Schritt ein plattformunabhängiges Modell (Platform Independent Model, PIM) unter Verwendung der UML erstellt. Durch geeignete Generatoren kann dieses plattformunabhängige UML-Modell in unterschiedliche plattformspezifische UML-Modelle, z.B. für J2EE, .NET oder CORBA, umgewandelt werden (Plattform Specific Model, PSM). Es handelt sich bei dieser Umwandlung um eine "Model-to-Model"-Transformation, bei der allgemeine Modellierungselemente in plattformspezifische Elemente transformiert werden. Wenn das Modellierungswerkzeug und der Generator nicht integriert sind, muss i.d.R. das UML-Modell vor der Transformation in das XMI-Format (XML Metadata Interchange) extern überführt werden, das eine XML-basierte Darstellung der UML-Modellierungselemente ermöglicht. XMI ist ein wesentlicher Bestandteil der UML 2.0 extern. Die aktuelle Version 2.0 der UML wurde auf die Anwendung des MDA-Ansatzes hin optimiert.

In einem zweiten Schritt wird das jeweilige plattformspezifische Modell in den entsprechenden Programmcode für die Zielplattform transformiert. Dabei findet der Übergang von UML-Modellen zu konkretem Programmcode statt, d.h. es handelt sich um eine "Model-to-Code"-Transformation.

Ein Teil der Transformationen kann standardisiert zur Verfügung gestellt werden, der übrige Teil muss individuell entwickelt werden, insbesondere, wenn das UML-Metamodell für eine konkrete Anwendung verändert bzw. erweitert wurde.

 

 

Werkzeugunterstützung nach oben
   

Da der MDA-Ansatz noch relativ neu ist, ist derzeit noch keine zufriedenstellende Werkzeugunterstützung vorhanden. In den Werkzeugen der traditionellen Hersteller von UML-Modellierungsumgebungen sind bisher nur rudimentäre Generierungsfunktionalitäten enthalten und auch der UML 2.0-Standard ist meist noch nicht umgesetzt. Ein Großteil der Werkzeuge unterstützt aber inzwischen den Export der UML-Modelle im XMI-Format, was eine Weiterverwendung der Modellinhalte durch Zusatzwerkzeuge ermöglicht.

Es existieren jedoch eine Reihe von Zusatzwerkzeugen, die zur Umsetzung des MDA-Ansatzes geeignet sind und XMI-Daten verwenden, um daraus ausführbaren Programmcode zu erzeugen. Ein Beispiel hierfür ist das Produkt ArcStyler der Firma Interactive Objects extern. Es existieren auch spezialisierte Werkzeuge von anderen Herstellern, die z.B. ausschließlich dazu verwendet werden können, um aus UML-Zustandsdiagrammen Programmcode zu generieren.

Einen Schritt weiter sind die Werkzeughersteller im Umfeld der Entwicklung von Embedded Systems. Hier setzen bereits erste Werkzeuge, wie z.B. das Produkt TAU der Firma Telelogic extern, den UML 2.0 -Standard um und unterstützen auch die Generierung von Programmcode gemäß dem MDA-Ansatz. Besonders erwähnenswert ist in diesem Zusammenhang auch das Produkt Rhapsody der Firma i-Logix, das bereits in den 90er Jahren die Modellierung und Simulation von Systemen auf Basis von UML-Modellen ermöglichte und auch eine vollständige Generierung des ablauffähigen Programmcodes unterstützt. Rhapsody hat also den MDA-Gedanken bereits umgesetzt, bevor dieser öffentlich formuliert wurde. Es wurde seit dem weiterentwickelt und stellt, vor allem im Embedded Sektor, eine gute Alternative dar.

 

 

Bewertung und Fazit nach oben
   

Die generative Softwareentwicklung im Allgemeinen und die MDA-Vorgehensweise im Besonderen besitzen eine Reihe von Vorteilen:

- Es handelt sich um einen methodisch sehr guten Ansatz, der die Komplexität der Systeme für die Anwendungsentwickler reduziert, was zum einen die Entwicklung und zum anderen die Wartung der Systeme vereinfacht.
- Der in die Erstellung von UML-Modellen investierte Aufwand wird gewinnbringend genutzt.
- Der Aufwand für die eigentliche Codierung fällt weg, da der Programmcode automatisch erzeugt wird.
- Bei fehlerfreien Modellen und qualitativ hochwertigen Generatoren kann die Qualität der entstehenden Systeme bis hin zur Fehlerfreiheit gesteigert werden.
- Durch die Verwendung von unterschiedlichen Generatoren kann eine Variantenbildung unterstützt werden.
- Durch die plattformunabhängige Modellierung wird der technologische Wandel berücksichtigt. Somit kann eine höhere Investitionssicherheit erreicht werden.

Diesen offensichtlichen Vorteilen stehen eine Reihe von Nachteilen gegenüber, die teilweise durch die relative Neuheit der Standards hervorgerufen werden aber teilweise auch prinzipiell für die generative Softwareentwicklung gültig sind:

- Um hinreichend detaillierte Modelle zu erstellen, die für eine Codegenerierung geeignet sind, muss ein relativ hoher Aufwand in die Erstellung der Modelle investiert werden.
- Es muss ein relativ hoher Aufwand für die Erstellung der Generatoren einkalkuliert werden.
- Manche Arten von Systemen, z.B. Benutzungsoberflächen, lassen sich nur mit einem verhältnismäßig hohen Aufwand formal mit UML modellieren.
- Aufgrund der relativ neuen Standards sind diese Standards sowie die dazugehörigen Werkzeuge noch nicht ausgereift.
- Obwohl ein Großteil der Generierungsfunktionalität allgemein angeboten werden könnte, sind bisher kaum standardisierte Generatoren, z.B. auch als Open Source, verfügbar.

Aufgrund der Vorteile wäre es wünschenswert, dass generative Ansätze zukünftig eine stärkere Anwendung finden. Aufgrund der inhärenten Nachteile ist es jedoch fraglich, ob der Einsatz in allen Anwendungsfeldern - zumindest in naher Zukunft - sinnvoll ist.

Ein Beispiel ist eine Individualentwicklung mit neuen fachlichen Inhalten sowie einer neuen technischen Architektur. In diesem Fall kann die Anwendung eines generativen Ansatzes unter Umständen ökonomisch nicht sinnvoll sein, da die Generatoren neu entwickelt sowie umfangreiche Modelle für nur einen Anwendungsfall erstellt werden müssen.

Daher ist es sinnvoll, evtl. nur Teile eines Systems oder einzelne Komponenten, z.B. die zentrale Anwendungslogik, generativ zu entwickeln. Im Bereich der Generierung von technischen Basisfunktionalitäten wird der generative Ansatz bereits heute eingesetzt, z.B. für die Generierung von Datenbankzugriffscode.

 

 

Neue Tätigkeitsfelder nach oben
   

Für Freiberufler ergeben sich mit der stärkeren Verbreitung des MDA-Ansatzes neue Tätigkeitsfelder in den Bereichen der Erstellung der Modelle oder der Entwicklung von Generatoren. Dabei sind vor allem Kenntnisse in den Bereichen UML, XMI und Generierungsmechanismen von großer Bedeutung. Es lohnt sich also, die Entwicklung in diesen Bereichen aufmerksam zu verfolgen und sich rechtzeitig mit diesen Technologien vertraut zu machen, wenngleich der derzeitige Markt sicher noch sehr beschränkt ist.

 

 

Nähere Informationen zum Thema beim Fraunhofer-Institut für Arbeitswirtschaft und Organisation extern.
Der Autor behält sich alle Rechte am Artikel vor. © 2004 Oliver Höß

 

Kommentare zu diesem Artikel:

"Es sieht aus, als würde die beschriebene Art der generativen Programmierung der nächste Modetrend werden. Damit ist es zweifellos gut, daß Gulp einen Artikel dazu bringt, damit man sich als Freiberufler darauf vorbereiten kann. Allerdings erwarte ich nicht, daß dieser Ansatz in nennenswertem Umfang mehr Probleme löst, als er neue schafft - wie bei den meisten anderen "Patentlösungen" der letzten Jahrzehnte. Erst einmal wird hier ein reiner Top-Down-Ansatz propagiert, während man nach meiner Erfahrung immer eine Mischung von Top-Down-Design im Großen und Bottom-Up-Design im Kleinen (auf Programmiersprachen- und API-Ebene) benötigt, um zu brauchbarer (performanter) Software zu kommen. Dann ist UML nur eine formale Sprache, während die Programmiersprache eine andere formale Sprache ist. Wenn man beide in der beschriebenen Weise kombiniert, fügt man nur eine zusätzliche Lage an Komplexität hinzu - und generierter Code ist normalerweise aus mehreren Gründen sehr schlecht zu debuggen. Und wenn man Programmlogik graphisch statt in der Programmiersprache eingeben muß, entsteht nur Mehrarbeit. Bisher sind alle Ansätze zur graphischen Programmierung weitestgehend fehlgeschlagen. Ein sinnvollerer Ansatz wäre, eine ausreichend leistungsfähige, portabele Programmiersprache mit klarer Syntax (Ada o. ä.; C/C++, C# oder Java scheitern an diesem Kriterium) mit graphischen Designwerkzeugen zu koppeln, sodaß man eine vollwertige Programmiersprache für die Dinge hat, die graphisch nicht mehr sinnvoll darstellbar sind. Eine andere Möglichkeit gibt es wohl kaum. (Juni 2004)"

"Hochinteressanter Ansatz, der auch für diejenigen, die nicht in dem Thema drinstecken, verständlich nachvollziehbar erklärt wo0rden ist! Kompliment. (Mai 2004)"

"Wieviele Rationale Rose Modelle habe ich nicht schon an mir vorbeiziehen sehen, zerfallen und vergessen ... Im Ernst, der wievielte Versuch ist das, Softwareentwicklung auf dieser Ebene zu schematisieren ? Wenn ich bei den aufgezaehlten Nachteilen anfange: Es wird von prinzipiellen und neuheitsbedingten Nachteilen gesprochen - dann allerdings bleibt von den Prinzipiellen nicht viel uebrig, sondern Nichtverfuegbarkeit von tools etc. wird in den Vordergrund geschoben. Vielleicht sollte sich der Autor einmal etwas Popperschen Denkens bedienen und versuchen, die *staerksten* Argumente zu finden, um sein Modell zu falsifizieren ... Meine Meinung dazu: Generative Programmierung basierend auf Objektorientierung hat zum Einen prinzipielle Probleme, weil Software schlecht skaliert. Das ist bekannt und soll den ersten Grund dafuer liefern, das Folgendes eben so nicht klappt: "Ein Teil der Transformationen kann standardisiert zur Verfügung gestellt werden, der übrige Teil muss individuell entwickelt werden" Die Auf-TEILUNG ist gerade eines der Probleme bei nichttrivialen Projekten. Die Modularisierung durch Objekte ist naemlich nicht der Weisheit letzter Schluss, sondern oft sind es die Relationen ZWISCHEN den Objekten. Das ist schon eine Paradigmenfrage und keine der mir bekannten heutigen Programmierumgebungen gibt eine befriedigende Antwort darauf. Alles in allem fuehrt dieses u.a.m. zu viel unschaerferen Trennungen, als den Codegeneratoren wuenschenswert sein kann. Auch hier gibt es Ansaetze (aspektorientierte Programmierung), die Loesungen liefern soll, aber ueber nichttriviale Probleme nicht herausgekommen ist. Das GUI-Generierung als Schwierigkeit hervorgehoben wird, ist etwas abstrus. Hier existieren nun gerade einige der wenigen erprobten(!) Werkzeuge, mit denen man Routine delegieren kann. Ich kann mich auch gar nicht mit der Behauptung anfreunden, dass gemeine Softwareentwicklung ein niedriges Abstraktionslevel darstellt, welches durch hoeherwertige Betrachtungen abgeloest werden kann. Wie schon gesagt halte ich Software fuer schlecht skalierbar. Das bedeutet in Konsequenz, dass es keine Schichtung gibt. Der ganze Gedanke ist falsch. Ausserdem ist die Schichtung statisch. Dem dynamischen Aspekt von Projekten ist sie nicht gewachsen. Ich halte immer noch das Prinzip eines wachsenden Prototypes, der staendig getestet wird, fuer eines der aussichtsreichsten Verfahren. Der Anteil fehlerfrei generierten Codes ist immer ein Nebenschauplatz. Zu den Schlussfolgerungen: Selbst wenn bestimmte Anteile der Softwareentwicklung automatisiert werden koennen (was unbestritten moeglich ist), wird dieser Teil ab genau dem Zeitpunkt fuer den Freiberufler uninteressant sein - weil er eben automatisiert wurde. Das Erstellen von Generatoren wird mit Sicherheit nicht von den Freelancern erledigt werden, wenn dies laenger dauert, als das Projekt mit Hand zu coden. Sie werden also als fertige Werkzeuge kommen, wie ein GUI-Designer. Und diese Werkzeuge wird man beherrschen muessen - allerdings wird das m.E. nicht der Punkt sein, an dem der Freiberufler Vorteile erwerben kann. (Mai 2004)"


Seite drucken Seiten drucken
Zum Seitenanfang nach oben

Für die Teilnahme an den mit diesem Icon gekennzeichneten Diensten melden Sie sich mit den Zugangsdaten an.
Zugangsdaten vergessen? | Noch kein GULP Profil?
Über GULP: Mehr als 3.000 Kunden, 75.000 eingetragene IT-Experten, davon 10.500 mit Schwerpunkt Engineering, und über 1.000.000 abgewickelte Projektanfragen: GULP ist die wichtigste Quelle für die Besetzung von IT-/Engineering-Projekten mit externen Spezialisten im deutschsprachigen Raum. Zusätzlich zu den Dienstleistungen einer modernen Personalagentur bietet GULP ein umfassendes Online-Portal mit Informationen und Services für die Teilnehmer im Markt.