Zurück zur Übersicht

UMLi

Philip Wassenberg

UMLi (Unified Modeling Language for Interactive Applications) ist eine Erweiterung von UML, die es erlaubt, Elemente von graphischen Nutzerschnittstellen (Graphical User Interface, GUI) in UML-Diagramme zu integrieren. Dabei werden in UMLi nicht die Objekte der GUI selbst, sondern ihre Funktion dargestellt.

Außerdem kann man mit UMLi Abläufe der Interaktion eines Nutzers mit dem Programm (d.h. der GUI) darstellen.

UMLi wird von Norman W. Paton von der University of Manchester und von Paulo Pinheiro da Silva von der Stanford University entwickelt.

UML

UML (Universal Modeling Language) ist eine Beschreibungssprache, mit der man in der objektorientierten Softwareentwicklung die Beziehungen zwischen Objekten und Abläufe in Programmen grafisch in Diagrammen darstellen kann.

Grenzen von UML bezüglich der Darstellung von GUIs

In UML werden in erster Linie Beziehungen zwischen Objekten dargestellt. Es ist zwar auch möglich, GUIs (die ebenfalls aus Objekten bestehen) in UML darzustellen, aber solche Darstellungen werden schnell sehr unübersichtlich.

Ein Beispiel in der Programmiersprache Java soll dies verdeutlichen:

Ein einfaches Fenster mit einem Button besteht typischerweise aus einem Objekt der Klasse JFrame. Dieses Objekt besitzt ein weiteres Objekt der Klasse JPanel. Das JPanel besitzt ein Objekt der Klasse JButton, welches wiederum ein Objekt der Klasse ActionListener besitzen muss.

Schon bei einer sehr einfachen GUI benötigt man also zahlreiche Objekte, die man, will man die GUI in UML modellieren, alle darstellen und in Beziehung setzen muss.

Der Ansatz von UMLi

Der Ansatz von UMLi besteht darin, Modelle für die Interaktion zwischen Programm und Nutzer mit UML zu verbinden.

Dabei wird nicht mehr detailliert beschrieben, wie eine GUI programmiertechnisch aufgebaut ist, sondern nur noch, welche Möglichkeiten der Ein- und Ausgabe sie bietet, und welche Abläufe der Interaktion von Nutzer und Programm bei der Nutzung eines Programms vorkommen können.

Das obige Beispiel etwa würde dargestellt als Fenster mit einer Möglichkeit, dem Programm einen Input (in diesem Fall ein Ereignis (event)) zu geben. Wie dieses Fenster aufgebaut ist und wie es den Input realisiert wird dabei nicht festgelegt. Ebensowenig werden Aussagen darüber gemacht, wie die GUI letztlich aussehen soll. Wenn man so will, wird nur die Semantik der GUI durck UMLi beschrieben.

Darstellungselemente von UMLi

UMLi stellt mehrere Grundelemente, so genannte Konstruktoren, zur Verfügung. Dies sind graphische Elemente, aus denen sich UMLi-Diagramme aufbauen lassen. Diese Grundelemente teilen sich in zwei Aufgabenbereiche auf, nämlich die Modellierung der Ein- und Ausgabe einer GUI und der Modellierung der Interaktion von Nutzer und Programm. Hierbei können die Elemente aus diesen beiden Aufgabenbereichen natürlich gemeinsam in Diagrammen genutzt werden; schließlich interagiert ein Nutzer eigentlich mit den Ein- und Ausgabeelementen der GUI.

Die Konstruktoren für die Ein- und Ausgabe sind im Einzelnen:

Ein "FreeContainer". Dieser stellt ein "Fenster" dar, das die weiteren Elemente beinhaltet.

"Displayer" repräsentieren Elemente, die Output darstellen.

"Inputter" stellen Möglichkeiten für den Nutzer, dem Programm Input zu geben, dar.

"Editors" kombinieren Displayer und Inputter, d.h. sie stellen Elemente dar, die sowohl Ausgaben darstellen als auch Eingaben annehmen können.

"ActionInvoker" empfangen Eingaben des Nutzers in Form von Ereignissen.

Außerdem gibt es "Container", die Displayer, Inputter, Editors, ActionInvokers und weitere Container enthalten können.

Die Konstruktoren, die zur Darstellung der Interaktion eines Nutzers mit der GUI dienen, tragen leider keine so griffigen Namen wie die ebengenannten. Im wesentlichen werden die üblichen UML-Symbole durch Symbole ergänzt, die Anfang und Ende der Interaktion darstellen, und durch Symbole, die anzeigen, wie sich der Nutzer an bestimmten Stellen des Ablaufs verhalten muss. "Verhalten" bedeutet hier genauer, was für Optionen er auswählen bzw. Aktionen er durchführen kann bzw. muss. Man unterschiedet hier zwischen Fällen, in denen jede mögliche Option (oder Aktion) wenigstens einmal gewählt worden sein muss, um im Ablauf fortzufahren ("order independent behavior"), Fälle, in denen beliebig oft (auch kein mal) Optionen (oder Aktionen) gewählt werden können ("optional behavior"), und Fälle, in denen eine bestimmte Aktion beliebig oft wiederholt werden kann ("repeatable behavior"). Bei "optional behavior" sollte der Nutzer dem Programm mitteilen, wenn er fertig ist. Bei "repeatable behavior" sollte eine maximale Anzahl an Durchgängen festgelegt sein.

UMLi und UML

Bei der Betrachtung der Konstruktoren von UMLi ist noch zu beachten, dass diese in bei den Konstruktoren von UML nicht (also auch nicht mit anderer Bedeutung) enthalten sind. UMLi ergänzt also UML, beeinträchtigt aber die Semantik vorhandener UML-Elemente nicht.

Weitere Mittel zur Darstellung von Interaktionen

UMLi bietet einige integrierte Beziehungen zwischen Objekten an:

<<interacts>> wird für die Beziehung zwischen "Displayern" bzw. "Inputtern" und den Objekten, die die anzuzeigenden bzw. einzulesenden Werte verarbeiten, verwendet.

<<presents>> stellt die Beziehung zwischen einem Ablauf und einem "FreeContainer" dar in dem Sinn, dass der "FreeContainer" sichtbar ist, während der Ablauf läuft, und die für den Ablauf nötigen Elemente enthält.

<<confirms>> verbindet einen "ActionInvoker" mit einer Auswahl, die der Nutzer trifft. Zum Beispiel kann man bei "optional behavior" (s.o.) einen ActionInvoker mit der Auswahl verbinden, so dass der Nutzer über den ActionInvoker mitteilen kann, dass er fertig ist.

<<cancels>> verknüpft einen ActionInvoker mit einem Ablauf, so dass der Ablauf über den ActionInvoker abgebrochen werden kann und der Ablauf zu einem früheren Zustand zurückkehrt.

<<activate>> stellt eine Beziehung zwischen einem ActionInvoker und einem Ablauf dergestalt dar, dass der ActionInvoker den Ablauf startet.

Software

Derzeit wird UMLi durch Argoi, eine Erweiterung der Software "ArgoUML" realisiert. "ArgoUML" ist eine in Java geschriebene und unter der BSD-Lizenz zur Verfügung stehende Software zum Erstellen von UML-Diagrammen. Diese Software bietet auch Möglichkeiten, aus UML-Diagrammen (Java-)Code zu erzeugen und umgekehrt. Argoi scheint derzeit diese Funktionalität nicht zu haben.

Aktivität des Projekts

Bei Betrachtung der Website des UMLi-Projekts fällt auf, dass die aktuelle Version von Argoi (argoi.jar) den Zeitstempel 2002-09-26 trägt (Stand: 14. November 2005). Dies lässt vermuten, dass die Erstellung von GUIs durch UMLi-Diagramme, wie von den Entwicklern von UMLi als Möglichkeit betrachtet, in nächster Zeit nicht zu erwarten sein wird.

Zusammenfassung

UMLi ist eine Erweiterung von UML, die es ermöglichen bzw. vereinfachen soll, Software mit Graphischer Nutzerschnittstelle zu entwerfen und zu entwickeln. Zu diesem Zweck ergänzt UMLi UML um Konstruktoren, mit denen sich Diagramme zur (semantischen) Darstellung von Fenstern mit Ein- und Ausgabeelementen ebenso wie Abläufe von Interaktionen zwischen Programm und Nutzer erstellen lassen. Dabei werden die Konstruktoren von UML, und damit auch die Semantik dieser Konstruktoren, unverändert gelassen. Durch diesen Ansatz hat UMLi auch das Potential, die Kommunikation zwischen Anwendungsentwicklern und Entwicklern von GUIs zu erleichtern.

Quellen:

http://www.cs.man.ac.uk/img/umli/

http://www.cs.man.ac.uk/img/umli/tutorial/short_tutorial01.html

http://www.cs.man.ac.uk/img/umli/tutorial/short_tutorial02.html

http://www.cs.man.ac.uk/img/umli/tutorial/short_tutorial03.html

http://www.cs.man.ac.uk/img/umli/tutorial/short_tutorial04.html

http://www.cs.man.ac.uk/img/umli/tutorial/short_tutorial05.html

http://www.cs.man.ac.uk/img/umli/tutorial/short_tutorial06.html

http://www.ksl.stanford.edu/people/pp/papers/PinheirodaSilva_UML_2000.pdf

http://de.wikipedia.org/wiki/Unified_Modeling_Language

http://argouml.tigris.org/

http://argouml.tigris.org/features.html

http://freshmeat.net/projects/argouml/