Pflichtenheft von byteme - PI - Praktische Informatik
Pflichtenheft von byteme - PI - Praktische Informatik
Pflichtenheft von byteme - PI - Praktische Informatik
Erfolgreiche ePaper selbst erstellen
Machen Sie aus Ihren PDF Publikationen ein blätterbares Flipbook mit unserer einzigartigen Google optimierten e-Paper Software.
<strong>Pflichtenheft</strong><br />
der Gruppe ByteMe<br />
Sinisa Djukanovic<br />
Sebastian Eifert<br />
Matthias Orgler<br />
Kai Stroh<br />
Carole Urvoy<br />
Mario Vekic<br />
Version 1.0<br />
02.03.2004
Inhaltsverzeichnis<br />
1 Einleitung 9<br />
1.1 Beteiligte Parteien . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9<br />
1.2 Kapitelübersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10<br />
2 Projektübersicht 11<br />
2.1 Ist-Zustand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11<br />
2.2 Soll-Zustand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12<br />
2.2.1 Musskriterien . . . . . . . . . . . . . . . . . . . . . . . . . . 14<br />
2.2.2 Wunschkriterien . . . . . . . . . . . . . . . . . . . . . . . . 14<br />
3 Anforderungsspezifikation 15<br />
3.1 Use Case Modell . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15<br />
3.1.1 Persistenzmanagement . . . . . . . . . . . . . . . . . . . . . 17<br />
3.1.1.1 Ein bestehendes Netz öffnen . . . . . . . . . . . . 17<br />
3.1.1.2 Ein neues Netz anlegen . . . . . . . . . . . . . . . 18<br />
3.1.1.3 Das aktuelle Netz exportieren / speichern . . . . . . 19<br />
3.1.1.4 Zusammenführen <strong>von</strong> zwei Netzen . . . . . . . . . 20<br />
3.1.2 Knotenmanagement . . . . . . . . . . . . . . . . . . . . . . 21<br />
3.1.2.1 Einen neuen Knoten in ein Netz einfügen . . . . . . 21<br />
3.1.2.2 Einen Knoten aus einem Netz löschen . . . . . . . 22<br />
3.1.2.3 Eigenschaften eines Knotens bearbeiten . . . . . . 23<br />
3.1.3 Verbindungsmanagement . . . . . . . . . . . . . . . . . . . . 24<br />
3.1.3.1 Eine Verbindung zwischen zwei Knoten erstellen . 24<br />
3.1.3.2 Eine Verbindung zwischen zwei Knoten auflösen . . 25<br />
3.1.3.3 Eigenschaften einer Verbindung bearbeiten . . . . . 26<br />
3.1.3.4 Die Zielknoten einer Verbindung bearbeiten . . . . 27<br />
3.1.4 Visualisierung . . . . . . . . . . . . . . . . . . . . . . . . . 28<br />
3.1.4.1 Knoten fokussieren . . . . . . . . . . . . . . . . . 28<br />
3.1.4.2 Navigation durch das Netz . . . . . . . . . . . . . 29<br />
3.1.4.3 Visualisierungsmodus verändern . . . . . . . . . . 30<br />
3.1.4.4 Anwenden eines Filters auf die Visualisierung . . . 31<br />
3.1.4.5 Suchen eines Knotens . . . . . . . . . . . . . . . . 32<br />
3.1.5 Typenmanagement . . . . . . . . . . . . . . . . . . . . . . . 33<br />
3.1.5.1 Neues Typenprofil anlegen . . . . . . . . . . . . . 33<br />
3.1.5.2 Bestehendes Typenprofil laden . . . . . . . . . . . 34<br />
3.1.5.3 Neuen Typen hinzufügen . . . . . . . . . . . . . . 35<br />
3.1.5.4 Typ löschen . . . . . . . . . . . . . . . . . . . . . 36<br />
3.1.5.5 Typ bearbeiten . . . . . . . . . . . . . . . . . . . . 37<br />
3
4 INHALTSVERZEICHNIS<br />
3.1.5.6 Einem Netz ein Typenprofil zuordnen . . . . . . . . 38<br />
3.1.6 Sonstiges . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39<br />
3.1.6.1 Eine mit einem Knoten verbundene Aktion ausführen 39<br />
3.1.6.2 Undo / Redo . . . . . . . . . . . . . . . . . . . . . 40<br />
3.1.6.3 Bookmark auf einen Knoten erstellen . . . . . . . . 41<br />
3.1.7 Priorisierung der Use Cases . . . . . . . . . . . . . . . . . . 42<br />
3.2 Nicht-funktionale Anforderungen . . . . . . . . . . . . . . . . . . . 42<br />
4 Benutzerinterface 45<br />
4.1 Persistenzmanagement . . . . . . . . . . . . . . . . . . . . . . . . . 45<br />
4.2 Knotenmanagement . . . . . . . . . . . . . . . . . . . . . . . . . . . 47<br />
4.3 Verbindungsmanagement . . . . . . . . . . . . . . . . . . . . . . . . 47<br />
4.4 Visualisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48<br />
4.5 Typenmanagement . . . . . . . . . . . . . . . . . . . . . . . . . . . 48<br />
4.6 Sonstiges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48<br />
5 Architektur 51<br />
5.1 Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51<br />
5.2 Bibliotheken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51<br />
6 Entwicklungsprozess 53<br />
6.1 Interne Organisation . . . . . . . . . . . . . . . . . . . . . . . . . . 53<br />
6.2 Prozessstruktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53<br />
6.2.1 Rational Unified Process . . . . . . . . . . . . . . . . . . . . 54<br />
6.2.1.1 Einführungsphase . . . . . . . . . . . . . . . . . . 54<br />
6.2.1.2 Entwurfsphase . . . . . . . . . . . . . . . . . . . . 54<br />
6.2.1.3 Konstruktionsphase . . . . . . . . . . . . . . . . . 54<br />
6.2.1.4 Übergangsphase . . . . . . . . . . . . . . . . . . . 54<br />
6.2.2 Extreme Programming . . . . . . . . . . . . . . . . . . . . . 55<br />
6.2.2.1 Pair-Programming . . . . . . . . . . . . . . . . . . 55<br />
6.2.2.2 Refactoring . . . . . . . . . . . . . . . . . . . . . 56<br />
6.3 Iterationsplan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56<br />
6.4 Prototypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58<br />
6.5 Zeitplanung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58<br />
6.6 Verwendete Software und Tools . . . . . . . . . . . . . . . . . . . . 59<br />
6.6.1 Werkzeuge zur Dokumentation . . . . . . . . . . . . . . . . . 59<br />
6.6.2 Werkzeuge zur Verwaltung und Kommunikation . . . . . . . 60<br />
6.6.3 Werkzeuge zur Entwicklung . . . . . . . . . . . . . . . . . . 60<br />
7 Qualitätssicherung 61<br />
7.1 Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61<br />
7.2 Qualitätsmerkmale . . . . . . . . . . . . . . . . . . . . . . . . . . . 61<br />
7.2.1 Änderbarkeit/Analysierbarkeit . . . . . . . . . . . . . . . . . 61<br />
7.2.2 Stabilität/Zuverlässigkeit . . . . . . . . . . . . . . . . . . . . 62<br />
7.2.3 Übertragbarkeit . . . . . . . . . . . . . . . . . . . . . . . . . 62<br />
7.2.4 Konfigurierbarkeit . . . . . . . . . . . . . . . . . . . . . . . 62<br />
7.2.5 Nutzwert . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62<br />
7.2.6 Konformität . . . . . . . . . . . . . . . . . . . . . . . . . . . 62<br />
7.2.7 Anwendbarkeit/Benutzerfreundlichkeit . . . . . . . . . . . . 62<br />
7.2.8 Effizienz . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
INHALTSVERZEICHNIS 5<br />
7.2.9 Prozessqualität . . . . . . . . . . . . . . . . . . . . . . . . . 63<br />
7.3 Umsetzung im Projekt . . . . . . . . . . . . . . . . . . . . . . . . . 63<br />
7.3.1 Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63<br />
7.3.2 Richtlinien . . . . . . . . . . . . . . . . . . . . . . . . . . . 64<br />
7.3.3 Dokumentation <strong>von</strong> Änderungen . . . . . . . . . . . . . . . . 64<br />
7.3.4 Layout und Stil . . . . . . . . . . . . . . . . . . . . . . . . . 64<br />
7.3.4.1 Code-Dokumentation . . . . . . . . . . . . . . . . 65<br />
7.3.4.2 Namensgebung . . . . . . . . . . . . . . . . . . . 65<br />
7.3.4.3 Programmierstandard . . . . . . . . . . . . . . . . 65<br />
7.3.5 Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65<br />
7.3.5.1 Unit-Tests . . . . . . . . . . . . . . . . . . . . . . 65<br />
7.3.5.2 Manuelle Tests . . . . . . . . . . . . . . . . . . . . 66<br />
7.3.5.3 Fehlerdokumetation . . . . . . . . . . . . . . . . . 66<br />
7.3.5.4 Durchführung . . . . . . . . . . . . . . . . . . . . 66<br />
7.3.6 Kommunikation . . . . . . . . . . . . . . . . . . . . . . . . 66<br />
7.4 Merkmals-Maßnahmen-Zuordnung . . . . . . . . . . . . . . . . . . . 67<br />
7.5 Kontrolle der Qualität . . . . . . . . . . . . . . . . . . . . . . . . . . 67<br />
7.6 Risikomanagement . . . . . . . . . . . . . . . . . . . . . . . . . . . 67<br />
7.6.1 Mangelhafter Zeitplan . . . . . . . . . . . . . . . . . . . . . 68<br />
7.6.2 Keine ordentliche Spezifikation . . . . . . . . . . . . . . . . 68<br />
7.6.3 Anforderungs-Inflation . . . . . . . . . . . . . . . . . . . . . 69<br />
7.6.4 Weggang <strong>von</strong> Personal . . . . . . . . . . . . . . . . . . . . . 70<br />
7.6.5 Umzug in das Zintl-Gebäude . . . . . . . . . . . . . . . . . . 70<br />
7.6.6 Bibliotheken . . . . . . . . . . . . . . . . . . . . . . . . . . 71<br />
8 Rechtsgrundlagen 73<br />
8.1 Vertragspartner und Vertragsgegenstand . . . . . . . . . . . . . . . . 73<br />
8.2 Urheber- und Nutzungsrechte . . . . . . . . . . . . . . . . . . . . . . 73<br />
8.3 Change-Request-Verfahren . . . . . . . . . . . . . . . . . . . . . . . 73<br />
8.4 Schadensersatz- und Wartungsansprüche . . . . . . . . . . . . . . . . 74<br />
8.4.1 Gewährleistung und Wartung . . . . . . . . . . . . . . . . . . 74<br />
8.4.2 Schadensersatzansprüche . . . . . . . . . . . . . . . . . . . . 74<br />
8.5 Anwendbares Recht und Gerichtsstand . . . . . . . . . . . . . . . . . 74<br />
8.6 Zusicherungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74<br />
8.7 Ende des Vertragsverhältnisses . . . . . . . . . . . . . . . . . . . . . 74<br />
A Eine Einführung in Topicmaps 77<br />
A.1 Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77<br />
A.2 Konzepte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78<br />
A.2.1 Kurze Einführung in Topicmaps . . . . . . . . . . . . . . . . 78<br />
B Glossar 81
6 INHALTSVERZEICHNIS
Abbildungsverzeichnis<br />
2.1 Sitemap <strong>von</strong> www.inxight.com . . . . . . . . . . . . . . . . . . . . . 13<br />
2.2 Visual Thesaurus . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13<br />
3.1 Übersicht über den Zusammenhang der Use Cases. . . . . . . . . . . 16<br />
4.1 Konzeptzeichnung der Benutzeroberfläche . . . . . . . . . . . . . . . 46<br />
4.2 Erste Implementierung einer Benutzeroberfläche (erweiterter Prototyp 1) 46<br />
6.1 Zeitliche Fixierung der Meilensteine . . . . . . . . . . . . . . . . . . 59<br />
7
8 ABBILDUNGSVERZEICHNIS
Kapitel 1<br />
Einleitung<br />
Die Gruppe ByteMe nimmt am Software-Engineering-Praktikumder Technischen Universität<br />
Darmstadt - Fachbereich <strong>Informatik</strong> - Fachgebiet Softwaretechnologie im Wintersemester<br />
2003/2004 (SE2003) teil und entwickelt für die Firma Daedalos Consulting<br />
GmbH 1 ein Werkzeug zur Bearbeitung und Visualisierung semantischer Netze. Für die<br />
Betreuung seitens der TU Darmstadt ist Dipl.-Ing. Michael Haupt zuständig.<br />
Dieses <strong>Pflichtenheft</strong> soll die genaue Aufgabenstellung festlegen, und damit Mißverständnisse<br />
zwischen Daedalos und ByteMe verhindern. Die Angaben in diesem Dokument<br />
sind für beide Seiten bindend, es handelt sich also um einen Vertrag zwischen der<br />
Firma Daedalos und der Gruppe ByteMe.<br />
1.1 Beteiligte Parteien<br />
An der Entwicklung des Visualisierungswerkzeugs sind folgende Parteien beteiligt,<br />
nachfolgend Auftraggeber und Auftragnehmer genannt:<br />
Auftraggeber<br />
Daedalos Consulting GmbH<br />
Ruhrtal 5<br />
D-58456 Witten<br />
Germany<br />
Der Auftraggeber wird vertreten durch:<br />
Thorsten Dittmar<br />
E-Mail: Thorsten.Dittmar@daedalos.com<br />
Auftragnehmer<br />
TUD, Projektgruppe ByteMe, bestehend aus<br />
• Sinisa Djukanovic<br />
• Sebastian Eifert<br />
1 http://www.daedalos.com/<br />
9
10 KA<strong>PI</strong>TEL 1. EINLEITUNG<br />
• Matthias Orgler<br />
• Kai Stroh<br />
• Carole Urvoy<br />
• Mario Vekic<br />
1.2 Kapitelübersicht<br />
• Kapitel 2 gibt einen allgemeinen Überblick über den Ist- und den Soll-Zustand<br />
des Projektes. Insbesondere werden an dieser Stelle die Muß- und Wunschkriterien<br />
festgelegt.<br />
• Kapitel 3.1 enthält die Anforderungen an das Projekt in Form <strong>von</strong> Use Cases.<br />
Diese Use Cases spiegeln somit den gewünschten Funktionsumfang des Projektes<br />
wider.<br />
• Kapitel 4 beschreibt das geplante Benutzerinterface.<br />
• Kapitel 5 beschreibt die grundlegende Architektureigenschaften des Systems.<br />
• Kapitel 6 stellt den Entwicklungsprozess und einige darin verwendete Verfahren<br />
dar und gibt einen Überblick über den zeitlichen Rahmen des Projekts.<br />
• Kapitel 7 behandelt Aspekte der Qualitätssicherung.<br />
• Kapitel 8 erläutert die rechtlichen Bedingungen des Vertrags mit Daedalos.<br />
• Anhang A gibt eine kurze Einführung zum Thema Topicmaps.<br />
• Anhang B ist ein Glossar, der Fachbegriffe erläutert.
Kapitel 2<br />
Projektübersicht<br />
Seit einiger Zeit gibt es aus unterschiedlichen Ansätze, für den Menschen typische<br />
Denkstrukturen auch rechnergestützt zu erfassen und zu modellieren. Zwei Richtungen<br />
sind dabei besonders sichtbar.<br />
Zum einen versucht das W3C, eine neue Art <strong>von</strong> Web zu implementieren. Den Seiten<br />
dieses Webs wird neben struktureller Information auch jede Menge semantischer<br />
Information mitgegeben. Wer in Zukunft zum Beispiel in Google nach LKW sucht,<br />
der wird auch die Seiten finden, in denen das Wort Lastkraftwagen steht. Diese zusätzlichen<br />
Informationen können nicht nur die Qualität der Suchergebnisse erheblich<br />
verbessern, auch wird es völlig neue Navigationswege geben.<br />
Zum anderen werden Mindmaps und artverwandte Kreativitätsmanagementmethoden<br />
immer beliebter. Dabei werden Gedanken, Ideen und ähnliches in einer nicht sequentiellen<br />
Form als „Knoten“ erfasst, zwischen denen anschließend semantische Verknüpfungen<br />
durch das Anlegen <strong>von</strong> Verbindungen hergestellt werden können. Verschiedene<br />
Möglichkeiten der Bearbeitung erlauben anschließend die Reorganisation<br />
<strong>von</strong> solchen Gedanken oder sogar die Generierung <strong>von</strong> Kapitelstrukturen, beispielsweise<br />
für Word-Dokumente.<br />
Manche Werkzeuge führen diese Ansätze auch zusammen, indem sie Websites<br />
durchsuchen und aus deren Linkstruktur eine Art Mindmap erzeugen.<br />
Die Struktur ist heute weitestgehend beschrieben. Unter anderem hat das W3C<br />
einen Standard festgelegt, der das Format der Speicherung <strong>von</strong> semantischen Netzen<br />
in einem XML-Dokument beschreibt (das so genannte XTM-Format).<br />
Auch gibt es einige Open-Source-Werkzeuge zur textuellen Bearbeitung, doch bisher<br />
sind entsprechende grafische Werkzeuge sehr teuer und meist auch nicht an eigene<br />
Bedürfnisse anpassbar.<br />
2.1 Ist-Zustand<br />
Die Firma Daedalos benutzt derzeit zu Testzwecken einige Tools zur Strukturierung<br />
<strong>von</strong> Informationen, zur Visualisierung solcher Strukturen sowie zur Erfassung inhärenter<br />
Zusammenhänge. Eines dieser Tools ist „PersonalBrain“ der Firma „TheBrain<br />
Technologies Corporation“.<br />
Hierbei sind die Mitarbeiter allerdings auf zahlreiche Schwächen des Systems gestoßen.<br />
Zunächst besitzt PersonalBrain nicht die gewünschte Flexibilität, da es nur zwei<br />
Verbindungstypen (Synonym und Abhängigkeit) kennt. Zudem ist die Software nicht<br />
11
12 KA<strong>PI</strong>TEL 2. PROJEKTÜBERSICHT<br />
plattformübergreifend, sondern nur für Win32-Systeme erhältlich. Daedalos setzt jedoch<br />
hauptsächlich Linux- und Apple-Rechner ein.<br />
Schwierigkeiten treten darüberhinaus bei der Interaktion mit bestehenden Knoten<br />
(z.B. dem Verschieben) oder bei der visuellen Auswertung der Informationsnetze auf,<br />
da immer nur ein sehr kleiner Ausschnitt des Netzes angezeigt wird.<br />
2.2 Soll-Zustand<br />
Ziel des Projektes ist es, eine Anwendung zu entwickeln, die es erlaubt, Knoten und<br />
deren Verbindungen zu anderen Knoten in semantischen Netzen zu verwalten.<br />
Die verwendete Technologie muss Java ab Version 1.4 sein. Alle dabei benutzten<br />
Komponenten müssen lizenzrechtlich die Weiterentwicklung des Projektes auf Open-<br />
Source-Basis zulassen.<br />
Sowohl Knoten als auch die Verbindungen können unterschiedlichen Typs sein.<br />
Verbindungen eines bestimmten Typs <strong>von</strong> einem Knoten zum nächsten können zum<br />
Beispiel bedeuten, dass der eine Knoten ein Synonym für einen anderen Knoten ist.<br />
Viele weitere Typen sind denkbar (Simplifizierung, Spezialisierung, Teilaspekt, Konsequenz,<br />
etc.). Auch Knoten können Typen haben, z.B. eine These, ein Fakt, ein Axiom<br />
oder eine Datei. Die Typen unterscheiden sich durch Layoutinformationen, Farben,<br />
Umrandung und gegebenenfalls andere Aktionsmöglichkeiten. Es soll die Möglichkeit<br />
bestehen, Typen je nach individuellem Bedarf zu erstellen und die oben erwähnten<br />
Eigenschaften festzulegen.<br />
Dabei sollte mit verschiedenen Sichtweisen auf das Netz experimentiert werden.<br />
Gängige Sichtweisen sind<br />
• die Fokussierung auf einen Knoten, verbunden mit der automatischen Darstellung<br />
der angrenzenden Knoten,<br />
• sich selbst dynamisch anordnende Knoten, wobei meist nur ein Teil des Netzes<br />
dargestellt werden kann,<br />
• vollständige Abbildung des Netzes (hauptsächlich <strong>von</strong> kleineren Netzen) mit<br />
oder ohne automatischer Anordnung der Knoten.<br />
Beispiele für eine gelungene Implementierung einiger dieser Darstellungsweisen<br />
sind auf den folgenden Webseiten zu finden:<br />
• http://inxight.com/map/ (siehe Abbildung 2.1)<br />
• http://www.visualthesaurus.com/online/index.html(siehe Abbildung<br />
2.2)<br />
Da der Auftraggeber für seine Aufgabe ein flexibles Tool benötigt, das insbesondere<br />
beliebige Knoten- und Verbindungstypen unterstützt und dabei plattformübergreifend<br />
einsetzbar ist, reichen die bisher am Markt erhältlichen Programme nicht aus. Unser<br />
Ziel ist es, eine in den genannten Punkten verbesserte Software zur Visualisierung semantischer<br />
Netze zu entwickeln.
2.2. SOLL-ZUSTAND 13<br />
Abbildung 2.1: Sitemap <strong>von</strong> www.inxight.com<br />
Abbildung 2.2: Visual Thesaurus
14 KA<strong>PI</strong>TEL 2. PROJEKTÜBERSICHT<br />
2.2.1 Musskriterien<br />
Die Implementierung der folgenden Musskriterien wird <strong>von</strong> der Gruppe ByteMe fest<br />
zugesagt. Details zu den einzelnen Kriterien werden im Rahmen der Use Cases (s.<br />
Kapitel 3.1) näher spezifiziert.<br />
• Das Programm muss die Möglichkeit bieten, semantische Netze in einer 2D-<br />
Ansicht darzustellen und eine Navigation durch die Netze erlauben.<br />
• Der Benutzer muss in der Lage sein, Knoten zu einem Netz hinzuzufügen und<br />
wieder zu löschen. Die Eigenschaften eines Knotens sollen bearbeitbar sein. Diese<br />
Anforderungen gelten analog auch für Verbindungen.<br />
• Es muss möglich sein, die Netze in Form <strong>von</strong> Dateien abzuspeichern und wieder<br />
zu laden. Das Zusammenführen <strong>von</strong> mehreren Netzen muss möglich sein.<br />
• Das Programm muss die Möglichkeit bieten, im laufenden Betrieb zwischen den<br />
verfügbaren Visualisierungsarten umzuschalten. Der Benutzer muss darüberhinaus<br />
in der Lage sein festzulegen, bis zu welcher Tiefe die verschiedenen Verbindungstypen<br />
- ausgehend vom derzeit fokussierten Knoten - verfolgt werden<br />
sollen.<br />
• Das Typenmanagement muss hinsichtlich Flexibilität und Konfigurierbarkeit den<br />
Ist-Zustand übertreffen. Es muss möglich sein, die einzelnen Typen anhand einer<br />
Farbcodierung o.ä. in der verwendeten Ansicht zu unterscheiden.<br />
• Es muss möglich sein, einem Knoten bzw. seinem Typ eine Aktion (z.B. das<br />
Starten eines Programms oder das Öffnen einer Webseite) zuzuordnen, die auf<br />
Befehl des Benutzers vom System ausgeführt wird.<br />
2.2.2 Wunschkriterien<br />
Die nachfolgenden als wünschenswert erachteten Funktionen sind keine Musskriterien,<br />
d.h., sie werden <strong>von</strong> der Gruppe ByteMe nur implementiert, falls vor Ablauf des<br />
Vertrages bereits alle Musskriterien verwirklicht und ausreichend getestet sind. Die<br />
hier aufgeführten Punkte sind nicht verpflichtend, sollen aber eine spätere Richtung<br />
der Weiterentwicklung aufzeigen. ByteMe wird versuchen, das Projekt so zu gestalten,<br />
dass eine spätere Implementierung einfach möglich ist.<br />
• Nach Vervollständigung der 2D-Ansicht, die in den Musskriterien beschrieben<br />
ist, können weitere Experimente mit alternativen Visualisierungsarten (z.B. eine<br />
sphärische 2D-Visualisierung) folgen.<br />
• Eine Kompatibilität zum XTM (XML Topicmap) Standard wäre wünschenswert,<br />
d.h. die Möglichkeit, Netze einzulesen, die ursprünglich nicht <strong>von</strong> unserem Programm<br />
erstellt wurden.<br />
• Evtl. könnte die Datenhaltung in einer Datenbank erfolgen, so dass alle Aktionen<br />
des Benutzers sofortige Auswirkungen auf die persistente Speicherung haben.<br />
• Netze könnten <strong>von</strong> entfernten Quellen geladen werden, die sich nicht im lokalen<br />
Dateisystem widerspiegeln, z.B. über das Internet via HTTP.
Kapitel 3<br />
Anforderungsspezifikation<br />
3.1 Use Case Modell<br />
Die hier beschriebenen Use Cases spezifizieren den gewünschten Funktionsumfang der<br />
Anwendung. Sie stellen implementierungsunabhängig Episoden aus der Benutzung in<br />
abstrakter Weise dar, die zum Erreichen eines Ziels des Benutzers dienen. Konkrete<br />
Vorgehensweisen, die stark vom Design der Benutzerschnittstelle abhängen, werden,<br />
soweit sie zum gegenwärtigen Zeitpunkt schon geplant sind, in Kapitel 4 beschrieben.<br />
Abbildung 3.1 verdeutlicht den Zusammenhang zwischen den einzelnen Use Cases.<br />
Der Benutzer unseres Programm kann zwei Rollen annehmen:<br />
• Als Information Designer gibt er Informationen und Wissen in das semantische<br />
Netz ein,<br />
• als Information User nutzt der die Informationen des Netzes für seine Arbeit.<br />
Der Information Designer benötigt dabei insbesondere die Möglichkeit, die Informationen<br />
im Netz zu bearbeiten. Er kann Knoten- und Verbindungen erstellen, bearbeiten<br />
und löschen. Weiterhin steht ihm das Typenmanagement zur Verfügung, durch das er<br />
Knoten und Kanten optisch und in Ihrer Funktionalität (verknüpfte Aktionen) kategorisieren<br />
kann. Undo/Redo-Funktionalität und die Möglichkeit, semantische Netze<br />
abzuspeichern, machen nur für den Information Designer Sinn. Während der Eingabe<br />
<strong>von</strong> Daten muss er sich durch die Informationen bewegen können und hat insbesondere<br />
bei größeren Netzen ein Interesse an den Filtermöglichkeiten der Visualisierung. Somit<br />
hat der Benutzer in dieser Rolle auch alle Möglichkeiten, durch das Netz zu navigieren.<br />
Der Information User will Informationen aus dem Netz gewinnen, wobei er kein<br />
Interesse daran hat, die Daten im Netz zu verändern. Er benötigt insbesondere die Möglichkeit,<br />
das Netz ansprechend darzustellen und durch die Informationen zu navigieren.<br />
Hierbei stehen ihm Komfortfunktionen wie die Filterung bestimmter Typen (enthalten<br />
in der Visualisierung), das Setzen <strong>von</strong> Bookmarks auf bestimmte Knoten oder das<br />
Ausführen <strong>von</strong> mit Knoten verbundenen Aktionen (z.B. der Aufruf einer Webseite) zur<br />
Verfügung. Der Information User benötigt außer dem Use Case ein bestehendes Netz<br />
öffnen keine weiteren Funktionen des Persistenzmanagements.<br />
15
16 KA<strong>PI</strong>TEL 3. ANFORDERUNGSSPEZIFIKATION<br />
Abbildung 3.1: Übersicht über den Zusammenhang der Use Cases.<br />
Elementare Use Cases sind weiß, Use Cases zum Eingeben <strong>von</strong> Informationen in ein<br />
Netz sind gelb und orange, Use Cases zum Navigieren durch das Netz sind blau und<br />
türkis. Persistenzmanagement, Knotenmanagement, Verbindungsmanagement, Typenmanagement<br />
und Visualisierung stellen dabei die Kategorien dar unter denen die elementaren<br />
Use Cases zusammengefasst sind.
3.1. USE CASE MODELL 17<br />
3.1.1 Persistenzmanagement<br />
Das Persistenzmangagement fasst Aktionen zusammen, die das Netz als ganzes betreffen,<br />
insbesondere das Speichern des aktuellen Zustandes und das Wiederherstellen<br />
eines gespeicherten Zustandes. Der Speicherort sollte dabei flexibel sein, bespielsweise<br />
sollte eine Wahlmöglichkeit zwischen einem Dateisystem und einer Datenbank zu<br />
Verfügung stehen.<br />
3.1.1.1 Ein bestehendes Netz öffnen<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Ein bestehendes Netz öffnen<br />
Benutzer als Information Designer oder Information User, System<br />
Benutzer: Will den Zustand eines zu einem früheren Zeitpunkt<br />
erstellten Netzes wiederherstellen<br />
System läuft<br />
Hauptablauf<br />
1. Der Benutzer erteilt dem System den Befehl, ein externes Netz<br />
zu öffnen.<br />
2. Das System präsentiert eine Übersicht der vorhandenen Quellen<br />
(Datei, Datenbank...) und der darin vorhandenen Netze.<br />
3. Der Benutzer wählt das gewünschte Netz.<br />
4. Das System zeigt das gewählte Netz in der Visualisierung an<br />
und stellt das zugehörige Typenprofil zu Verfügung.<br />
Alternativer Ablauf<br />
2a. Das System soll nur jeweils ein Netz geöffnet halten und es<br />
ist bereits ein Netz geladen, das noch nicht gespeicherte Änderungen<br />
enthält.<br />
2a1. Das System bietet nach Use Case „Das aktuelle Netz exportieren/speichern“<br />
eine Speichermöglichkeit für das alte Netz.<br />
2a2. Das System präsentiert eine Übersicht der vorhandenen<br />
Quellen (Datei, Datenbank...) und der darin vorhandenen Netze.<br />
2a3. Weiter bei Hauptablauf, Punkt 3<br />
3a. Abbruchwunsch<br />
3a1. Der Benutzer bricht den Vorgang ab<br />
3a2. Das System zeigt das vorher geöffnete Netz wieder an.<br />
3a3. Use Case beendet.<br />
4a. Fehler beim Laden<br />
4a1. Das System stellt einen Fehler beim Laden fest (Datei nicht<br />
gefunden, Formatfehler).<br />
4a2. Das System teilt dem Benutzer den Fehler mit und zeigt<br />
das vorher geöffnete Netz wieder an.<br />
4a3. Use Case beendet.<br />
Hauptablauf<br />
Das neue Netz ist zur Bearbeitung verfügbar.<br />
Alternativer Ablauf<br />
2a.: Das neue Netz ist zur Bearbeitung verfügbar.<br />
3a., 4a.: Der Zustand des alten Netzes ist unverändert.
18 KA<strong>PI</strong>TEL 3. ANFORDERUNGSSPEZIFIKATION<br />
3.1.1.2 Ein neues Netz anlegen<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Ein neues Netz anlegen<br />
Benutzer als Information Designer, System<br />
Benutzer: Will mit der Bearbeitung eines neuen Netzes beginnen<br />
System läuft<br />
Hauptablauf<br />
1. Der Benutzer erteilt dem System den Befehl, ein externes Netz<br />
zu erstellen.<br />
2. Das System präsentiert eine Übersicht der vorhandenen Typenprofile.<br />
3. Der Benutzer wählt ein Profil.<br />
4. Das System zeigt die leere Arbeitsfläche an und stellt die Typen<br />
aus dem evtl. geladenen Profil zu Verfügung.<br />
Alternativer Ablauf<br />
2a. Das System soll nur jeweils ein Netz geöffnet halten und es<br />
ist bereits ein Netz geladen, das noch nicht gespeicherte Änderungen<br />
enthält.<br />
2a1. Das System bietet nach Use Case „Das aktuelle Netz exportieren/speichern“<br />
eine Speichermöglichkeit für das alte Netz.<br />
2a2. Das System präsentiert eine Übersicht der vorhandenen Typenprofile.<br />
2a3. Weiter bei Hauptablauf, Punkt 3<br />
3a. Abbruchwunsch<br />
3a1. Der Benutzer bricht den Vorgang ab.<br />
3a2. Das System zeigt das vorher geöffnete Netz wieder an.<br />
3a3. Use Case beendet.<br />
Hauptablauf<br />
Das neue, leere Netz ist zur Bearbeitung verfügbar.<br />
Alternativer Ablauf<br />
2a.: Das neue, leere Netz ist zur Bearbeitung verfügbar.<br />
3a.: Der Zustand des alten Netzes ist unverändert.
3.1. USE CASE MODELL 19<br />
3.1.1.3 Das aktuelle Netz exportieren / speichern<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Das aktuelle Netz exportieren / speichern<br />
Benutzer als Information Designer, System<br />
Benutzer: Will den Zustand des aktuellen Netzes festhalten, um<br />
ihn zu einem späteren Zeitpunkt oder an einem anderen Ort wiederherzustellen.<br />
System läuft, ein Netz ist geöffnet.<br />
Hauptablauf<br />
1. Der Benutzer erteilt dem System den Befehl, das aktuelle Netz<br />
zu speichern.<br />
2. Das System präsentiert eine Übersicht der Zielorte (Datei, Datenbank...),<br />
die zur Verfügung stehen.<br />
3. Der Benutzer wählt den Ort und spezifiziert die exakte Position.<br />
4. Das System führt die Speicherung aus und zeigt wieder das<br />
aktuelle Netz auf der Arbeitsfläche.<br />
Alternativer Ablauf<br />
3a. Abbruchwunsch<br />
3a1. Der Benutzer bricht den Vorgang ab.<br />
3a2. Das System zeigt das aktuelle Netz wieder an.<br />
3a2. Usecase beendet.<br />
4a. Fehler beim Speichern<br />
4a1. Das System stellt einen Fehler beim Speichern fest (Datenträger<br />
voll, Datenbankfehler).<br />
4a2. Das System teilt dem Benutzer den Fehler mit.<br />
4a3. Weiter mit Schritt 2.<br />
Das aktuelle Netz bleibt zur Bearbeitung verfügbar.
20 KA<strong>PI</strong>TEL 3. ANFORDERUNGSSPEZIFIKATION<br />
3.1.1.4 Zusammenführen <strong>von</strong> zwei Netzen<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Zusammenführen <strong>von</strong> zwei Netzen<br />
Benutzer als Information Designer, System<br />
Benutzer: Will den Inhalt <strong>von</strong> zwei Netzen in einem kombinieren<br />
System läuft, ein Netz ist geöffnet.<br />
Hauptablauf<br />
1. Der Benutzer erteilt dem System den Befehl, ein zweites Netz<br />
zu integrieren.<br />
2. Das System präsentiert eine Übersicht der vorhandenen Quellen<br />
(Datei, Datenbank...) und der darin vorhandenen Netze.<br />
3. Der Benutzer wählt das zu integrierende Netz.<br />
4. Das System zeigt das kombinierte Netz auf der Arbeitsfläche<br />
an.<br />
Alternativer Ablauf<br />
3a. Abbruchwunsch<br />
3a1. Der Benutzer bricht den Vorgang ab.<br />
3a2. Das System zeigt das vorher geöffnete Netz wieder an.<br />
3a3. Usecase beendet.<br />
4a. Fehler beim Laden<br />
4a1. Das System stellt einen Fehler beim Laden fest (Datei nicht<br />
gefunden, Formatfehler).<br />
4a2. Das System teilt dem Benutzer den Fehler mit und zeigt<br />
das vorher geöffnete Netz wieder an.<br />
4a3. Usecase beendet.<br />
4b. Konflikte beim Zusammenführen<br />
4b1. Das System stellt einen Konflikt bei den Netzinhalten fest<br />
(z.B. identische Knotennamen).<br />
4b2. Das System bietet dem Benutzer die Möglichkeit, die Konflikte<br />
aufzulösen.<br />
4b3. Der Benutzer löst die Konflikte.<br />
Hauptablauf<br />
Das kombinierte Netz ist zur Bearbeitung verfügbar.<br />
Alternativer Ablauf<br />
3a., 4a.: Der Zustand des alten Netzes ist unverändert.<br />
4b.: Das kombinierte Netz ist zur Bearbeitung verfügbar.
3.1. USE CASE MODELL 21<br />
3.1.2 Knotenmanagement<br />
Das Knotenmanagement dient der Verwaltung <strong>von</strong> allen auf Knoten bezogenen Aktionen.<br />
Knoten im Netz stellen Gedanken, Sachverhalte und Dinge dar. Jeweils zwei<br />
Knoten sind die Endpunkte einer Verbindung, die dann als „Knoten A steht in Relation<br />
R zu Knoten B“ gelesen werden kann.<br />
Der Benutzer soll Knoten anlegen, editieren und löschen können. In den Eigenschaften<br />
eines Knotens sind universelle Daten wie z.B. sein Name, Erstellungsdatum<br />
und sein Typ gespeichert, aber auch visualisierungsabhängige Daten wie seine Position<br />
relativ zu andern Knoten o.ä.<br />
Falls das Löschen eines Knotens dazu führt, dass das Netz in zwei oder mehr disjunkte<br />
Teilgraphen zerfällt, so können Knoten aus anderen Teilnetzen nach wie vor<br />
über die Suchfunktion oder die Knotenübersicht erreicht werden.<br />
3.1.2.1 Einen neuen Knoten in ein Netz einfügen<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Einen neuen Knoten in ein Netz einfügen<br />
Benutzer als Information Designer, System<br />
Benutzer: Will eine Repräsentation eines Gedankens (oder eines<br />
Objekts, ...) haben.<br />
System läuft, ein bearbeitbares Netz steht zur Verfügung<br />
Hauptablauf<br />
1. Der Benutzer wählt einen Knotentyp aus dem Typenprofil.<br />
2. Der Benutzer erteilt dem System den Befehl zum Erstellen<br />
eines Knoten und teilt eine Benennung mit.<br />
3. Das System stellt den neuen Knoten in der Visualierung mit<br />
dem restlichen Netz dar.<br />
Alternativer Ablauf<br />
3b. Fehlschlag<br />
3b1. Das System kann den Knoten nicht erstellen.<br />
3b2. Das System zeigt eine Fehlerinformation an.<br />
3b3. Use Case beendet.<br />
Hauptablauf<br />
Das Netz enthält den neuen Knoten und ist zur Bearbeitung verfügbar,<br />
Undo- und Datumsinformationen sind gespeichert.<br />
Alternativer Ablauf<br />
Der Zustand des Netzes ist unverändert.
22 KA<strong>PI</strong>TEL 3. ANFORDERUNGSSPEZIFIKATION<br />
3.1.2.2 Einen Knoten aus einem Netz löschen<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Einen Knoten aus einem Netz löschen<br />
Benutzer als Information Designer, System<br />
Benutzer: Benötigt die vom Knoten repräsentierte Information<br />
nicht mehr.<br />
System läuft, ein bearbeitbares Netz mit mindestens einem Knoten<br />
steht zur Verfügung<br />
Hauptablauf<br />
1. Der Benutzer wählt einen Knoten aus.<br />
2. Der Benutzer erteilt dem System den Befehl zum Löschen des<br />
Knotens.<br />
3. Das System stellt das restliche Netz ohne den gelöschten Knoten<br />
und ohne die ihn berührenden Verbindungen in der Visualisierung<br />
dar.<br />
Alternativer Ablauf<br />
3b. Fehlschlag<br />
3b1. Das System kann den Knoten nicht löschen.<br />
3b2. Das System zeigt eine Fehlerinformation an.<br />
3b3. Usecase beendet.<br />
Hauptablauf<br />
Das Netz ohne den gelöschten Knoten und die ihn berührenden<br />
Verbindungen ist zur Bearbeitung verfügbar, Undo-<br />
Informationen sind verfügbar. Der Knoten ist nicht in den Bookmarks<br />
enthalten.<br />
Alternativer Ablauf<br />
Der Zustand des Netzes ist unverändert.
3.1. USE CASE MODELL 23<br />
3.1.2.3 Eigenschaften eines Knotens bearbeiten<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Eigenschaften eines Knotens bearbeiten<br />
Benutzer als Information Designer, System<br />
Benutzer: Möchte einem Knoten andere Eigenschaften (anderer<br />
Name, Typ etc.) zuordnen.<br />
System läuft, ein bearbeitbares Netz mit mindestens einem Knoten<br />
steht zur Verfügung<br />
Hauptablauf<br />
1. Der Benutzer wählt einen Knoten aus.<br />
2. Der Benutzer erteilt dem System den Befehl zum Bearbeiten<br />
des Knotens.<br />
3. Das System stellt die Eigenschaften des gewählten Knotens<br />
dar.<br />
4. Der Benutzer bearbeitet die Eigenschaften und erteilt den Befehl<br />
zur Übernahme der neuen Eigenschaften.<br />
Alternativer Ablauf<br />
2b. Die Eigenschaften des gewählten Knotens sind ständig sichtbar<br />
2b1. Das System stellt die Eigenschaften des gewählten Knotens<br />
automatisch dar.<br />
2b2. Weiter bei Hauptablauf Punkt 4.<br />
4b. Abbruch<br />
4b1. Der Benutzer bricht das Bearbeiten der Eigenschaften ab.<br />
Hauptablauf<br />
Der gewählte Knoten besitzt nun die neuen Eigenschaften.<br />
Undo-Informationen sind gespeichert.<br />
Alternativer Ablauf<br />
2b.: Der gewählte Knoten besitzt nun die neuen Eigenschaften.<br />
Undo-Informationen sind gespeichert.<br />
4b.: Der gewählte Knoten besitzt die alten Eigenschaften.
24 KA<strong>PI</strong>TEL 3. ANFORDERUNGSSPEZIFIKATION<br />
3.1.3 Verbindungsmanagement<br />
Das Verbindungsmanagement kümmert sich um das komplette Handling der Verbindungen.<br />
Verbindungen beschreiben die semantischen Zusammenhänge zwischen Knoten.<br />
Der Benutzer hat die Möglichkeit, die Eigenschaften einer Verbindung zu manipulieren.<br />
Dies betrifft z.B. Zielknoten, Farbe, Art der Relation, usw.<br />
Falls das Löschen einer Verbindung dazu führt, dass das Netz in zwei disjunkte<br />
Teilgraphen zerfällt, so können Knoten aus dem jeweils anderen Teilnetz nach wie vor<br />
über die Suchfunktion oder die Knotenübersicht erreicht werden.<br />
3.1.3.1 Eine Verbindung zwischen zwei Knoten erstellen<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Eine Verbindung zwischen zwei Knoten erstellen<br />
Benutzer als Information Designer, System<br />
Benutzer: Will eine semantische Verknüpfung zwischen zwei<br />
durch Knoten repräsentierte Informationseinheiten erstellen.<br />
System läuft, ein bearbeitbares Netz mit mindestens zwei Knoten<br />
steht zur Verfügung<br />
Hauptablauf<br />
1. Der Benutzer wählt den gewünschten Verbindungstyp aus.<br />
2. Der Benutzer erteilt dem System den Befehl zum Erstellen<br />
einer Verbindung.<br />
3. Der Benutzer wählt den ersten Knoten aus.<br />
4. Der Benutzer wählt den zweiten Knoten aus.<br />
5. Das System stellt die neue Verbindung in der Visualisierung<br />
dar.<br />
Alternativer Ablauf<br />
3a. Abbruch des Vorgangs<br />
3a1. Der Benutzer erteilt dem System den Befehl, den Vorgang<br />
abzubrechen.<br />
3a2. Use Case beendet.<br />
4a. Abbruch des Vorgangs<br />
4a1. Der Benutzer erteilt dem System den Befehl, den Vorgang<br />
abzubrechen.<br />
4a2. Use Case beendet.<br />
Hauptablauf<br />
Das Netz enthält die neu erstellte Verbindung zwischen den gewählten<br />
Knoten und ist zur Bearbeitung verfügbar, Undo- und<br />
Datumsinformationen sind gespeichert.<br />
Alternativer Ablauf<br />
Der Zustand des Netzes ist unverändert.
3.1. USE CASE MODELL 25<br />
3.1.3.2 Eine Verbindung zwischen zwei Knoten auflösen<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Eine Verbindung zwischen zwei Knoten auflösen<br />
Benutzer als Information Designer, System<br />
Benutzer: Will eine bestehende semantische Verknüpfung zwischen<br />
zwei durch Knoten repräsentierte Informationseinheiten<br />
entfernen.<br />
System läuft, ein bearbeitbares Netz mit mindestens einer Verbindung<br />
steht zur Verfügung.<br />
Hauptablauf<br />
1. Der Benutzer wählt die zu löschende Verbindung.<br />
2. Der Benutzer erteilt dem System den Befehl zum Löschen<br />
einer Verbindung.<br />
3. Das System stellt das aktuelle Netz ohne die gewählte Verbindung<br />
neu dar.<br />
Alternativer Ablauf<br />
2a. Abbruch des Vorgangs<br />
2a1. Der Benutzer erteilt dem System den Befehl, den Vorgang<br />
abzubrechen.<br />
Hauptablauf<br />
Das Netz enthält die gelöschte Verbindung nicht mehr und ist zur<br />
Bearbeitung verfügbar, Undo-Informationen sind gespeichert.<br />
Alternativer Ablauf<br />
Der Zustand des Netzes ist unverändert.
26 KA<strong>PI</strong>TEL 3. ANFORDERUNGSSPEZIFIKATION<br />
3.1.3.3 Eigenschaften einer Verbindung bearbeiten<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Eigenschaften einer Verbindung bearbeiten<br />
Benutzer als Information Designer, System<br />
Benutzer: Will die Art des Zusammenhangs zwischen zwei Informationseinheiten<br />
ändern.<br />
System läuft, ein bearbeitbares Netz mit mindestens einer Verbindung<br />
steht zur Verfügung.<br />
Hauptablauf<br />
1. Der Benutzer wählt eine Verbindung aus.<br />
2. Der Benutzer erteilt dem System den Befehl zum Bearbeiten<br />
einer Verbindung.<br />
3. Das System stellt die Eigenschaften der gewählten Verbindung<br />
dar.<br />
4. Der Benutzer bearbeitet die Eigenschaften und erteilt den Befehl<br />
zur Übernahme der neuen Eigenschaften.<br />
Alternativer Ablauf<br />
2b. Die Eigenschaften der gewählten Verbindung sind ständig<br />
sichtbar<br />
2b1. Das System stellt die Eigenschaften der gewählten Verbindung<br />
automatisch dar.<br />
2b2. Weiter bei Hauptablauf Punkt 4.<br />
4b. Abbruch<br />
4b1. Der Benutzer bricht das Bearbeiten der Eigenschaften ab.<br />
Hauptablauf<br />
Die gewählte Verbindung besitzt nun die neuen Eigenschaften.<br />
Undo-Informationen sind gespeichert.<br />
Alternativer Ablauf<br />
2b.: Die gewählte Verbindung besitzt nun die neuen Eigenschaften.<br />
Undo-Informationen sind gespeichert.<br />
4b.: Die gewählte Verbindung besitzt die alten Eigenschaften.
3.1. USE CASE MODELL 27<br />
3.1.3.4 Die Zielknoten einer Verbindung bearbeiten<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Die Zielknoten einer Verbindung bearbeiten<br />
Benutzer als Information Designer, System<br />
Benutzer: Möchte die Verbindung auf andere Informationseinheiten<br />
verweisen lassen.<br />
System läuft, ein bearbeitbares Netz mit mindestens einer Verbindung<br />
steht zur Verfügung.<br />
Hauptablauf<br />
1. Der Benutzer wählt eine Verbindung aus.<br />
2. Der Benutzer erteilt dem System den Befehl zum Bearbeiten<br />
der Zielknoten einer Verbindung.<br />
3. Das System stellt die aktuellen Zielknoten dar.<br />
4. Der Benutzer ändert die Zielknoten und erteilt den Befehl zur<br />
ihrer Übernahme.<br />
Alternativer Ablauf<br />
4b. Abbruch<br />
4b1 Der Benutzer bricht das Ändern der Zielknoten ab.<br />
Hauptablauf<br />
Die Verbindung bezieht sich auf die neuen Knoten. Undo-<br />
Informationen sind gespeichert.<br />
Alternativer Ablauf<br />
Die Verbindung bezieht sich auf die alten Zielknoten.
28 KA<strong>PI</strong>TEL 3. ANFORDERUNGSSPEZIFIKATION<br />
3.1.4 Visualisierung<br />
In den Bereich der Visualisierung fällt die Darstellung des Netzes auf eine Art, die dem<br />
Benutzer eine einfache Navigation, also das Richten des Blickpunkts auf veschiedene<br />
Knoten bzw. Teile des Netzes und das Traversieren der Verbindungen, ermöglicht.<br />
Das Filtern bestimmter Knoten- oder Verbindungstypen hilft, die Übersichtlichkeit<br />
der Darstellung zu erhöhen.<br />
Die hier dargestellten Aktionen sind nicht für jede Art der Visualisierung sinnvoll.<br />
Bei der dynamischen Selbstanordnung führt beispielsweise die Positionsveränderung<br />
eines einzelnen Knotens automatisch zu Veränderungen in der Darstellung des restlichen<br />
Netzes.<br />
3.1.4.1 Knoten fokussieren<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Knoten fokussieren<br />
Benutzer als Information Designer oder Information User, System<br />
Benutzer: Hat eine relevante Information im Netz entdeckt und<br />
will den entsprechenden Knoten zum Ausgangspunkt einer neu<br />
angeordneten Darstellung machen.<br />
System läuft, ein bearbeitbares Netz mit mindestens einem Knoten<br />
steht zur Verfügung.<br />
Hauptablauf<br />
1. Der Benutzer erteilt dem System den Befehl, den Fokus auf<br />
den gewünschten Knoten zu richten (z.B. auf einen nicht fokussierten<br />
Knoten in der Visualisierung, ein Bookmark etc.).<br />
2. Das System baut eine neue Visualisierung des Netzes auf, die<br />
den gewünschten Knoten in seiner Umgebung zeigt.<br />
3. Das System nimmt den neu fokussierten Knoten in die Liste<br />
der zuletzt besuchten Knoten auf und stellt diese dar.<br />
Hauptablauf<br />
Das Netz ist unverändert.
3.1. USE CASE MODELL 29<br />
3.1.4.2 Navigation durch das Netz<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Navigation durch das Netz<br />
Benutzer als Information Designer oder Information User, System<br />
Benutzer: Möchte die Umgebung des momentan fokussierten<br />
Knoten in einer anderen Art und Weise darstellen (z.B. sich weiter<br />
vom fokussierten Knoten entfernen, um einen besseren Überblick<br />
zu erlangen)<br />
System läuft, ein bearbeitbares Netz mit mindestens einem Knoten<br />
steht zur Verfügung.<br />
Hauptablauf<br />
1. Der Benutzer erteilt dem System den Befehl, die Darstellung<br />
der Umgebung des fokussierten Knotens zu verändern (die zur<br />
Verfügung stehenden Möglichkeiten sind abhängig vom gewählten<br />
Visualisierungsmodus und reichen <strong>von</strong> einer Rotation des<br />
Blickfeldes bis zu einer Expansion eines entfernten Knotens).<br />
2. Das System stellt die Umgebung des fokussierten Knotens auf<br />
die gewünschte Weise dar.<br />
Hauptablauf<br />
Das Netz ist unverändert.
30 KA<strong>PI</strong>TEL 3. ANFORDERUNGSSPEZIFIKATION<br />
3.1.4.3 Visualisierungsmodus verändern<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Visualisierungsmodus verändern<br />
Benutzer als Information Designer oder Information User, System<br />
Benutzer: Möchte die Darstellungsform des Netzes ändern<br />
System läuft, ein bearbeitbares Netz steht zur Verfügung.<br />
Hauptablauf<br />
1. Der Benutzer erteilt dem System den Befehl, für die Darstellung<br />
des Netzes einen anderen Visualisierungsmodus zu benutzen.<br />
2. Das System ersetzt den momentanen Visualisierungsmodus<br />
durch den neu gewählten.<br />
Hauptablauf<br />
Das Netz ist unverändert.
3.1. USE CASE MODELL 31<br />
3.1.4.4 Anwenden eines Filters auf die Visualisierung<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Anwenden eines Filters auf die Visualisierung<br />
Benutzer als Information Designer oder Information User, System<br />
Benutzer: Will für ihn momentan irrelevante Knoten- und Verbindungstypen<br />
ausblenden, um die Übersichtlichkeit zu erhöhen.<br />
System läuft, ein bearbeitbares Netz steht zur Verfügung.<br />
Hauptablauf<br />
1. Der Benutzer erteilt dem System den Befehl, einen bestimmten<br />
Knoten- oder Verbindungstyp auszublenden (bzw. bei Verbindungstypen<br />
nur bis zu einer gewissen Tiefe einzublenden).<br />
2. Das System stellt die Umgebung um den momentan fokussierten<br />
Knoten nach den neuen Vorgaben dar.<br />
Hauptablauf<br />
Das Netz ist unverändert.
32 KA<strong>PI</strong>TEL 3. ANFORDERUNGSSPEZIFIKATION<br />
3.1.4.5 Suchen eines Knotens<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Suchen eines Knotens<br />
Benutzer als Information Designer oder Information User, System<br />
Benutzer: kennt den Namen und/oder bestimmte Eigenschaften<br />
eines Knotens. Er möchte diesen Knoten im Netz auffinden.<br />
System läuft, ein bearbeitbares Netz steht zur Verfügung.<br />
Hauptablauf<br />
1. Der Benutzer erteilt dem System den Befehl, einen Knoten zu<br />
suchen.<br />
2. Das Benutzer gibt die bekannten Eigenschaften des gesuchten<br />
Knotens ein.<br />
3. Das System stellt das Resultat der Suche (evtl. direkt in der<br />
Visualisierung) dar.<br />
Alernativer Ablauf<br />
2b. Abbruch der Suche<br />
2b1. Der Benutzer erteilt dem System den Befehl, die Suche abzubrechen.<br />
2b2. Ende des Use Cases<br />
Der Zustand des Netzes ist unverändert.
3.1. USE CASE MODELL 33<br />
3.1.5 Typenmanagement<br />
Die Verwaltung <strong>von</strong> Typenprofilen sollte unabhängig <strong>von</strong> den Netzen geschehen, damit<br />
verschiedene Netze auf die gleichen Profile zurückgreifen können.<br />
Wenn ein Benutzer gerade ein Netz bearbeitet und einen zusätzlichen Knoten- oder<br />
Verbindungstyp erstellt, so wird das verwendete Profil um den neuen Typ erweitert.<br />
Dieser neue Typ steht somit auch allen anderen Netzen zur Verfügung, die dieses Profil<br />
verwenden.<br />
Ein Typ klassifiziert einen Knoten oder eine Verbindung. Er definiert sowohl Eigenschaften<br />
wie die Darstellung in der Visualisierung als auch die semantische Bedeutung<br />
des Knotens oder der Verbindung innerhalb des Netzes. In den Verbindungstypen werden<br />
dabei unter anderem die Rollen der verbundenen Knoten festgelegt. Knotentypen<br />
können zusätzlich Informationen über mit dem Knoten verbundene Aktionen enthalten<br />
(z.B. das Öffnen einer Webseite). Die dazu notwendigen Parameter (in diesem Fall die<br />
URL) werden in den Eigenschaften der einzelnen Knoten dieses Typs festgehalten.<br />
3.1.5.1 Neues Typenprofil anlegen<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Neues Typenprofil anlegen<br />
Benutzer als Information Designer, System<br />
Benutzer: Will einen neuen Satz <strong>von</strong> zusammengehörigen<br />
Knoten- und Verbindungstypen anlegen.<br />
System läuft.<br />
Hauptablauf<br />
1. Der Benutzer erteilt den System den Befehl, ein neues Typenprofil<br />
anzulegen.<br />
2. Der Benutzer teilt dem System den Namen des anzulegenden<br />
Typenprofils mit.<br />
3. Der Benutzer wählt aus, welches Typenprofil er als Vorlage<br />
verwenden möchte bzw. dass er ein leeres Profil erstellen möchte.<br />
4. Das System legt gemäß den Vorgaben ein neues Typenprofil<br />
an.<br />
Alternativer Ablauf<br />
4a. Fehler beim Erzeugen des Typenprofils<br />
4a1. Das System teilt dem Benutzer den Fehler mit<br />
4a2: UseCase beendet<br />
4b. Ein Typenprofil mit dem gewünschten Namen existiert bereits.<br />
4b1. Das System weist den Benutzer auf den Konflikt hin<br />
4b2. Der Benutzer gibt einen neuen Namen für das Typenprofil<br />
ein.<br />
4b3. Der Benutzer bestätigt das Verwerfen des alten Typenprofils.<br />
Hauptablauf<br />
Es existiert ein Typenprofil gemäß den Vorgaben.<br />
Alternativer Ablauf<br />
4a.: Am Ausgangszustand wurde nichts verändert<br />
4b.: Es existiert ein Typenprofil gemäß den Vorgaben.
34 KA<strong>PI</strong>TEL 3. ANFORDERUNGSSPEZIFIKATION<br />
3.1.5.2 Bestehendes Typenprofil laden<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Bestehendes Typenprofil laden<br />
Benutzer als Information Designer, System<br />
Benutzer: Will einen einen bestehenden Satz Knoten- und Verbindungstypen<br />
laden.<br />
System läuft, es existiert ein Typenprofil<br />
Hauptablauf<br />
1. Der Benutzer erteilt den System den Befehl, ein Typenprofil<br />
zu laden.<br />
2. Das System präsentiert dem Benutzer eine Auswahl bestehender<br />
Profile.<br />
3. Der Benutzer wählt ein Typenprofil.<br />
4. Das System zeigt das gewählte Profil an.<br />
Alternativer Ablauf<br />
3a. Abbruch<br />
3a1. Der Benutzer bricht den Vorgang ab.<br />
3a2. Use Case beendet.<br />
4a. Fehler beim Laden des Typenprofils<br />
4a1. Das System teilt dem Benutzer den Fehler mit<br />
4a2: Use Case beendet<br />
Hauptablauf<br />
Das gewählte Typenprofil wurde geladen.<br />
Alternativer Ablauf<br />
Der Ausgangszustand bleibt unverändert.
3.1. USE CASE MODELL 35<br />
3.1.5.3 Neuen Typen hinzufügen<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Neuen Typen hinzufügen<br />
Benutzer als Information Designer, System<br />
Benutzer: Will einen neuen Knoten- oder Verbindungstyp in das<br />
aktuelle Profil einfügen<br />
System läuft<br />
Hauptablauf<br />
1. Der Benutzer erteilt den Befehl, einen neuen Knoten- oder<br />
Verbindungstyp zu erstellen.<br />
2. Das System erzeugt einen neuen Typ mit Standardwerten.<br />
3. Der Benutzer editiert die Standardwerte nach seinen Vorstellungen.<br />
4. Das System speichert den neuen Typ automatisch im aktuellen<br />
Typenprofil.<br />
Alternativer Ablauf<br />
3a. Konflikt mit existierenden Typen<br />
3a1. Das System meldet den bestehenden Typenkonflikt.<br />
3a2. Der Benutzer löst den Konflikt auf.<br />
4a. Beim Speichern des veränderten Typenprofils tritt ein Fehler<br />
auf .<br />
4a1. Das System meldet den Fehler.<br />
4a2. Das aktuelle Typenprofil bleibt erhalten (inkl des neu hinzugefügten<br />
Typs).<br />
4a2a. Der Benutzer behebt den Fehler.<br />
4a2b. Das neue Typenprofil wird gespeichert.<br />
Hauptablauf<br />
Das geänderte Typenprofil wird angezeigt und wurde gespeichert.<br />
Alternativer Ablauf<br />
4a.: Falls der Benutzer den Fehler nicht behebt, wird das geänderte<br />
Typenprofil angezeigt. Es wurde jedoch nicht gespeichert.
36 KA<strong>PI</strong>TEL 3. ANFORDERUNGSSPEZIFIKATION<br />
3.1.5.4 Typ löschen<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Typ löschen<br />
Benutzer als Information Designer, System<br />
Benutzer: Will einen bestehenden Knoten- oder Verbindungstyp<br />
löschen<br />
System läuft<br />
Hauptablauf<br />
1. Der Benutzer wählt einen Knoten- oder Verbindungstyp<br />
2. Der Benutzer löscht den selektierten Typ<br />
3. Das System speichert automatisch das geänderte Typenprofil<br />
Alternativer Ablauf<br />
3a. Beim Speichern des veränderten Typenprofils tritt ein Fehler<br />
auf<br />
3a1. Das System weist den Benutzer auf den Fehler hin<br />
3a2. Das aktuelle Typenprofil bleibt erhalten (der gelöschte Typ<br />
existiert nicht mehr)<br />
3a2a. Der Benutzer behebt den Fehler<br />
3a2b. Das neue Typenprofil wird gespeichert<br />
Hauptablauf<br />
Das geänderte Typenprofil wird angezeigt und wurde gespeichert.<br />
Alternativer Ablauf<br />
3a.: Falls der Benutzer den Fehler nicht behebt, wird das geänderte<br />
Typenprofil angezeigt. Es wurde jedoch nicht gespeichert.
3.1. USE CASE MODELL 37<br />
3.1.5.5 Typ bearbeiten<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Typ bearbeiten<br />
Benutzer als Information Designer, System<br />
Benutzer: Will einen bestehenden Knoten- oder Verbindungstyp<br />
bearbeiten<br />
System läuft, Typenprofil mit mindestens einem Typ ist geöffnet<br />
Hauptablauf<br />
1. Der Benutzer wählt einen neuen Knoten- oder Verbindungstyp<br />
2. Der Benutzer editiert die Typenwerte nach seinen Vorstellungen<br />
3. Das System speichert den geänderten Typ automatisch im aktuellen<br />
Typenprofil<br />
Alternativer Ablauf<br />
2a. Die vom Benutzer eingegebenen Werte stehen in Konflikt mit<br />
einem bereits existierenden Typen.<br />
2a1. Das System zwingt den Benutzer, den Konflikt aufzulösen<br />
3a. Beim Speichern des veränderten Typenprofils tritt ein Fehler<br />
auf<br />
4a1. Das System weist den Benutzer auf den Fehler hin<br />
4a2. Das aktuelle Typenprofil bleibt erhalten (inkl des bearbeiteten<br />
Typs)<br />
4a2a. Der Benutzer behebt den Fehler<br />
4a2b. Das neue Typenprofil wird gespeichert<br />
Hauptablauf<br />
Das geänderte Typenprofil wird angezeigt und wurde gespeichert.<br />
Alternativer Ablauf<br />
4a.: Falls der Benutzer den Fehler nicht behebt, wird das geänderte<br />
Typenprofil angezeigt. Es wurde jedoch nicht gespeichert.
38 KA<strong>PI</strong>TEL 3. ANFORDERUNGSSPEZIFIKATION<br />
3.1.5.6 Einem Netz ein Typenprofil zuordnen<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Einem Netz ein Typenprofil zuordnen<br />
Benutzer als Information Designer, System<br />
Benutzer: Will ein bestehendes Typenprofil mit dem aktuellen<br />
Netz verknüpfen<br />
System läuft, ein bearbeitbares Netz steht zur Verfügung.<br />
Hauptablauf<br />
1. Der Benutzer gibt dem System den Befehl, das aktuelle Netz<br />
mit einem anderen Typenprofil zu verknüpfen.<br />
2. Das System präsentiert eine Auswahl der vorhandenen Typenprofile.<br />
3. Der Benutzer wählt ein Typenprofil.<br />
4. Das System weist den Benutzer darauf hin, dass durch diese<br />
Aktion das alte Typenprofil des aktuellen Netzes <strong>von</strong> diesem<br />
entkoppelt und alle Typen <strong>von</strong> Knoten und Verbindungen zurückgesetzt<br />
werden<br />
5. Das System verknüpft das aktuelle Netz mit dem gewählten<br />
Typenprofil und setzt alle Knoten- und Verbindungstypen auf<br />
einen Standardwert zurück.<br />
Alternativer Ablauf<br />
3a. Der Benutzer bricht den Vorgang ab<br />
3a1. UseCase beendet.<br />
4a. Der Benutzer wünscht, das alte und neue Typenprofil zu verschmelzen<br />
4a1. Das System fragt den Benutzer, ob dafür ein neues Profil<br />
angelegt oder eines der beiden bestehenden ersetzt werden soll.<br />
4a2. Das System erzeugt ein neues Typenprofil durch Vereinigung<br />
des gewählten Profils mit dem des aktuellen Netzes.<br />
4a3. UseCase beendet.<br />
4a1a. Der Benutzer bricht den Vorgang ab<br />
4a1a1. Use Case beendet<br />
Hauptablauf<br />
Das aktuelle Netz ist nun mit dem neuen Typenprofil verknüpft.<br />
Alle Knoten und Verbindungen des Netzes wurden auf einen<br />
Standardwert zurückgesetzt.<br />
Alternativer Ablauf<br />
3a. 4a1a.: Ausgangszustand unverändert.<br />
4a.: Es wurde ein neues Typenprofil als Schnittmenge der beiden<br />
existierenden erstellt. Dabei wurde evtl. (je nach Wahl des<br />
Benutzers) eines der alten Profile ersetzt. Alle Knoten- und Verbindungen<br />
behalten ihren Typ bei.
3.1. USE CASE MODELL 39<br />
3.1.6 Sonstiges<br />
Dieser Abschnitt beschreibt alle Use Cases, die sich nicht einer der obigen Kategorien<br />
zuordnen lassen.<br />
3.1.6.1 Eine mit einem Knoten verbundene Aktion ausführen<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Eine mit einem Knoten verbundene Aktion ausführen<br />
Benutzer als Information Designer oder Information User, System<br />
Benutzer: Möchte die mit dem Knoten repräsentierte Information<br />
nutzen.<br />
System läuft, ein bearbeitbares Netz mit mindestens einem Knoten<br />
steht zur Verfügung.<br />
Hauptablauf<br />
1. Der Benutzer erteilt dem System den Befehl, eine Aktion auszuführen,<br />
die sich aus dem Typ eines bestimmten Knotens und<br />
der in diesem Knoten enthaltenen Information ergibt. Eine Aktion<br />
ist beispielsweise das Öffnen eines Dokuments bzw. einer<br />
Webseite oder das Starten eines einfachen, integrierten Texteditors.<br />
2. Das System führt die Aktion aus.<br />
Alternativer Ablauf<br />
2b. Die Aktion kann nicht ausgeführt werden<br />
2b1. Das System informiert den Benutzer darüber, dass die Aktion<br />
nicht ausgeführt werden kann.<br />
Das Netz ist unverändert.
40 KA<strong>PI</strong>TEL 3. ANFORDERUNGSSPEZIFIKATION<br />
3.1.6.2 Undo / Redo<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Undo / Redo<br />
Benutzer als Information Designer, System<br />
Der Benutzer möchte eine zuvor ausgeführte Aktion rückgängig<br />
machen bzw. eine rückgängig gemachte Aktion wieder herstellen.<br />
System läuft, ein bearbeitbares Netz steht zur Verfügung, Undobzw.<br />
Redo-Informationen stehen zur Verfügung.<br />
Hauptablauf<br />
1. Der Benutzer erteilt dem System den Befehl, eine Aktion<br />
rückgängig zu machen / wieder herzustellen.<br />
2. Das System führt die Anweisung aus und aktualisiert die Visualisierung.<br />
Hauptablauf<br />
Das Netz befindet sich in dem Zustand vor der rückgängig<br />
gemachten bzw. nach der wieder hergestellten Aktion. Undo-<br />
Informationen sind aktualisiert.
3.1. USE CASE MODELL 41<br />
3.1.6.3 Bookmark auf einen Knoten erstellen<br />
Name<br />
Akteure<br />
Ziele<br />
Vorbedingung<br />
Beschreibung<br />
Nachbedingung<br />
Bookmark auf einen Knoten erstellen<br />
Benutzer als Information Designer oder Information User, System<br />
Der Benutzer möchte einen Knoten für einen schnellen Zugriff<br />
markieren.<br />
System läuft, ein bearbeitbares Netz mit mindestens einem Knoten<br />
steht zur Verfügung.<br />
Hauptablauf<br />
1. Der Benutzer wählt einen Knoten aus.<br />
2. Der Benutzer erteilt dem System den Befehl zum Erstellen<br />
eines Bookmarks.<br />
3. Das System nimmt den gewählten Knoten in die Bookmark-<br />
Liste auf.<br />
Hauptablauf<br />
Das Netz ist unverändert. Die Bookmark-Liste enthält den gewählten<br />
Knoten.
42 KA<strong>PI</strong>TEL 3. ANFORDERUNGSSPEZIFIKATION<br />
3.1.7 Priorisierung der Use Cases<br />
Um die Reihenfolge der Implementierung festzulegen, werden den einzelnen Use Cases<br />
verschiedene Prioritäten zugeordnet. Die geschätzte Schwierigkeit der Use Cases<br />
wird bei der Zeitplanung berücksichtigt.<br />
Name Schwierigkeit Priorität<br />
Ein bestehendes Netz öffnen mittel hoch<br />
Ein neues Netz anlegen niedrig mittel<br />
Das aktuelle Netz exportieren / speichern mittel mittel<br />
Zusammenführen <strong>von</strong> mehreren Netzen mittel niedrig<br />
Einen neuen Knoten in ein Netz einfügen mittel hoch<br />
Einen Knoten aus einem Netz löschen mittel mittel<br />
Eigenschaften eines Knotens bearbeiten niedrig mittel<br />
Eine Verbindung zwischen zwei Knoten erstellen mittel hoch<br />
Eine Verbindung zwischen zwei Knoten auflösen niedrig mittel<br />
Eigenschaften einer Verbindung bearbeiten niedrig mittel<br />
Die Zielknoten einer Verbindung bearbeiten mittel niedrig<br />
Knoten fokussieren mittel hoch<br />
Navigation durch das Netz hoch hoch<br />
Visualisierungsmodus verändern hoch niedrig<br />
Anwenden eines Filters auf die Visualisierung hoch mittel<br />
Suchen eines Knotens mittel mittel<br />
Neues Typenprofil anlegen niedrig niedrig<br />
Bestehendes Typenprofil laden mittel niedrig<br />
Neue Typen hinzufügen mittel mittel<br />
Typ löschen mittel niedrig<br />
Typ bearbeiten mittel niedrig<br />
Einem Netz ein Typenprofil zuordnen mittel mittel<br />
Eine mit einem Knoten verbundene Aktion ausführen hoch mittel<br />
Undo / Redo hoch mittel<br />
Bookmark auf einen Knoten erstellen niedrig niedrig<br />
3.2 Nicht-funktionale Anforderungen<br />
Dieser Abschnitt beschreibt zusammenfassend die Anforderungen an das Programm,<br />
die nicht direkt mit der Funktionalität im Zusammenhang stehen. Zum Teil wird auf<br />
diese Anforderungen auch an anderen Stellen dieses <strong>Pflichtenheft</strong>s Bezug genommen.<br />
• Aufgrund der späteren Veröffentlichung des Quelltextes muss während der Entwicklung<br />
auf bestimmte rechtliche Aspekte geachtet werden (wie z.B. die Verwendung<br />
<strong>von</strong> lizenzrechtlich unbedenklichen externen Komponenten).<br />
• Aus dem gleichen Grund wird darauf Wert gelegt, dass der Quelltext angemessen<br />
kommentiert ist und die Vorgaben des Java Style Guide beachtet werden (siehe<br />
auch Abschnitt 7.3.4), so dass die Einarbeitung anderer Entwickler in unseren<br />
Quelltext erleichtert wird.<br />
• Das Programm soll optisch ansprechend sein und das Navigieren durch das Netz<br />
soll „flüssig <strong>von</strong> der Hand gehen“, so dass das Stöbern in den Informationen, die
3.2. NICHT-FUNKTIONALE ANFORDERUNGEN 43<br />
das Netz repräsentiert, Spaß macht.<br />
• Bezüglich des Laufzeitverhaltens wird angestrebt, Netze in der Größenordnung<br />
<strong>von</strong> 10.000 Knoten in akzeptabler Geschwindigkeit bearbeiten zu können.
44 KA<strong>PI</strong>TEL 3. ANFORDERUNGSSPEZIFIKATION
Kapitel 4<br />
Benutzerinterface<br />
Das Benutzerinterface soll wegen des hohen Grades an Interaktivität bei dieser Anwendung<br />
nicht in allen Einzelheiten vorausgeplant werden. Stattdessen soll während der<br />
Implementierungsphase eine ständige Evaluation und gegebenenfalls eine Optimierung<br />
der Bedienabläufe erfolgen. Auf diese Weise können Elemente der Benutzerschnittstelle,<br />
unergonomisch oder nicht intuitiv genug sind, besser erkannt und bei Bedarf im<br />
nächsten Iterationsschritt überarbeitet werden. Abbildung 4.1 zeigt eine Konzeptzeichnung<br />
der geplanten Benutzeroberfläche. Die Interaktionsmöglichkeiten bezüglich der<br />
implementierten Use Cases (siehe Abschnitt 6.3) orientieren sich an dem in diesem<br />
Kapitel beschriebenen Entwurf.<br />
Eine erste Umsetzung dieser Oberfläche in frühen Iterationsstufen ist in Abbildung<br />
4.2 zu sehen. Es ist geplant, dieses Layout in seinen Grundzügen beizubehalten, auch<br />
wenn aus den genannten Gründen spätere Iterationsstufen da<strong>von</strong> abweichen können.<br />
Das Layout ist aufgeteilt in eine Knotenübersicht, die eine Übersicht über alle im Netz<br />
enthaltenen Knoten anzeigt, ein Eigenschaftspanel, in dem alle bekannten Eigenschaften<br />
des jeweils ausgewählten Elements dargestellt werden, und der eigentlichen Sicht<br />
auf das Netz, die den größten Teil des Bildschirms einnimmt. Die momentan markierten<br />
Knoten sind blau hervorgehoben.<br />
Über die Werkzeugleiste hat der Benutzer ständig Zugriff auf oft benötigte Funktionen,<br />
wie z.B. das Anlegen eines neuen Knotens. Die Verwendung <strong>von</strong> Dialogboxen<br />
soll so selten wie möglich erfolgen; lediglich das Typen- und Persistenzmanagement<br />
wird noch darauf zurückgreifen müssen. Ansonsten werden sie nur noch für die globalen<br />
Einstellungen des Programms benötigt. Alle anderen änderbaren Eigenschaften<br />
sollen in ständig sichtbaren Panels angezeigt werden.<br />
Im Folgenden soll kurz beschrieben werden, wie sich die einzelnen Use-Case-<br />
Kategorien in den geplanten GUI-Elementen widerspiegeln.<br />
4.1 Persistenzmanagement<br />
Die Befehle zum Laden und Speichern eines Netzes werden wahlweise über Menüpunkte<br />
im „File“-Menü, über eine Schaltfläche in der Toolbar oder aber über einen<br />
Hotkey gegeben. Die eigentliche Auswahl der zu öffnenden bzw. zu speichernden Datei<br />
erfolgt im regulären Dateidialog, der <strong>von</strong> der Java-Umgebung bereitgestellt wird.<br />
Bei Verwirklichung des als Wunschkriterium klassifizierten Datenbankzugriffs oder<br />
des Zugriffs über Netzwerke werden über einen Dialog die entsprechende Quelle so-<br />
45
46 KA<strong>PI</strong>TEL 4. BENUTZERINTERFACE<br />
Abbildung 4.1: Konzeptzeichnung der Benutzeroberfläche<br />
Abbildung 4.2: Erste Implementierung einer Benutzeroberfläche (erweiterter Prototyp<br />
1)
4.2. KNOTENMANAGEMENT 47<br />
wie evtl. nötige Zugangsdaten abgefragt.<br />
Der Befehl zum Neuanlegen eines Netzes ist über die gleichen Wege erteilbar. Der<br />
Benutzer muss daraufhin auswählen, welches Typenprofil er dem neuen Netz zu Grunde<br />
legen möchte. Dazu wählt er das gewünschte Profil aus einer Dialogbox aus.<br />
Das Zusammenführen mehrerer Netze erfolgt wie das Laden eines Netzes. Anschließend<br />
erscheint ein Dialog, über den eventuell auftretende Konflikte, die z.B.<br />
durch mehrfach vorhandene Typen auftreten können, manuell aufgelöst werden müssen.<br />
4.2 Knotenmanagement<br />
Um einen Knoten in ein Netz einzufügen, muss zunächst der gewünschte Typ des Knotens<br />
über eine Auswahlliste bestimmt werden. Alternativ kann der momentan eingestellte<br />
Typ beibehalten werden, in diesem Fall ist keine besondere Aktion nötig. Anschließend<br />
wird in der Toolbar die Schaltfläche zum Einfügen eines Knotens gewählt.<br />
Da der neue Knoten noch keine Verbindungen zu anderen Knoten besitzt, erscheint er<br />
in der graphischen Liste der zuletzt besuchten Knoten.<br />
Das Löschen eines Knotens erfolgt durch Auswahl des Knotens in der Visualisierung<br />
und dem anschließenden Wählen des Löschbefehls in der Toolbar oder des<br />
Auslösens eines Hotkeys.<br />
Um die Eigenschaften eines Knotens zu bearbeiten, genügt es, den Knoten in der<br />
Visualisierung anzuwählen. Das System stellt dessen Eigenschaften dann automatisch<br />
in einem ständig sichtbaren Bildschirmbereich dar, wo sie wie in einer Tabellenkalkulation<br />
direkt bearbeitet werden können. Die Übernahme der geänderten Daten erfolgt<br />
ebenfalls automatisch.<br />
Ein ausgewählter Knoten wird in der Visualisierung durch einen Rahmen optisch<br />
hervorgehoben.<br />
4.3 Verbindungsmanagement<br />
Um eine Verbindung zu erstellen, wird - ähnlich wie beim Erstellen eines neuen Knotens<br />
- der Verbindungstyp über eine Auswahlliste bestimmt, sofern ein anderer als der<br />
aktuell eingestellte Typ gewünscht wird. Als nächstes muss der erste Zielknoten angewählt<br />
werden, was direkt in der Visualisierung geschieht, d.h. entweder in der eigentlichen<br />
Netzdarstellung oder aber im Bereich der zuletzt besuchten Knoten. Anschließend<br />
wird über die Toolbar oder das Menü der Befehl zum Erstellen einer neuen Verbindung<br />
gegeben. Die Verbindung wird in das Netz eingefügt, sobald der Benutzer den zweiten<br />
Zielknoten auf analoge Weise auswählt.<br />
Zum Löschen wird eine Verbindung zunächst durch Anklicken in der Visualisierung<br />
ausgewählt. Danach muß nur noch über das Menü oder die Toolbar der Befehl<br />
zum Löschen der Verbindung ausgewählt werden.<br />
Das Bearbeiten der Eigenschaften einer Verbindung erfolgt nach dem selben Schema<br />
wie bei einem Knoten, wobei sich natürlich die verfügbaren Eigenschaften und<br />
Bearbeitungsmöglichkeiten unterscheiden. Auch das Ändern der Zielknoten einer Verbindung<br />
erfolgt über das Eigenschaften-Panel, da die Zielknoten normale Eigenschaften<br />
der Verbindung sind.
48 KA<strong>PI</strong>TEL 4. BENUTZERINTERFACE<br />
4.4 Visualisierung<br />
Das Arbeiten in der Visualisierung kann sich je nach gewähltem Visualisierungsmodus<br />
unterscheiden. Hier soll die Benutzerschnittstelle in der 2D-Darstellung beschrieben<br />
werden.<br />
Um einen Knoten zu fokussieren, genügt es, in der Visualisierung einen Doppelklick<br />
auf sein Icon auszuführen. Ist der gewünschte Knoten momentan nicht sichtbar,<br />
so kann er über die Gesamtliste der Knoten ausgewählt werden. Die Visualisierung<br />
wird daraufhin automatisch aktualisiert.<br />
Die Navigation durch das dargestellte Netz erfolgt durch Auswahl der gewünschten<br />
Aktion (Verschieben des Sichtbereiches, Rotation oder Zoom) in einer visualisierungsspezifischen<br />
Unter-Toolbar. Die Aktion selbst wird dann durch Ziehen der Maus bei gedrückter<br />
Maustaste umgesetzt. Der Benutzer kann in Echtzeit die Auswirkungen seiner<br />
Aktionen sehen. Bei der sich selbst anordnenden Visualisierung erfolgt die Navigation<br />
durch direktes Ziehen eines Knotens in die gewünschte Richtung. Die verbundenen<br />
Knoten folgen dem gezogenen Knoten und ordnen sich automatisch an.<br />
Das Umschalten des Visualisierungsmodus erfolgt über das Menü, wo alle dem<br />
System bekannten Modi aufgelistet sind.<br />
Das Aktivieren <strong>von</strong> Filtern kann zum einen über die Eigenschaften einer Verbindung<br />
geschehen. Der Filter gilt dann für alle Verbindungen des gleichen Typs. Zum<br />
anderen kann man im Typenmanagement die Filter für jeden Verbindungstyp setzen.<br />
Dies ist z.B. dann notwendig, wenn keine Verbindung eines bestimmten Typs mehr<br />
in der Visualisierung angezeigt wird, da man sie dann logischerweise nicht auswählen<br />
kann.<br />
Um einen Knoten zu suchen, kann statt der Gesamtliste der Knoten eine Liste eingeblendet<br />
werden, die nur Knoten mit den gewünschten Eigenschaften enthält. Beim<br />
Umschalten auf die Suchansicht wird das Feld, das normalerweise die Eigenschaften<br />
<strong>von</strong> Knoten und Verbindungen enthält, geleert, so dass dort die gewünschten Suchbegriffe<br />
eingegeben werden können. Das Betätigen des ebenfalls eingeblendeten Suchen-<br />
Buttons startet die Suche.<br />
4.5 Typenmanagement<br />
Aktionen, die das Typenmanagement betreffen, sind in einer Dialogbox verfügbar, die<br />
über das Hauptmenü aufgerufen werden kann. In dieser Dialogbox kann über separate<br />
Tabs auf die Knoten- und Verbindungstypen zugegriffen werden. Die einzelnen Typen<br />
werden jeweils in einer Liste aufgeführt. Daneben werden der Eigenschaften des<br />
aktuell gewählten Elements angezeigt und können direkt verändert werden.<br />
Daneben ist es möglich, das aktuelle Typenprofil in eine neue Datei zu speichern<br />
oder ein bestehendes Typenprofil für die Verwendung im momentan geöffneten Netz<br />
zu laden.<br />
4.6 Sonstiges<br />
Will der Benutzer eine mit einem Knoten verbundene Aktion durchführen, so muß er<br />
zunächst den gewünschten Knoten durch Anklicken auswählen. Falls mit dem Knoten<br />
eine Aktion verknüpft ist, so wird dies im Eigenschaften-Panel angezeigt. Hier hat der<br />
Benutzer dann die Möglichkeit, die Aktion über eine Schaltfläche zu starten.
4.6. SONSTIGES 49<br />
Im Bearbeiten-Menü findet der Benutzer den Befehl „Undo“, über den die letzten<br />
ausgeführten Aktionen in umgekehrter Reihenfolge rückgängig gemacht werden<br />
können. Analog können über den Befehl „Redo“ rückgängig gemachte Aktionen wiederhergestellt<br />
werden. Alternativ können auch Hotkeys verwendet werden.<br />
Ist ein Knoten markiert, so hat der Benutzer die Möglichkeit, über den Menüeintrag<br />
„Bookmark / Add“ den Knoten in das Bookmark-Menü aufzunehmen. Über die Option<br />
„Manage Bookmarks“ kann der Benutzer diese Liste einsehen und Bookmarks löschen.<br />
Durch das Auswählen eines Bookmarks in diesem Menü wird die Ansicht sofort auf<br />
diesen Knoten fokussiert.
50 KA<strong>PI</strong>TEL 4. BENUTZERINTERFACE
Kapitel 5<br />
Architektur<br />
5.1 Grundlagen<br />
Das Projekt basiert auf Java 1.4 oder höher. Hinsichtlich der bereits erwähnten Platformunabhängigkeit<br />
wird Kompatibilität mit MS Windows 2000/XP, Apple Mac OS X<br />
und Linux/X11 vorausgesetzt. Als GUI-Toolkit wird Swing/JFC verwendet.<br />
Zur besseren Darstellung einzelner Menübefehle in der GUI wird zumindest in<br />
Teilen das „Java Look And Feel Graphics Repository“ 1 verwendet. Diese Grafiken<br />
garantieren eine konsistente Darstellung nach den Java look and feel design guidelines.<br />
Das Repository ist eine frei erhältliche Erweiterung der Firma Sun Microsystems zur<br />
verwendeten Programmiersprache Java.<br />
5.2 Bibliotheken<br />
Zur Begrenzung des Programmieraufwands und zur Ausnutzung bereits erprobter Programmteile<br />
sollen verschiedene Bibliotheken eingesetzt werden. Aufgrund der späteren<br />
Veröffentlichung des Projekts als Open-Source verwendet ByteMe dabei nur Bibliotheken,<br />
deren Lizenzen die Verwendbarkeit des Projektes in keiner signifikanten<br />
Weise beschneiden.<br />
Zur Repräsentation des Netzes verwenden wir die TM4J-Bibliothek (z.Zt. in der<br />
Version 0.9). Diese basiert auf dem ISO-Topicmap-Standard (siehe Anhang). Um nicht<br />
zu stark abhängig <strong>von</strong> den Formalitäten des Standards und der Bibliothek selbst zu<br />
sein, erstellen wir eine Abstraktionsschicht zwischen der Bibliothek und unserer Anwendung,<br />
die den Zusammenhang zwischen einer Topicmap (siehe Anhang A) und<br />
unserem „Netz“ herstellt.<br />
TM4J bietet neben der Topicmap-Repräsentation auch Dienste zum Im- und Exportieren<br />
<strong>von</strong> ISO-Topicmaps im XTM-Format, so dass wir dieses Format zur Serialisierung<br />
verwenden können. Zudem besteht so die Möglichkeit, bei zukünftigen Erweiterung<br />
des Programms die Topicmap in einer externen Datenbank abzulegen.<br />
Auch für die Visualisierung werden wir Bibliotheken verwenden. Zu diesem Zeitpunkt<br />
steht bereits die Verwendung <strong>von</strong> Teilen der Graphendarstellungs-Bibliothek<br />
„GraphLayout“ 2 (aktuelle Version 1.21) fest, die die dynamische Anordnung der Knoten<br />
über Abstoßungs- und Anziehungskräfte bereitstellt.<br />
1 http://java.sun.com/developer/techDocs/hi/repository/<br />
2 http://www.touchgraph.com/<br />
51
52 KA<strong>PI</strong>TEL 5. ARCHITEKTUR<br />
Daneben benutzen wir das Open-Source-Werkzeug Log4J 3 , um applikationsweit<br />
Log-Ausgaben zu erstellen. Es ist eine weit verbreitete Logging-Bibliothek und zählt<br />
heute zum De-facto-Standard für Logging. Log4J ist zur Laufzeit konfigurierbar und<br />
beeinflusst die Performance der Applikation nur minimal. Es bietet die Möglichkeit,<br />
auf alle bekannten Ausgabekanäle zu loggen (u.a. Konsole, Textdatei, Mail usw.). Die<br />
Geschwindigkeit und Flexibilität <strong>von</strong> Log4J erlaubt es, die Log-Anweisungen im Code<br />
zu belassen und sie zur Laufzeit zu aktivieren, ohne Codeänderungen durchzuführen.<br />
3 http://logging.apache.org/log4j/docs/
Kapitel 6<br />
Entwicklungsprozess<br />
6.1 Interne Organisation<br />
Die Gruppe ByteMe besteht aus sechs gleichberechtigten Mitgliedern. Es gibt keinen<br />
expliziten Projektleiter; lediglich bestimmte dauerhafte Aufgaben werden längerfristig<br />
einer bestimmten Person zugeordnet:<br />
Qualitätssicherung<br />
Außenminister<br />
Homepage<br />
Sinisa Djukanovic<br />
Matthias Orgler<br />
Kai Stroh<br />
Am Anfang jeder Teamsitzung wird ein neuer Protokollant bestimmt. Der Protokollant<br />
nimmt auch die Rolle eines Moderators wahr, indem er, sofern nötig, die Diskussion<br />
leitet und darauf achtet, dass Diskussionen nicht abschweifen. Die Protokolle<br />
werden in einen für alle Teammitglieder zugänglichen Bereich auf unserer Homepage<br />
abgelegt, so dass nachträgliches Informieren über die Beschlüsse einer Teamsitzung<br />
jederzeit möglich ist.<br />
Die Tagesordnung für die folgende Sitzung wird am Ende jeder Sitzung im Wiki<br />
(siehe Glossar) geschrieben und kann dann <strong>von</strong> jedem Teammitglied eingesehen und<br />
bei Bedarf ergänzt werden.<br />
6.2 Prozessstruktur<br />
Im Zuge der heutigen Vorstellungen <strong>von</strong> Software, besonders unter qualitativen Gesichtspunkten<br />
als auch in finanzieller und zeitlicher Hinsicht, ist es unerläßlich, den<br />
Entwicklungsprozess diesen Gesichtspunkten anzupassen bzw. daran auszurichten. Es<br />
gibt verschiedene Modelle, die den Entwicklungsprozess analysieren und versuchen,<br />
eine Lösung anzubieten. Die Gruppe ByteMe hat sich entschlossen, ihren Arbeitsprozess<br />
an den folgenden Modellen auszurichten: dem Rational Unified Process und Extreme<br />
Programming <strong>von</strong> Kent Beck (dargestellt in [3]). Dabei sollen diese Prozessabläufe<br />
nicht strikt verfolgt werden, sondern vielmehr als Leitfaden und Kontrollinstrument für<br />
einen erfolgreichen Entwicklungsprozess dienen.<br />
53
54 KA<strong>PI</strong>TEL 6. ENTWICKLUNGSPROZESS<br />
6.2.1 Rational Unified Process<br />
Der Rational Unified Process (RUP) ist in vier Phasen eingeteilt. Diese Phasen geben<br />
Auskunft über den Reifegrad des Projektes und jede schliesst mit einem sogenannten<br />
Meilenstein ab. Sie erlauben eine Organisation des Projektes entsprechend des zeitlichen<br />
Ablaufs.<br />
6.2.1.1 Einführungsphase<br />
Die Einführungs- oder auch Vorbereitungsphase (engl. inception phase) bildet sozusagen<br />
den Einstiegspunkt in ein neues Projekt. Es werden die Hauptanforderungen an das<br />
zu entwickelnde System erarbeitet. Das Ziel ist festzustellen, ob das Produkt realisiert<br />
werden kann oder nicht.<br />
Hierfür haben wir die ersten Use Cases entwickelt und in Kurzform („casual format“)<br />
festgehalten, um einen ersten Eindruck <strong>von</strong> der Funktionalität des Systems zu<br />
bekommen. Darüberhinaus wurden Technologien wie z.B. Bibliotheken und Entwicklungswerkzeuge<br />
bezüglich ihrer Eignung für die Verwendung in unserem Projekt evaluiert.<br />
Damit verbunden war auch eine erste Risikoabschätzung für die bereits hier<br />
erkennbaren Risiken (siehe auch Abschnitt 7.6).<br />
6.2.1.2 Entwurfsphase<br />
Die Aufgabe der Entwurfsphase (engl. elaboration phase) ist quasi die Vorbereitung<br />
für die Konstruktionsphase. Wir haben das Use-Case-Modell vervollständigt und die<br />
bereits existierenden Use Cases in das „fully dressed format“ überführt. Zusätzlich<br />
wurde eine Priorisierung und eine Einteilung der Use Cases nach ihrer Schwierigkeit<br />
vorgenommen.<br />
Nach der Evaluierung <strong>von</strong> Werkzeugen und Technologien in der Einführungsphase<br />
erfolgte hier die Festlegung auf diejenigen, die geeignet erschienen. Mit Hilfe des<br />
UML-Tools Together haben wir ein Klassenmodell erstellt, auf dessen Basis ein erster<br />
lauffähiger Prototyp entwickelt wurde. Dieser ist die Basis für die weitere Systementwicklung.<br />
6.2.1.3 Konstruktionsphase<br />
Die Hauptaufgabe der Konstruktionsphase (engl. construction phase) ist die Implementierung<br />
und das Testen der Systemkomponenten. Basis für die Entwicklung ist der in<br />
der Entwurfsphase entstandene Architektur-Prototyp. Die grundlegende Analyse des<br />
Systems ist beendet, jedoch können noch während der Konstruktionsphase Veränderungen<br />
im Design vorgenommen werden, um flexibel auf geänderte Umstände (z.B.<br />
zusätzliche Anregungen des Auftraggebers) reagieren zu können. Daher wollen wir in<br />
dieser Phase vor allem auf verschiedene Prinzipien des XP zurückgreifen, die in Abschnitt<br />
6.2.2 näher betrachtet werden.<br />
6.2.1.4 Übergangsphase<br />
In dieser Phase (engl. transition phase) erfolgt der Übergang des Systems aus der Entwicklungsumgebung<br />
zum Kunden. Diese Phase ist bei uns <strong>von</strong> geringerer Bedeutung,<br />
da der Auftraggeber schon während der Konstruktionsphase Zugriff auf Vorversionen<br />
des Systems hat. Daher sollten hier folglich keine Schwierigkeiten auftreten.
6.2. PROZESSSTRUKTUR 55<br />
6.2.2 Extreme Programming<br />
Diese <strong>von</strong> Kent Beck entwickelte Methode stellt mit ihren Regeln und Bedingungen<br />
einen Rahmen für die Durchführung <strong>von</strong> Software-Projekten zur Verfügung. Durch die<br />
relativ kleine Anzahl <strong>von</strong> Gruppenmitgliedern bietet sich der Einsatz <strong>von</strong> Extreme Programming<br />
an und verspricht einen erfolgreichen und schnelleren Implementierungs-<br />
Prozess.<br />
XP verzichtet auf eine Reihe <strong>von</strong> Elementen der klassischen Softwareentwicklung,<br />
um so eine schnellere und effizientere Kodierung zu erlauben. Die dabei entstehenden<br />
Defizite werden durch stärkere Gewichtung anderer Konzepte (insbesondere der<br />
Testverfahren) zu kompensieren versucht.<br />
Weil der Programmcode das ultimative Ziel einer Softwareentwicklung ist, fokussiert<br />
XP <strong>von</strong> Anfang an genau auf diesen Code. Im Gegensatz dazu wird Dokumentation<br />
als aufwändiger Ballast betrachtet. Eine Dokumentation ist aufwändig zu erstellen<br />
und sehr oft viel fehlerhafter als der Code, weil sie nicht automatisch analysier- und<br />
testbar ist. Folgerichtig wird in XP-Projekten kaum externe Dokumentation erstellt. Im<br />
Ausgleich dafür wird Wert auf eine gute Kommentierung des Quellcodes durch Coding<br />
Standards und eine umfangreiche Test-Sammlung gelegt.<br />
Dies alles basiert auf den folgenden grundlegenden Prinzipien eines XP-Prozesses:<br />
Kommunikation: Permanente und intensive Kommunikation der Entwickler untereinander<br />
sowie mit dem Kunden erlaubt schnellstmögliches Feedback sicherzustellen,<br />
unnötige Funktionalität zu verhindern, entstehende Probleme so schnell<br />
wie möglich zu lösen und das Problem der fehlenden Dokumentation zu mildern.<br />
Dies wollen wir durch regelmäßige Teamsitzungen und die Verwendung<br />
<strong>von</strong> modernen Kommunikationsmitteln (Wiki, ICQ etc.) erreichen.<br />
Einfachheit: Die Software soll so einfach wie möglich gehalten werden, keine Vorbereitung<br />
möglicher zukünftiger Erweiterungen, keine redundante oder unnötige<br />
Funktionalität und keine redundanten Strukturen sind geduldet. Dadurch bleibt<br />
das System einfach und wartbar. Wir weichen <strong>von</strong> diesem Prinzip des XP insofern<br />
ab, als dass wir die Erweiterbarkeit des Programms sicherstellen wollen,<br />
auch wenn dies zu Lasten der Einfachheit gehen kann.<br />
Feedback: Evolutionäre Entwicklung des Systems in möglichst kleinen Releases und<br />
eine permanente Verfügbarkeit des Kunden erlaubt schnelles Feedback und dadurch<br />
flexible Steuerung des Projektfortschritts. Dem wollen wir durch die Einbeziehung<br />
des Auftraggebers und unsere geplanten Intervalle zwischen den einzelnen<br />
Iterationen Rechnung tragen (siehe hierzu auch Abschnitt 6.5).<br />
Eigenverantwortung: Im XP sind die Entwickler gehalten, eigenverantwortlich zu<br />
handeln. Dies impliziert, in Absprache mit dem Kunden Funktionalitäten anzupassen<br />
und Pläne zu überdenken.<br />
Zu diesen Prinzipien gehören auch die folgenden Entwicklungspraktiken, die in unserer<br />
Gruppe zur Anwendung kommen.<br />
6.2.2.1 Pair-Programming<br />
In der Coding-Phase werden wir das sogenannte Pair-Programming benutzen. Hierbei<br />
sitzen während des Schreibens <strong>von</strong> Quellcode jeweils zwei Leute an einem Rechner.<br />
Der momentane Benutzer <strong>von</strong> Tastatur und Maus konzentriert sich auf eine bestmögliche<br />
Implementierung des aktuellen Code-Abschnitts, während der andere eher
56 KA<strong>PI</strong>TEL 6. ENTWICKLUNGSPROZESS<br />
hinsichtlich des aktuellen Lösungsansatzes strategisch vorausdenkt und versucht, Auswirkungen<br />
der aktuellen Implementierung auf das Gesamtsystem abzuschätzen. Die<br />
Rollen können dabei jederzeit getauscht werden.<br />
Die Gruppe ist in drei Kleingruppen gegliedert, die sich zwar nicht, wie in XP<br />
vorgesehen, regelmäßig neu bilden, da dies aus organisatorischen Gründen (Zeit- und<br />
Wohnsituation) nicht praktikabel ist. Jedoch wird eine Umgruppierung zu einem späteren<br />
Zeitpunkt des Projekts nicht ausgeschlossen.<br />
Model<br />
Visualisierung<br />
Controller<br />
Mario Vekic, Sinisa Djukanovic<br />
Kai Stroh, Sebastian Eifert<br />
Matthias Orgler, Carole Urvoy<br />
Grundlegend zu all diesen Punkten gehört auch die enge Zusammenarbeit zwischen<br />
Auftraggeber und -nehmer, um den Fortschritt des Projektes in die richtige Richtung<br />
garantieren zu können. Es wäre wünschenswert, während der Programmierphase kontinuierlich<br />
Rückmeldungen vom Auftraggeber zu erhalten und für die jeweils nächste<br />
Iteration zu berücksichtigen.<br />
6.2.2.2 Refactoring<br />
Software, die benutzt wird, muss laufend den sich ändernden Anforderungen angepasst<br />
werden, d.h. sie muss gewartet werden. Leider führt Software-Wartung in der Regel<br />
zur Degeneration der Struktur der Software. Das macht weitere Änderungen immer<br />
schwieriger, bis schließlich nur noch eine Neuimplementierung sinnvoll ist.<br />
Eine Möglichkeit, dieser „natürlichen“ Degeneration der Software-Struktur entgegenzuwirken,<br />
ist die kontinuierliche Software-Restrukturierung oder „Refactoring“,<br />
die dafür sorgt, dass die Software jederzeit verständlich und änderbar bleibt.<br />
Das Refactoring umfasst also konstruktive Maßnahmen, die dazu dienen, eine vorhandene<br />
Software oder Teile da<strong>von</strong> verständlicher und leichter änderbar zu machen,<br />
ohne dabei das beobachtbare Verhalten zu verändern.<br />
Durch die Wahl <strong>von</strong> Eclipse als Entwicklungsumgebung fällt die Anwendung solcher<br />
Maßnahmen relativ leicht, da dort bereits weitreichende Unterstützungsfunktionen<br />
zur Durchführung verschiedener Refactoring-Prozesse vorhanden sind.<br />
6.3 Iterationsplan<br />
Wie im Abschnitt zur Prozessstruktur (s. 6.2) bereits erwähnt, werden wir das Projekt<br />
nicht „in einem Rutsch“ implementieren, sondern mehrere, kleinere Iterationen durchführen.<br />
Dies hat mehrere Vorteile. Zunächst einmal sind die Teilaufgaben, die in jeder<br />
Iteration zu lösen sind, weniger komplex und damit besser überschaubar als die Gesamtaufgabe.<br />
Weiterhin besteht bei einem iterativen Vorgehen die Möglichkeit, frühzeitig<br />
(d.h. spätestens nach dem ersten Release) Feedback vom Auftraggeber zu erhalten<br />
und damit eventuelle Unklarheiten aufzuklären. Schließlich versucht man, durch mehrere<br />
Meilensteine das Projektrisiko zu senken. Dies ist darin begründet, dass die riskantesten<br />
und schwierigsten Aufgaben möglichst früh im Projekt implementiert werden,<br />
d.h. wenn noch viel Zeit für möglicherweise nötige Umstrukturierungen bleibt, während<br />
in späteren Iterationen nur noch vergleichsweise einfache und damit sicherer zu<br />
bewältigende Aufgaben übrig bleiben. Der aktuelle Iterationsplan wird stets in unserem<br />
Wiki festgehalten.
6.3. ITERATIONSPLAN 57<br />
Der Funktionsumfang der einzelnen Milestones läßt sich bis zu einem gewissen<br />
Grad aus der Prioritätenliste der Use Cases ableiten:<br />
Milestone 0<br />
• Grundstruktur des Programmaufbaus<br />
• Anbindung an die TM4J-Bibliothek<br />
• Use Cases:<br />
– Ein bestehendes Netz öffnen (aus einer Datei)<br />
– Knoten fokussieren in einer einfachen textbasierten Baumansicht<br />
Milestone 1<br />
• Grafische Visualisierung<br />
• Use Cases:<br />
– Das aktuelle Netz exportieren / speichern<br />
– Ein neues Netz anlegen<br />
– Einen neuen Knoten in ein Netz einfügen<br />
– Eine Verbindung zwischen zwei Knoten auflösen<br />
– Einen Knoten aus einem Netz löschen<br />
– Eine Verbindung zwischen zwei Knoten erstellen<br />
– Navigation durch das Netz<br />
Milestone 2<br />
• Fertigstellung des Benutzerinterfaces<br />
• Use Cases:<br />
– Eigenschaften eines Knotens bearbeiten<br />
– Eigenschaften einer Verbindung bearbeiten<br />
– Die Zielknoten einer Verbindung bearbeiten<br />
– Anwenden eines Filters auf die Visualisierung<br />
– Suchen eines Knotens<br />
– Neue Typen hinzufügen<br />
– Einem Netz ein Typenprofil zuordnen<br />
– Eine mit einem Knoten verbundene Aktion ausführen<br />
– Undo / Redo
58 KA<strong>PI</strong>TEL 6. ENTWICKLUNGSPROZESS<br />
Final Release<br />
• Use Cases:<br />
– Zusammenführen <strong>von</strong> mehreren Netzen<br />
– Visualisierungsmodus verändern<br />
– Neues Typenprofil anlegen<br />
– Bestehendes Typenprofil laden<br />
– Typ löschen<br />
– Typ bearbeiten<br />
– Bookmark auf einen Knoten erstellen<br />
In jeder Iteration wird soweit wie möglich das Feedback des Auftraggebers mit einbezogen.<br />
Mit jeder dazwischen liegenden Iteration werden Teile der für den nächsten<br />
Meilenstein geplanten Ausbaustufe des Programms hinzugefügt. Die Reihenfolge der<br />
Implementierung wird dabei flexibel und nach Bedarf festgelegt. Auch kann die Umsetzung<br />
der in vorherigen Stufen integrierten Use Cases in späteren Iteration noch angepasst<br />
oder erweitert werden, insbesondere was Aspekte der Benutzerfreundlichkeit<br />
angeht.<br />
6.4 Prototypen<br />
Um sicherzustellen, dass das Projekt die vom Auftraggeber gewünschte Richtung beibehält,<br />
werden regelmäßig abgeschlossene Iterationen als „Prototypen“ zum Auftraggeber<br />
gesandt.<br />
Durch dieses Prototyping werden zum einen Missverständnisse zwischen Auftraggeber<br />
und Auftragnehmer frühzeitig aufgedeckt. Auch kann auf diese Weise auf übersehene<br />
essentielle Funktionalität hingewiesen werden. Der Auftraggeber ist zudem<br />
ständig über den aktuellen Entwicklungsstand informiert.<br />
Mit Hilfe dieser Entwicklungsmethode können bestimmte Qualitätsmerkmale bezüglich<br />
ihrer Umsetzung kontrolliert werden. Hierbei sei besonders auf die Benutzerfreundlichkeit,<br />
den Nutzwert und die Zuverlässigkeit durch den frühzeitigen Einsatz<br />
hingewiesen.<br />
Des weiteren ist Prototyping eines der zentralen Wesensmerkmale eines iterativen<br />
Programmiermodells und erleichtert durch die Konzentration auf Teile der Gesamtaufgabe<br />
die schrittweise Annäherung an das endgültige Produkt.<br />
6.5 Zeitplanung<br />
In diesem Abschnitt wird der Zeitplan für das Projekt wiedergegeben. Oberstes Ziel<br />
unserer Planung ist die Einhaltung der vorgegebenen Termine. Daneben soll erreicht<br />
werden, dass die anfallenden Aufgaben möglichst gerecht (vom Zeitaufwand und vom<br />
Anspruch) auf die verschiedenen Teammitglieder verteilt werden.<br />
Unsere Zeitplanung ergibt sich aus einem fest vorgebenden Gerüst externer Termine,<br />
sowie der <strong>von</strong> uns gesetzten Meilensteine.
6.6. VERWENDETE SOFTWARE UND TOOLS 59<br />
Abbildung 6.1: Zeitliche Fixierung der Meilensteine<br />
Datum<br />
Ziel/Ereignis<br />
7. November 2003 Beginn des Projektes<br />
7. Januar 2004 1. Steering Committee<br />
21. Dezember 2003 <strong>Pflichtenheft</strong> 0.1<br />
Ende Januar 2004 Prototyp - Milestone 0<br />
4. Februar 2004 2. Steering Committee<br />
Ende Februar 2004 Abgabe <strong>Pflichtenheft</strong> 1.0<br />
Anfang März 2004 1. Review<br />
Anfang April 2004 Milestone 1<br />
Mitte Mai 2004 3. Steering Committee<br />
Anfang Juli 2004 2. Review<br />
Mitte Juni 2004 Milestone 2<br />
Anfang August 2004 Fertigstellung des Produktes<br />
Anfang Oktober 2004 Abgabe<br />
Mitte Oktober 2004 Abschlußreview<br />
Anfang November 2004 SE - Messe<br />
Der verbindliche Abgabetermin ist Anfang Oktober 2004. Die Diskrepanz zu dem<br />
oben erwähnten, internen Termin der Fertigstellung Anfang August 2004 kommt auf<br />
Grund interner Pufferzeiten zustande.<br />
Abbildung 6.1 veranschaulicht die geplanten Zeiträume der verschiedenen Projektphasen.<br />
6.6 Verwendete Software und Tools<br />
Die Gruppe ByteMe setzt zur Realisierung dieses Projektes für die unterschiedlichen<br />
Aufgaben nachfolgend aufgeführte Software ein.<br />
6.6.1 Werkzeuge zur Dokumentation<br />
Zur Erstellung der Dokumentation und der Protokolle haben wir uns für den Einsatz<br />
verschiedener, für ihren Zweck jeweils am besten geeigneter Werkzeuge entschieden.
60 KA<strong>PI</strong>TEL 6. ENTWICKLUNGSPROZESS<br />
Im einzelnen sind dies:<br />
• verschiedene einfache Texteditoren zur Erstellung des HTML-Codes für die Homepage,<br />
• OpenOffice 1.1.0 zur Erstellung der Protokolle und zum PDF-Export,<br />
• Together 6.0 für das Design eines Klassenmodells,<br />
• L Y X 1.3.2 und L A TEX 2.0.2 für das <strong>Pflichtenheft</strong>,<br />
• OpenOffice 1.1.0, um Folien für Steering Committees und Reviews zu erzeugen.<br />
6.6.2 Werkzeuge zur Verwaltung und Kommunikation<br />
Zur Kommunikation außerhalb der Teamsitzungen und zur Verwaltung und Verteilung<br />
der erstellten Dokumente verwenden wir<br />
• verschiedene E-Mail-Programme,<br />
• verschiedene HTML-Browser,<br />
• verschiedene ICQ-kompatible Instant-Messaging-Programme,<br />
• WinSCP, um Dateien in den Downloadbereich unserer Homepage zu stellen,<br />
• das MoinMoin Wiki 1 zur Projektplanung und -koordination,<br />
• ein selbst geschriebenes PHP-Skript zur Zeiterfassung.<br />
6.6.3 Werkzeuge zur Entwicklung<br />
Die Entscheidung bezüglich der Wahl der Entwicklungswerkzeuge fiel auf<br />
• CVS zur Versionsverwaltung zur Aufnahme <strong>von</strong> Quellcode, Testklassen und<br />
Beispieldateien,<br />
• Eclipse 3.0 zur Erstellung des Java Quellcodes,<br />
• JUnit als Test-Framework (in Eclipse).<br />
1 http://moin.sourceforge.net/
Kapitel 7<br />
Qualitätssicherung<br />
7.1 Einleitung<br />
Die Qualitätssicherung spielt eine zentrale Rolle im Prozess der Softwareentwicklung<br />
und beginnt bereits in der Planungsphase eines Projektes. Dieser Qualitätsbegriff bezieht<br />
sich jedoch nicht nur auf den erstellten Code, sondern auch auf die zugehörigen<br />
Dokumente wie <strong>Pflichtenheft</strong>, Code-Dokumentation, Benutzer- und Entwicklerhandbuch.<br />
In diesem Kapitel werden zunächst die wichtigsten Qualitätsmerkmale auf Basis<br />
der DIN ISO 9126 beschrieben und ggf. deren Bedeutung für das Projekt erläutert.<br />
Anschließend soll der Qualitätssicherungsplan vorgestellt werden, welcher in die praktische<br />
Umsetzung während der Projektarbeit sowie die Testfallübersicht untergliedert<br />
ist.<br />
7.2 Qualitätsmerkmale<br />
Allgemein formuliert ist Qualität die Gesamtheit <strong>von</strong> Eigenschaften und Methoden<br />
eines Produktes oder einer Tätigkeit, die sich auf deren Eignung zur Erfüllung gegebener<br />
Erfordernisse bezieht. Im Folgenden werden Merkmale der Qualität nach DIN ISO<br />
9126 und deren Bedeutung im Projekt dargestellt.<br />
7.2.1 Änderbarkeit/Analysierbarkeit<br />
Das Design des Softwaresystems in seinen unterschiedlichen Komponenten und Schnittstellen<br />
muss transparent, einheitlich und gut dokumentiert sein. Diese Attribute sind<br />
eng miteinander verknüpft: Die eingesetzten Klassen sollten minimale Abhängigkeiten<br />
untereinander besitzen und die Schnittstellen so ausgelegt sein, dass Änderungen<br />
in der Implementierung keine Auswirkungen nach außen haben. Ein einheitliches System<br />
in der Namensgebung <strong>von</strong> Variablen und Formatierung der Quellcodes erleichtert<br />
ebenfalls die Wartung und Weiterentwicklung der Software. Der wichtigste Aspekt ist<br />
eine gute und vollständige Dokumentation des Codes. Nur wenn diese Eigenschaften<br />
erfüllt sind, kann das Produkt mit vertretbarem Aufwand gewartet und ausgebaut werden.<br />
61
62 KA<strong>PI</strong>TEL 7. QUALITÄTSSICHERUNG<br />
7.2.2 Stabilität/Zuverlässigkeit<br />
Ein grundlegendes Merkmal der Qualität ist die Zuverlässigkeit des entwickelten Softwaresystems.<br />
Das betrifft in erster Linie die Zahl der (kritischen) Programmfehler, aber<br />
auch die Behandlung <strong>von</strong> Ausnahmesituationen wie Hardwarefehler, Ausfälle und andere.<br />
Da es in diesem Projekt zentral um Datenerfassung und -verwaltung geht, hat<br />
die Konsistenz der zu speichernden Informationen einen hohen Stellenwert. Ein weiterer<br />
wichtiger Punkt in diesem Zusammenhang ist die Toleranz gegenüber fehlerhaften<br />
Eingaben des Anwenders. Der Datenbestand darf dadurch nicht gefährdet werden.<br />
7.2.3 Übertragbarkeit<br />
Allgemein wird dieser Begriff mit Plattformunabhängigkeit assoziiert, das Softwaresystem<br />
soll im Idealfall in unterschiedlichsten Rechner- und Softwareumgebungen bei<br />
minimalem Anpassungsaufwand einsetzbar sein. Hier wird vor allem Wert auf uneingeschränkte<br />
Kompatibilität zu Linux- und Mac OS-Systemen gelegt.<br />
7.2.4 Konfigurierbarkeit<br />
Hinter diesem Begriff steht die Frage, inwieweit der Anwender das Softwaresystem<br />
seinen Bedürfnissen anpassen kann, ohne den Quellcode zu modifizieren. Dieses Projekt<br />
soll gerade in dieser Hinsicht dem Benutzer die besten Möglichkeiten geben, Daten<br />
verschiedenster Art zu erfassen und zu verwalten.<br />
7.2.5 Nutzwert<br />
Das Ziel jedes Softwareprojekts ist die Erstellung eines Systems, welches genau die<br />
Funktionalität besitzt, die sich der Auftraggeber vorgestellt hat. Die elementaren Voraussetzungen<br />
dafür sind<br />
• ein <strong>Pflichtenheft</strong>, welches die Anforderungen an die Software möglichst eindeutig<br />
definiert,<br />
• regelmäßige Rücksprachen mit dem Auftraggeber,<br />
• Qualitätssicherung bei der Erstellung des Programmcodes.<br />
7.2.6 Konformität<br />
Dieser Begriff ist eng mit dem des Nutzwertes und der Analysierbarkeit verknüpft. Es<br />
ist wichtig, dass die tatsächliche Implementierung des Softwaresystems den Anforderungen<br />
des <strong>Pflichtenheft</strong>es genügt.<br />
7.2.7 Anwendbarkeit/Benutzerfreundlichkeit<br />
Diese Attribute zielen vor allem auf eine intuitive Benutzeroberfläche ab: Das System<br />
soll sich so verhalten, wie es der Anwender erwartet. Der Benutzer soll in der Lage<br />
sein, das Softwaresystem nach möglichst kurzer Einarbeitungszeit nutzen zu können.<br />
Ungültige Eingaben müssen so weit wie möglich abgefangen werden und dürfen vor<br />
allem in unserem Projekt nicht die verwalteten Datenbestände gefährden. Zur Benutzerfreundlichkeit<br />
gehören auch geringe Antwortzeiten der Software.
7.3. UMSETZUNG IM PROJEKT 63<br />
7.2.8 Effizienz<br />
Das Softwaresystem soll so effizient wie möglich gestaltet werden. Dieses Attribut<br />
steht jedoch oft im Widerspruch zur Toleranz gegenüber Ausnahmesituationen und ungültigen<br />
Eingaben durch den Benutzer. Da wir Plattformunabhängigkeit garantieren<br />
wollen und daher Java als Programmiersprache verwenden, muss bei Überlegungen<br />
bezüglich der Performance stets in Betracht gezogen werden, dass das Programm nur<br />
innerhalb einer Virtual Machine laufen kann. Hier ist also in der Regel mit einem Verlust<br />
an Effizienz gegenüber einer nativen Implementierung zu rechnen. Grundsätzlich<br />
sollte beim Design darauf geachtet werden, die jeweils günstigsten Methoden für den<br />
konkreten Anwendungsfall zu finden, der allen genannten Punkten gerecht wird.<br />
7.2.9 Prozessqualität<br />
Dieser Begriff umfasst folgende Attribute, die speziell die Organisation der Projektgruppe<br />
betreffen<br />
• Prüfbarkeit der Prozessabläufe,<br />
• Nachvollziehbarkeit,<br />
• Personenunabhängigkeit.<br />
Prüfbarkeit bedeutet in diesem Zusammenhang, dass das Vorhandensein der wichtigsten<br />
Prinzipien des angewandten Entwicklungsprozesses im Rahmen eines Projektes<br />
<strong>von</strong> außen sichtbar sein sollte. Darunter fallen etwa Release-Planung und Qualitätssicherung,<br />
die in diesem <strong>Pflichtenheft</strong> beschrieben werden.<br />
Diese Prozesse müssen auch im Rückblick nachvollziehbar sein, d.h. es muss ersichtlich<br />
sein, auf welche Weise ein bestimmtes Ergebnis zustande gekommen ist. Diesem<br />
Punkt wird unter anderem durch den Einsatz des CVS-Tools Rechnung getragen,<br />
durch das alle Versionen eines damit verwalteten Dokuments oder Codestücks verfügbar<br />
sind. Desweiteren werden sämtliche Entscheidungen der Gruppe protokolliert und<br />
können somit auch zu späteren Zeitpunkten rekonstruiert werden.<br />
Teile des Entwicklungsprozesses dürfen nicht an eine einzelne Person gebunden<br />
sein. Um dies sicherzustellen, entwickeln wir einerseits kaum in Einzelarbeit, sondern<br />
hauptsächlich in Zweier-Teams. Darüberhinaus stellen wir durch die Dokumentation<br />
des Quellcodes und den ständigen Informationsaustausch über die Teamsitzungen und<br />
das Wiki sicher, dass alle Teammitglieder stets einen umfassenden Überblick über die<br />
Arbeit jeder Kleingruppe haben.<br />
7.3 Umsetzung im Projekt<br />
7.3.1 Einleitung<br />
Die Sicherung der oben aufgeführten Qualitätskriterien im Projekt wird durch die folgenden<br />
Verfahrensweisen unterstützt:<br />
• Einhaltung <strong>von</strong> Richtlinien zur Erhaltung der Transparenz und Wartbarkeit des<br />
Produkts,<br />
• Anwendung <strong>von</strong> Tests zur Minimierung <strong>von</strong> Programmfehlern,
64 KA<strong>PI</strong>TEL 7. QUALITÄTSSICHERUNG<br />
• Hinreichende Kommunikation intern und extern zur Bildung einer gemeinsamen<br />
Basis und zur Vermeidung <strong>von</strong> Missverständnissen.<br />
In den folgenden Unterkapiteln werden diese Verfahren detailliert erläutert.<br />
7.3.2 Richtlinien<br />
Ziel <strong>von</strong> einheitlichen Konventionen bei der Durchführung wichtiger Prozesse im Projekt<br />
ist die Gewährleistung <strong>von</strong> Transparenz und Wartbarkeit des Produktes. Dadurch<br />
wird sowohl die Zusammenarbeit in der Gruppe unterstützt, als auch die spätere Weiterentwicklung<br />
durch den Auftraggeber und ggf. die Open-Source-Gemeinde erleichtert.<br />
7.3.3 Dokumentation <strong>von</strong> Änderungen<br />
Jede Modifikation eines Dokumentes wird dokumentiert. Dies betrifft vor allem den<br />
Quelltext, aber auch alle schriftlichen Dokumente wie z.B. das Benutzer- und Entwicklerhandbuch.<br />
Dies wird aus technischer Sicht für den Quellcode und die Testdefinitionen<br />
durch den Einsatz des Programmpakets CVS (Concurrent Version System) gewährleistet.<br />
Durch den Einsatz <strong>von</strong> Eclipse, in dem eine umfassende CVS-Unterstützung<br />
integriert ist, wird die Nutzung dieses Systems durch alle Gruppenmitglieder sichergestellt.<br />
Hierbei wird bei jedem „Commit“-Vorgang, d.h. bei jedem Hinzufügen <strong>von</strong><br />
neuem oder Ändern <strong>von</strong> bestehendem Code, ein begleitender Kommentar abgefragt.<br />
Wir haben daher die Regel aufgestellt, commits stets mit sinnvollen Kommentaren<br />
durchzuführen. Dadurch können Änderungen einheitlich protokolliert werden und die<br />
Versionskontrolle ist gewährleistet.<br />
Bei anderen Dokumenten, wie z.B. diesem <strong>Pflichtenheft</strong>, werden grundsätzlich alle<br />
alten Versionen archiviert und sind stets über den Dateibereich auf unserer Homepage<br />
verfügbar.<br />
7.3.4 Layout und Stil<br />
Dokumentation:<br />
Für alle schriftlichen Dokumente werden einheitliche Formatvorlagen verwendet. Diese<br />
wurden vom Zuständigen für die Qualitätssicherung erzeugt. Er überprüft auch die<br />
Einhaltung und Benutzung der Vorlagen. Die Einhaltung <strong>von</strong> Layoutkonventionen ist<br />
sehr wichtig, da Dokumente in der Regel auch lange nach ihren Erstellungsdatum noch<br />
oft gelesen werden, und ein einheitlicher Stil das Zurechtfinden erheblich verbessert.<br />
Programmierstil:<br />
Auch die Formatierung der Quelltexte und das Klassendesign sind einheitlich festgelegt.<br />
Dies erleichtert vor allem die Lesbarkeit <strong>von</strong> Komponenten, die <strong>von</strong> anderen<br />
Gruppenmitgliedern erstellt wurden. Zu einem guten Programmierstil gehört auch die<br />
Dokumentation im Quelltext und die Einhaltung <strong>von</strong> bestimmten Richtlinien bei der<br />
Benennung <strong>von</strong> Variablen, Methoden und Klassen. Im wesentlich orientieren wir uns<br />
hierbei am Java Style Guide der Firma Sun. Einige Punkte werden nachfolgend kurz<br />
erläutert.
7.3. UMSETZUNG IM PROJEKT 65<br />
7.3.4.1 Code-Dokumentation<br />
Die Quelltexte sollen auch <strong>von</strong> anderen Gruppenmitgliedern und zukünftigen Entwicklern<br />
gut lesbar und verständlich sein. Darum werden alle wichtigen Variablen und Methoden<br />
(JavaDoc-konform) direkt im Programmcode kurz erläutert. Bei komplexeren<br />
Methoden wird in gleicher Weise auch auf Unterabschnitte bzw. Funktionsblöcke eingegangen.<br />
7.3.4.2 Namensgebung<br />
Für die Benennung <strong>von</strong> Klassen, Methoden und Variablen wird eine einheitliche Richtlinie<br />
festgelegt. Zum Beispiel soll der Verwendungszweck einer Variable direkt anhand<br />
des jeweiligen Bezeichners erkennbar sein. Diese Vorgehensweise erleichtert die Verständlichkeit<br />
des Quelltexts. Insbesondere bei der Benennung <strong>von</strong> Methoden wird auf<br />
eine klassenübergreifende Konsistenz geachtet, soweit dies möglich und sinnvoll ist.<br />
Vor allem wird bei der Namesgebung darauf geachtet, die englische Sprache zu verwenden,<br />
was vor allem in Bezug auf das spätere Open-Source-Dasein dieses Projektes<br />
äußerst wichtig ist.<br />
7.3.4.3 Programmierstandard<br />
Die Umsetzung eines bestimmten Programmierstandards schließt bereits die Verwendung<br />
<strong>von</strong> Namenskonventionen mit ein. Den Kern bildet jedoch ein Regelwerk das<br />
festlegt, wie die syntaktischen Mittel der eingesetzten Programmiersprache verwendet<br />
werden dürfen. Dies unterstützt zum einen die Erstellung <strong>von</strong> einheitlichem Code, hilft<br />
aber auch dabei, Fehler zu vermeiden, die zum Beispiel beim Einsatz <strong>von</strong> bestimmten<br />
Sprachmitteln auftreten können. Auch hier halten wir uns an den Java Style Guide 1 <strong>von</strong><br />
Sun.<br />
7.3.5 Tests<br />
Tests <strong>von</strong> Komponenten und Prototypen dienen der frühzeitigen Fehlererkennung. Je<br />
später ein Programmfehler entdeckt wird, desto aufwendiger wird seine Behebung. Daher<br />
wird bei der Implementierung auf die regelmäßige Anwendung <strong>von</strong> Tests geachtet.<br />
Wir verwenden beim Testen sowohl automatische Unit-Tests als auch manuelle Tests.<br />
7.3.5.1 Unit-Tests<br />
Die sogenannten Unittests, die im XP eine elementare Rolle einnehmen (siehe Abschnitt<br />
6.2.2), werden mit Hilfe <strong>von</strong> JUnit 2 durchgeführt. JUnit ist ein kleines, mächtiges<br />
Java-Framework zum Schreiben und Ausführen automatischer Unit-Tests. Hierbei<br />
werden Programmeinheiten in Isolation <strong>von</strong> anderen im Zusammenhang des Programms<br />
benötigten Einheiten getestet. Die Größe der unabhängig getesteten Einheit<br />
kann dabei <strong>von</strong> einzelnen Methoden über Klassen bis hin zu Komponenten reichen.<br />
Hierbei wird, soweit dies möglich ist, auf Test First Programming gesetzt, bei dem<br />
zunächst der Test und dann die Einheit programmiert wird.<br />
1 http://java.sun.com/docs/codeconv/html/CodeConvTOC.doc.html<br />
2 http://www.junit.org
66 KA<strong>PI</strong>TEL 7. QUALITÄTSSICHERUNG<br />
7.3.5.2 Manuelle Tests<br />
Hierbei werden Programmabläufe <strong>von</strong> den Teammitgliedern selbst getestet. Es wird dabei<br />
eine Reihe <strong>von</strong> Aktionen ausgeführt, die speziell einen Programmteil testen, oder<br />
gar einen ganzen Programmablauf. Dabei werden unter anderem vorher erzeugte Testeingabedateien<br />
verwendet, bzw. festgelegte Testszenarien durchgeführt. Da das Projekt<br />
einen sehr großen Wert auf eine ansprechende Optik und Benutzerführung legt,<br />
muss sehr oft die Tauglichkeit der GUI, bzw. der Visualisierung, durch wiederholten<br />
Einsatz geprüft werden. Hierbei sollen Fehler oder Umständlichkeiten in der Benutzerfreundlichkeit<br />
des Programms aufgedeckt werden.<br />
7.3.5.3 Fehlerdokumetation<br />
Testfälle müssen sehr genau dokumentiert werden, um eine Reproduktion des Fehlers<br />
zu ermöglichen. Hierzu hat sich die Gruppe auf einen gemeinsamen Standard der Fehlerdokumentation<br />
geeinigt. Es werden bei jedem Test der genaue Testablauf, und falls<br />
vorhanden, die Fehlermeldung festgehalten und auf dem Wiki der Gruppe festgehalten.<br />
So können Fehler jederzeit <strong>von</strong> allen Mitgliedern der Gruppe eingesehen und analysiert<br />
werden.<br />
7.3.5.4 Durchführung<br />
Die Implementierung des Projekts ist in eine Reihe <strong>von</strong> Iterationen unterteilt. Im Zuge<br />
jeder Iteration werden dem Projekt bestimmte Funktionalitäten bzw. Funktionsblöcke<br />
hinzugefügt. Vor der Implementierung eines solchen Abschnittes werden geeignete<br />
Testfälle spezifiziert, um die gewünschte Semantik zu charakterisieren. Zum Abschluss<br />
einer Iteration muss sichergestellt sein, dass alle Testfälle fehlerfrei durchgeführt werden<br />
können. Außerdem werden die Programmieraufgaben in gegenseitiger Kontrolle<br />
<strong>von</strong> Kleingruppen bearbeitet, sodass logische Fehler möglichst früh gefunden bzw.<br />
vermieden werden können.<br />
7.3.6 Kommunikation<br />
Zur Schaffung einer gemeinsamen Basis und der Vermeidung <strong>von</strong> Missverständnissen,<br />
ist ein regelmäßiger Austausch zwischen allen Beteiligten des Projektes <strong>von</strong> zentraler<br />
Bedeutung.<br />
Intern<br />
Die Gruppe trifft sich mindestens einmal wöchentlich zur gemeinsamen Teamsitzung.<br />
Darin werden unter anderem alle wichtigen Fragen abgestimmt, Aufgaben definiert<br />
und verteilt sowie Ergebnisse <strong>von</strong> Kleingruppen diskutiert. Dadurch sind alle Gruppenmitglieder<br />
kontinuierlich über Stand und Fortschritt des Projektes informiert, und<br />
Missverständnisse können schnell erkannt und ausgeräumt werden.<br />
Extern<br />
Sämtliche Kommunikation <strong>von</strong> der Gruppe nach außen läuft über den Außenminister.<br />
Er ist unter anderem auch für die Kommunikation mit dem Auftraggeber Daedalos<br />
zuständig. Einerseits unterrichtet er die anderen Teammitglieder über Nachrichten des<br />
Auftraggebers, andererseits berichtet er dem dem Auftraggeber regelmäßig über den
7.4. MERKMALS-MASSNAHMEN-ZUORDNUNG 67<br />
aktuellen Stand des Projekts. Desweiteren hat der Auftraggeber die Möglichkeit, mit<br />
der Gruppe über das gemeinsame Wiki zu kommunizieren.<br />
7.4 Merkmals-Maßnahmen-Zuordnung<br />
Merkmal<br />
Änderbarkeit / Analysierbarkeit<br />
Stabilität / Zuverlässigkeit<br />
Übertragbarkeit<br />
Konfigurierbarkeit<br />
Nutzwert<br />
Konformität<br />
Anwendbarkeit / Benutzerfreundlichkeit<br />
Effizienz<br />
Prozessqualität<br />
Maßnahme<br />
Code-Richtlinien, Code-Dokumentation<br />
Tests, Fehlerdokumentation<br />
Tests (auf verschiedenen Plattformen)<br />
(wird erfüllt durch Konformität, da in funktionaler<br />
Spezifikation)<br />
Tests, Kommunikation mit dem Auftraggeber<br />
interne Kommunikation<br />
Kommunikation mit dem Auftraggeber<br />
(Last-) Tests<br />
Dokumentation <strong>von</strong> Änderungen, interne Kommunikation<br />
7.5 Kontrolle der Qualität<br />
Die Qualitätssicherung im Projekt basiert im Kern auf einer Sammlung <strong>von</strong> Richtlinien<br />
zur Sicherstellung der Transparenz, auf dem Einsatz <strong>von</strong> statischen wie auch dynamischen<br />
Tests und auf der regelmäßigen Kommunikation zwischen allen Beteiligten. Diese<br />
Punkte wurden bereits dargestellt. Darüber hinaus werden alle wichtigen Prozesse<br />
durch folgendes Zweischichten-Modell gesichert.<br />
Aufgaben wie z.B. die Erstellung eines Dokumentes werden an Kleingruppen vergeben.<br />
Die Mitglieder einer solchen Kleingruppe kontrollieren sich während der Arbeit<br />
gegenseitig. Sollte nur eine Person an einem Thema arbeiten, so werden die Resultate<br />
zunächst vom Beauftragten für Qualitätssicherung gegengelesen. Anschließend werden<br />
die Ergebnisse in der gesamten Gruppe vorgestellt und diskutiert. Sollten Änderungen<br />
erforderlich sein, die nicht sofort durchgeführt werden können, durchlaufen sie den angeführten<br />
Vorgang erneut. Bei bestimmten Aufgabentypen können andere Vorgehensweisen<br />
besser geeignet sein. Im Allgemeinen werden alle Dokumente und Quellcodes<br />
mindestens vom Beauftragten für Qualitätssicherung auf Format und Korrektheit geprüft.<br />
7.6 Risikomanagement<br />
Im Folgenden werden die <strong>von</strong> uns erkannten Kernrisiken, die den erfolgreichen Abschluss<br />
des Projekts gefährden könnten, dargestellt und analysiert. Insbesondere werden<br />
vorbeugende Maßnahmen besprochen und Schritte für den Fall des Eintretens festgelegt.
68 KA<strong>PI</strong>TEL 7. QUALITÄTSSICHERUNG<br />
7.6.1 Mangelhafter Zeitplan<br />
Problem:<br />
Der Projektumfang wird <strong>von</strong> Anfang an komplett unterschätzt. Es ist möglich, dass<br />
wirklich eine ehrliche Schätzung versucht wurde und diese völlig falsch lag, doch oftmals<br />
ist eher der Grund, dass Wunschtermine zu festen Lieferdaten gemacht werden.<br />
Zusammen mit anderen unumstößlichen Randbedingungen des Projekts führt dies zu<br />
einem Projekt, das nach [1] „overconstrained“ ist.<br />
Risiko:<br />
Mittel - Der Umfang des Projektes scheint in unseren Augen gut abschätzbar zu sein.<br />
Vorbeugende Maßnahmen:<br />
Der Abgabetermin ist <strong>von</strong> Seiten der Universität festgesetzt und somit unabänderlich.<br />
Wir benutzen jedoch einen iterativen Entwicklungsprozess, wodurch sichergestellt ist,<br />
dass auch frühe Versionen unserer Software bereits eine gewisse Kernfunktionalität<br />
besitzen. In jedem Fall sollte der <strong>von</strong> uns aufgestellte Iterationsplan im Auge behalten<br />
werden, um Verzögerungen im Zeitplan schnell zu erkennen und darauf zu reagieren.<br />
Wenn das Risiko zu einem Problem wird:<br />
Sollten wir unter hohen Zeitdruck geraten, bietet sich an, nur die Kernfunktionalitäten<br />
des Programms zu implementieren. Zu diesem Zweck sind die Use Cases nach<br />
Schwierigkeit und Priorität sortiert. Sollte sich das Risiko manifestieren, so werden<br />
wir im Zweifelsfall trotz der Einplanung einer Pufferzone am Ende unseres Zeitplans<br />
einige niedrig-priorisierte Features nicht fertiggestellen können. Da das Projekt auch<br />
nach Abschluss der Software Engineering-Veranstaltung als Open-Source-Projekt weitergeführt<br />
wird, besteht dennoch Hoffnung, dass noch nicht implementierte Features<br />
<strong>von</strong> anderen Entwicklern der Open-Source-Gemeinde aufgegriffen und außerhalb des<br />
Rahmens dieser Veranstaltung verwirklicht werden.<br />
7.6.2 Keine ordentliche Spezifikation<br />
Problem:<br />
Der Auftraggeber kann sich nicht zu einer genauen Spezifikation des zu erstellenden<br />
Softwareprodukts durchringen bzw. es gibt widersprüchliche Anforderungen <strong>von</strong> verschiedenen<br />
Seiten.<br />
Risiko:<br />
Hoch - Die bisher vom Auftraggeber erhaltenen Anforderungen sind sehr allgemein<br />
gehalten. Ein Grund dafür mag sein, dass das Projekt nicht die Erstellung <strong>von</strong> unternehmenskritischer<br />
Software zum Ziel hat, sondern mehr als Machbarkeitsstudie, fast<br />
schon als „Experiment“ gesehen wird.
7.6. RISIKOMANAGEMENT 69<br />
Vorbeugende Maßnahmen:<br />
Es gibt (kommerzielle) Alternativen zu unserem Programm. Da nicht zu erwarten ist,<br />
dass wir detailliertere Spezifikationen erhalten werden, sollten wir uns bemühen, eine<br />
erschöpfende und in sich konsistente Anforderungsspezifikation in eigener Regie zu<br />
erstellen.<br />
Wenn das Risiko zu einem Problem wird:<br />
Im Falle einer mangelhaften Spezifikation sollten wir uns an den erwähnten Programmen<br />
orientieren und versuchen, ein Produkt mit ähnlicher Funktionalität zu erstellen.<br />
Diese <strong>von</strong> uns erstellte Spezifikation wird als Teil des <strong>Pflichtenheft</strong>s dem Auftraggeber<br />
vorgelegt und im Idealfall <strong>von</strong> ihm abgesegnet. Im Zuge der Planung und Programmierung<br />
werden wir versuchen, die Funktionalität der bereits existierenden Programme<br />
nachzubilden. Dies gilt auch für den Fall, dass sich nach Unterschrift des <strong>Pflichtenheft</strong>s<br />
irgendwelche Unklarheiten / fehlende Kernfunktionalitäten ergeben. Da die<br />
erwähnten Programme <strong>von</strong> Drittherstellern bisher noch nicht vom Auftraggeber eingesetzt<br />
wurden, ist mit einem eventuellen Scheitern des Projekts in keinem Fall ein<br />
Verlust verbunden, sondern höchstens eine Art „entgangener Gewinn“.<br />
7.6.3 Anforderungs-Inflation<br />
Problem:<br />
Nach einer Einigung auf eine Anforderungsspezifikation kommen im Laufe des Projekts<br />
immer weitere zusätzliche Anforderungen hinzu und drohen, den Zeitplan des<br />
Projekts durcheinanderzubringen.<br />
Risiko:<br />
Niedrig - Dieses <strong>Pflichtenheft</strong> mit der darin beschriebenen Funktionalität ist rechtlich<br />
bindend.<br />
Vorbeugende Maßnahmen:<br />
Streng genommen ist nur die in diesem <strong>Pflichtenheft</strong> beschriebene Funktionalität für<br />
uns bindend. Da es jedoch nach dem Risikofaktor „Keine ordentliche Spezifikation“<br />
möglich ist, dass sich Teile der benötigten Funktionalität erst im Laufe der Programmierarbeit<br />
ergeben, sollten wir dieses Risiko nicht völlig aus dem Auge verlieren.<br />
Wenn das Risiko zu einem Problem wird:<br />
Für den Fall, dass zu einem späten Zeitpunkt im Verlauf des Projekts weitere Funktionalitäten<br />
eingefordert werden, die nicht im ursprünglich abgegebenen und unterschriebenen<br />
<strong>Pflichtenheft</strong> auftauchen, können wir - je nachdem, wie wir im Zeitplan liegen<br />
- entweder die Machbarkeit beurteilen und die gewünschte Funktionalität nachträglich<br />
als Muss-Kriterium aufnehmen, oder aber ablehnen, wozu wir nach den Bedingungen<br />
in diesem Pflichenheft das Recht haben.
70 KA<strong>PI</strong>TEL 7. QUALITÄTSSICHERUNG<br />
7.6.4 Weggang <strong>von</strong> Personal<br />
Problem:<br />
Mitglieder des Teams scheiden aus, bevor das Projekt beendet ist<br />
Risiko:<br />
Niedrig - In den ersten Wochen hat sich gezeigt, dass wir ein gutes Betriebsklima haben,<br />
das <strong>von</strong> Gleichberechtigung und gegenseitigem Respekt geprägt ist.<br />
Vorbeugende Maßnahmen:<br />
Alle Teilnehmer der Veranstaltung sind in einem Team gebunden, weswegen eine „firmeninterne“<br />
Umschichtung <strong>von</strong> Personal nicht möglich ist. Wir sollten daher bemüht<br />
sein, unser gutes Betriebsklima zu erhalten und Unstimmigkeiten frühzeitig zur Sprache<br />
bringen, bevor sie zu einem echten Problem werden.<br />
Wenn das Risiko zu einem Problem wird:<br />
Sollte das Team entgegen aller Erwartungen auseinanderbrechen und die Fertigstellung<br />
des Projekts daher nicht mehr möglich sein, bietet die TU Darmstadt selbst erstellte<br />
Auffangprojekte an, die es den einzelnen Personen immerhin erlauben, die Veranstaltung<br />
erfolgreich abzuschließen.<br />
7.6.5 Umzug in das Zintl-Gebäude<br />
Problem:<br />
Der Fachbereich <strong>Informatik</strong> zieht vor Beginn der Vorlesungen im Sommersemester<br />
2004 in das ehemalige Zintl-Gebäude um. Während dieser Zeit ist die Infrastruktur des<br />
Fachbereichs nur eingeschränkt nutzbar. Dies betrifft vor allem die Server, auf denen<br />
unsere Homepage und die CVS-Repositories liegen.<br />
Risiko:<br />
Sehr Hoch - Der Umzug wird stattfinden, auch wenn er möglicherweise später als ursprünglich<br />
geplant stattfindet.<br />
Vorbeugende Maßnahmen:<br />
Da es einfach zu bewerkstelligen ist und keine großen Kapazitäten benötigt, sollten<br />
wir - zusätzlich zu den täglichen Backups der TU Darmstadt- über ein regelmäßiges<br />
eigenes Backup aller wichtigen Daten nachdenken. Ein Ausweichserver kann besonders<br />
für die CVS-Funktionalität sinnvoll sein, um die Programmierarbeit nicht unnötig<br />
zu behindern. Sollte niemand einen Server mit dauerhafter Netzanbindung zur Verfügung<br />
stellen können, so läßt sich möglicherweise bereits in diesem frühen Stadium des<br />
Projekts ein Account bei SourceForge 3 oder einem ähnlichen Dienst einrichten, der im<br />
Notfall genutzt werden kann.<br />
3 http://www.sourceforge.net/
7.6. RISIKOMANAGEMENT 71<br />
Wenn das Risiko zu einem Problem wird:<br />
Sollten wichtige Teile der Infrastruktur tatsächlich über einen längeren Zeitraum nicht<br />
nutzbar sein, so können wir auf die vorbereiteten Backup-Server ausweichen. Dieses<br />
Risiko ist jedoch streng genommen nicht unser eigenes Risiko, sondern das unseres<br />
„Vorgesetzten“ in Form des Fachbereichs. Dieser sollte sich daher darum bemühen,<br />
die Ausfallzeiten so kurz wie möglich zu halten und den Umzug aus sicht der Netzinfrastruktur<br />
transparent zu gestalten.<br />
7.6.6 Bibliotheken<br />
Problem:<br />
Im Verlauf der Entwicklung stellen sich Details der verwendeten Bibliotheken (TM4J,<br />
GraphLayout) als unvorteilhaft heraus, d.h. die Bibliotheken sind beispielsweise zu<br />
langsam, bewältigen die geforderte Datenmenge nicht fehlerfrei o.ä. Da die Bibliotheken<br />
als Open Source Projekte ständig in Entwicklung sind, ist es auch möglich, dass<br />
sich in zukünftigen Versionen eine Änderung der Schnittstellen ergibt.<br />
Risiko:<br />
Niedrig - Die Bibliotheken kommen auch in einer Vielzahl anderer Projekte zum Einsatz,<br />
woraus auf eine gewisse Zuverlässigkeit geschlossen werden kann. Es ist außerdem<br />
nicht anzunehmen, dass die Entwickler der Bibliotheken in zukünftigen Versionen<br />
Änderungen an der Schnittstelle in einer Weise vornehmen, die eine komplette<br />
Umstukturierung notwendig macht.<br />
Vorbeugende Maßnahmen:<br />
Die Bibliotheken wurden vor ihrer Verwendung ausgiebig auf ihre Eignung getestet.<br />
Die Schnittstelle zwischen unserem Projekt und den Bibliotheken wird möglichst schmal<br />
gehalten, so dass eventuelle Änderungen nur geringfügige Anpassungen an unserem<br />
Projekt notwendig machen.<br />
Wenn das Risiko zu einem Problem wird:<br />
Sollte sich eine Bibliothek nachträglich als ungeeignet für unser Projekt herausstellen,<br />
so muß die absolut notwendige Grundfunktionalität manuell reimplementiert werden.<br />
Der dadurch entstehende Zeitverlust muss durch die Pufferzone in der Zeitplanung<br />
aufgefangen werden.
72 KA<strong>PI</strong>TEL 7. QUALITÄTSSICHERUNG
Kapitel 8<br />
Rechtsgrundlagen<br />
8.1 Vertragspartner und Vertragsgegenstand<br />
Auftraggeber ist die Daedalos Consulting GmbH. Auftragnehmer ist die Studentengruppe<br />
ByteMe. Das Vertragsverhältnis zwischen Auftraggeber und Auftragnehmer<br />
entspricht einem Werkvertrag. Vertragsgegenstand ist das oben genannte Projekt in<br />
seinem vollen Umfang in Form <strong>von</strong> Dokumenten und ausführbaren Programmen.<br />
8.2 Urheber- und Nutzungsrechte<br />
Die Urheber- und Nutzungsrechte werden in dem separaten Dokument „Lizenzvereinbarung“<br />
festgelegt.<br />
8.3 Change-Request-Verfahren<br />
Änderungswünsche, die nach beidseitiger Unterzeichnung des <strong>Pflichtenheft</strong>es auftreten,<br />
werden nur unter Zustimmung sowohl des Auftraggebers als auch des Auftragnehmers<br />
berücksichtigt. Bei beidseitigem Einverständnis bezüglich Änderungen des<br />
Auftrages müssen diese Änderungen in einem separaten Schriftstück festgehalten und<br />
durch beidseitige Unterschrift bestätigt werden. Ein solches Schrifstück enthält in der<br />
Regel folgende Punkte:<br />
• Änderungswunsch,<br />
• Notwendigkeit,<br />
• Lösungsvorschlag,<br />
• Dringlichkeit,<br />
• Kosten und Auswirkungen auf das Projekt.<br />
73
74 KA<strong>PI</strong>TEL 8. RECHTSGRUNDLAGEN<br />
8.4 Schadensersatz- und Wartungsansprüche<br />
8.4.1 Gewährleistung und Wartung<br />
Es besteht keinerlei Gewährleistung für die entwickelten Programme, weder seitens<br />
der TU Darmstadt, noch seitens des Auftragnehmers. Bei den zu entwickelnden Programmen<br />
handelt es sich um eine Studie. Die Eignung für einen kommerziellen Einsatz<br />
kann nicht garantiert werden. Dem Auftraggeber ist bekannt, dass bei Softwareprodukten,<br />
trotz Erprobung unter repräsentativen Einsatzbedingungen, Fehler im Programm<br />
nicht auszuschließen sind. Daher gilt ein subjektiver Fehlerbegriff. Das bedeutet, dass<br />
ein Fehler immer dann gegeben ist, wenn der Software eine Eigenschaft fehlt, die im<br />
<strong>Pflichtenheft</strong> ausdrücklich zugesichert wurde. Weder Auftragnehmer noch die Technische<br />
Universität Darmstadt übernehmen Wartungsverpflichtungen jeglicher Art für das<br />
Produkt.<br />
8.4.2 Schadensersatzansprüche<br />
Im Falle einer Nutzung durch den Auftraggeber liegt das Risiko für jegliche Art <strong>von</strong><br />
Schäden beim Auftraggeber. Weder die TU Darmstadt, noch der Auftragnehmer haften<br />
für die bei der Nutzung entstandenen Schäden soweit diese nicht durch Vorsatz entstehen.<br />
Der Auftraggeber trägt allein das Risiko für Schäden wie z.B. Datenverluste,<br />
Hardwaredefekte oder Systemabstürze. Etwaige durch die Benutzung der Programme<br />
entstehende Kosten für die Wiederbeschaffung <strong>von</strong> Daten und Programmen sowie Kosten<br />
für Reparaturen an der Hardware sind vom Benutzer zu tragen. Der Auftragnehmer<br />
kann nicht für Sach-, Personen- und Vermögensschäden haftbar gemacht werden,<br />
die im Zusammenhang mit dem Einsatz der vom Auftragnehmer erstellten Programme<br />
entstehen könnten. Bei Schaden Dritter, der durch den Einsatz des Produktes entsteht,<br />
übernimmt der Auftragnehmer keinerlei Haftung. Eine Haftung der Technischen Universität<br />
Darmstadt für den Auftragnehmer als deren Erfüllungsgehilfen nach §278 BGB<br />
scheidet ebenfalls aus.<br />
8.5 Anwendbares Recht und Gerichtsstand<br />
Für die Rechtsbeziehungen zwischen Auftraggeber, Auftragnehmer, Technischer Universität<br />
Darmstadt und etwaigen Dritten gilt das Recht der Bundesrepublik Deutschland<br />
als zwingend vereinbart. Andere nationale Rechte werden ausgeschlossen. Der<br />
Gerichtsstand ist Darmstadt.<br />
8.6 Zusicherungen<br />
Der Auftragnehmer verpflichtet sich, die in Abschnitt 3.1 (als garantiert) zugesicherte<br />
Funktionalität zu liefern. Der Auftraggeber verpflichtet sich, diese abzunehmen.<br />
8.7 Ende des Vertragsverhältnisses<br />
Das Projekt endet, sobald der Auftraggeber nach der Übergabe der zugesicherten Programme/Prototypen<br />
die Vollständigkeit und Korrektheit der Produkte im Sinne des
8.7. ENDE DES VERTRAGSVERHÄLTNISSES 75<br />
<strong>Pflichtenheft</strong>es bestätigt, spätestens jedoch am 30. September 2004. Sollten hier Meinungsverschiedenheiten<br />
auftreten, wird die TU Darmstadt (Fachbereich <strong>Informatik</strong>,<br />
Fachgebiet Softwaretechnologie) als Schiedsstelle hinzugezogen.
76 KA<strong>PI</strong>TEL 8. RECHTSGRUNDLAGEN
Anhang A<br />
Eine Einführung in Topicmaps<br />
(Übersetzung der englischen Version, zu finden unter [4].)<br />
A.1 Einleitung<br />
Ein Buch ohne Index ist ein Land, für das keine Landkarte existiert.<br />
Doch wie interessant und spannend die Erfahrung, ohne Landkarte <strong>von</strong> A nach B<br />
zu fahren, auch sein mag, so besteht doch kein Zweifel, dass eine Karte dann unerläßlich<br />
ist, wenn man sein Ziel so schnell wie möglich (oder zumindest ohne unnötige<br />
Verzögerung) erreichen will.<br />
Sucht man analog nach einer bestimmten Information in einem Buch (anstatt es<br />
<strong>von</strong> vorne bis hinten durchzulesen), so ist ein guter Index ein immenses Plus. Ein traditioneller<br />
Index am Ende eines Buches ist wie eine sorgfältig erstellte, handgemalte<br />
Landkarte, und das Erstellen eines solchen Index ist wie eine Aufzeichnung aller Themen<br />
des jeweiligen Dokuments in einer übersichtlichen und genauen Landkarte für den<br />
Leser.<br />
Bisher gab es keine Entsprechung des traditionellen Index am Ende eines Buches<br />
in der Welt der elektronischen Information. Zwar können wir einzelne Wörter in einer<br />
Textverarbeitung markieren und so einen automatischen Index erzeugen lassen, doch<br />
diese Indizes sind zu sehr an ein bestimmtes Dokument gebunden und für eine Veröffentlichung<br />
auf Papier ausgelegt. Die Welt der elektronischen Informationen ist anders,<br />
wie uns das World Wide Web gelehrt hat. Die Unterscheidung zwischen verschiedenen<br />
Dokumenten verschwimmt, und Indizes, die mehrere Dokumente und manchmal noch<br />
größere Informationsressourcen umspannen, wären wünschenswert. Daraus Ergibt sich<br />
die Notwendigkeit, Indizes zu verschmelzen und benutzerdefinierte Sichten auf die Informationen<br />
zuzulassen. In dieser Situation sind traditionelle Indizes unbrauchbar.<br />
Das Problem ist seit Jahrzehnten in der Domäne der Dokumentenverwaltung bekannt,<br />
aber die Methoden, es zu lösen - Volltextindizes - haben das Problem nur teilweise<br />
gelöst. Jeder, der schon einmal eine Suchmaschine im Internet benutzt hat, kann<br />
dies bestätigen.<br />
Das Hauptproblem mit Volltextindizes ist ihr Mangel an Unterscheidungskraft. Sie<br />
indizieren alles. Man stelle sich einen traditionellen Index am Ende eines Buches vor,<br />
der jedes einzelne Wort des Buches umfaßt, abgesehen <strong>von</strong> ein paar hundert wirklich<br />
unnützer Wörter, und <strong>von</strong> den verbleibenden jedes einzelne Vorkommen auflistet.<br />
Selbst ohne Berücksichtigung verschiedener Flexionsformen wäre das Ergebnis ziem-<br />
77
78 ANHANG A. EINE EINFÜHRUNG IN TO<strong>PI</strong>CMAPS<br />
lich nutzlos. Eine rein mechanische Indizierung berücksichtigt nicht, dass ein Sachverhalt<br />
durch verschiedene Wörter ausgedrückt werden kann (das Synonym-Problem),<br />
oder dass ein Wort verschiedene Dinge bezeichnen kann (das Homonym-Problem).<br />
Und dennoch ist dies das Funktionsprinzip gängiger Web-Suchmaschinen (kein Wunder,<br />
dass sie stets tausende irrelevanter Ergebnisse liefern und man das Gesuchte darunter<br />
nicht findet!).<br />
Daher werden neue Methoden benötigt. Topicmaps bieten einen Ansatz, der das<br />
beste aus verschiedenen Welten verbindet, einschließlich der des traditionellen Indexerstellens,<br />
Bibliothekswissenschaft und Wissensrepräsentation, mit fortgeschrittenen<br />
Techniken des Verweisens und Adressierens. Wir sind der Überzeugung, dass sie für<br />
die Informationsanbieter <strong>von</strong> morgen so unerläßlich sein werden wie Landkarten für<br />
einen Reisenden. Und wenn Topicmaps erst einmal allgegenwärtig sind, werden sie<br />
das GPS-System der Informationswelt sein.<br />
A.2 Konzepte<br />
Dieser Abschnitt beschreibt die Konzepte, die für das Verständnis <strong>von</strong> XML Topicmaps<br />
(XTM) notwendig sind.<br />
Der Zweck einer Topicmap ist es, Wissen über bestimmte Sachverhalte durch ein<br />
darübergelegtes Netz, das diese Sachverhalte kartographiert, zu vermitteln. Eine Topicmap<br />
enthält alle Themen, die für den jeweiligen Sachverhalte wichtig ist, sowie die<br />
Beziehungen zwischen diesen Themen. Die Topicmap ist dabei unabhängig <strong>von</strong> einer<br />
konkreten Implementierung.<br />
Die Grundkonzepte einer Topicmap sind Topics (Themen), Associations (Beziehungen)<br />
und Occurences (Vorkommnisse).<br />
Ein Topic ist eine Ressource innerhalb des Computers, die ein Thema aus der realen<br />
Welt repräsentiert. Beispiele für solche Themen sind das Theaterstück Hamlet, der<br />
Autor William Shakespeare, oder die Beziehung „ist Autor <strong>von</strong>“.<br />
Topics können Namen haben. Sie können auch Occurences besitzen, d.h. Informationsressourcen,<br />
die in einer bestimmten Weise als für ihr Thema relevant angesehen<br />
werden. Außerdem können Topics die Bestandteile <strong>von</strong> Beziehungen (Associations)<br />
sein, wo sie die Rolle eines Teilnehmers einnehmen.<br />
Topics haben also drei Charakteristika: Namen, Occurences und Rollen, die sie in<br />
den Associations spielen. Die Zuweisung dieser Charakteristika ist für einen bestimmten<br />
Kontext oder Scope gültig.<br />
Topicmaps können miteinander verschmolzen werden. Diese Verschmelzung kann<br />
zur Laufzeit auf Initiative eines Benutzers oder einer Applikation erfolgen, oder vom<br />
Autor der Topicmap bei ihrer Erstellung vorgegeben sein.<br />
Der folgende Abschnitt ist eine kurze Einführung, die ein einfaches Beispiel aus<br />
dem Sachgebiet <strong>von</strong> Enzyklopädien benutzt. Anschließend folgt eine detailliertere Übersicht<br />
über die Konzepte <strong>von</strong> Topicmaps.<br />
A.2.1<br />
Kurze Einführung in Topicmaps<br />
Um die Verwendung der Topicmaps, wie sie in dieser Spezifikation definiert sind, zu<br />
verdeutlichen, betrachten wir ein einfaches Beispiel. Angenommen, wir wollen Informationen<br />
über das Thema eines Dokuments so speichern, dass es den Index einer elektronischen<br />
Enzyklopädie aufgenommen werden kann. Dies soll in einer Weise gesche-
A.2. KONZEPTE 79<br />
hen, die unabhängig <strong>von</strong> bestimmten Endgeräten und unabhängig <strong>von</strong> einer bestimmten<br />
Implementierung ist.<br />
Für bestimmte Themen, z.B. William Shakespeare, Ben Johnson, ihre Stücke Hamlet<br />
und Volpone, und die Städte London und Stratford, wollen wir für alle Stellen in<br />
der elektronischen Enzyklopädie - Textpassagen, Bilder oder Tondokumente - festhalten,<br />
wo sie besprochen, abgebildet oder sonstwie erwähnt werden. Wir nennen diese<br />
Vorkommnisse „Occurences“ dieser Themen. Unterschiedliche Occurences können auf<br />
unterschiedliche Weise auf ihr Thema bezug nehmen. Dies wollen wir ebenfalls unterscheiden.<br />
Detaillierte Besprechungen, kurze Erwähnungen und Abbildungen müssen<br />
<strong>von</strong>einander unterschieden werden, damit Benutzer schneller das gesuchte finden können.<br />
Die Enzyklopädie, mit der wir arbeiten, existiert in elektronischer Form, so dass jede<br />
Occurence eines Themas eine elektronische Ressource ist. Somit hat jede Ressource<br />
eine Adresse. (Ohne ins Detail über den Aufbau <strong>von</strong> Adressen zu gehen, definieren wir<br />
eine Adresse als einen Ausdruck, der dem Computer erlaubt, eine Ressource zu lokalisieren.)<br />
Es sind also adressierbare Informationsressourcen.<br />
Die Autoren William Shakespeare und Ben Johnson sind dagegen keine adressierbaren<br />
Ressourcen. Sie sind überhaupt keine elektronischen Dinge, sondern Menschen.<br />
Um die Verbindung zwischen einer Occurence eines Themas und dem Thema selbst zu<br />
repräsentieren, würde man gerne der Reihe nach auf beide zeigen und sagen „an dieser<br />
Stelle wird dieses Thema behandelt“ (oder diesen Vorgang in sein elektronisches Äquivalent<br />
übersetzen, indem man die Adresse der Occurence und die Adresse des Themas<br />
angibt und die Verbindung dazwischen in einer Beschreibungssprache formuliert).<br />
Da nicht alle Themen in elektronischer Form vorliegen, können wir folglich manchmal<br />
keine Adresse dafür angeben. Stattdessen können wir einen elektronischen Ersatz<br />
für das Thema erzeugen. Dieser Ersatz heißt „Topic“. Jedes Topic ist ein Platzhalter<br />
für ein bestimmtes Thema. Man sagt, das Topic vergegenständlicht das Thema oder<br />
macht das Thema für das System greifbar. Das Erstellen eines Topics für ein bestimmtes<br />
Thema erlaubt dem System, die Charakteristika eines Themas zu manipulieren, zu<br />
verarbeiten und zuzuweisen, indem diese Operationen mit dem entsprechenden Topic<br />
vorgenommen werden. Wenn wir eine Adresse für das Thema benötigen, benutzen wir<br />
die Adresse seines Topics, das dem System bekannt ist.<br />
(Da jedes Topic ein Thema repräsentiert und jedes Thema als Vorlage für ein Topic<br />
dienen kann, ist die Unterscheidung manchmal nicht wichtig. Daher werden in diesen<br />
Fällen die Begriffe Topic und Thema gleichwertig benutzt.)<br />
Da die Menge der Indexeinträge eine Art Karte der Enzyklopädie darstellen, die<br />
zeigt, an welcher Stelle bestimmte Themen behandelt werden, nennen wir die elektronische<br />
Entsprechung eines Index eine Topicmap.<br />
Topics, die einige <strong>von</strong> William Shakespeares Werken repräsentieren, könnten in<br />
etwa so aussehen:<br />
<br />
<br />
<br />
Hamlet, Prince of Denmark<br />
<br />
<br />
<br />
<br />
<br />
80 ANHANG A. EINE EINFÜHRUNG IN TO<strong>PI</strong>CMAPS<br />
<br />
<br />
<br />
The Tempest<br />
<br />
<br />
<br />
<br />
<br />
Anhang B<br />
Glossar<br />
Code: Unter Code (auch Quellcode oder Source genannt) wird der eigentliche Programmtext<br />
verstanden, der nach der Kompilierung das fertige Softwaresystem<br />
liefert.<br />
CVS: Abkürzung für „Concurrent Versions System“. Softwaresystem zur Versionskontrolle.<br />
Filter: Festlegung, welche Verbindungsstypen in der visuellen Repräsentation des Netzes<br />
angezeigt werden.<br />
GUI: Abkürzung für „Graphical User Interface“ bzw. „Grafische Benutzerschnittstelle“.<br />
Java: Programmiersprache, die speziell für die Entwicklung <strong>von</strong> plattformunabhängigen<br />
Anwendungen konzipiert wurde. Die Syntax ist an die Sprache C++ angelehnt<br />
und fördert objektorientiertes Design.<br />
Knoten: Knoten repräsentieren in einem Netz einen Gedanken, ein Objekt oder ein<br />
Thema.<br />
Mindmap: Eine Mindmap ist eine grafische Darstellung, die Beziehungen zwischen<br />
verschiedenen Begriffen aufzeigt. Mindmaps eignen sich zum Festhalten <strong>von</strong><br />
Notizen, für Brainstorming-Sitzungen und allgemein für das Zusammenfassen,<br />
Überprüfen und Systematisieren <strong>von</strong> Ideen. Formal gesehen bestehen sie aus beschrifteten<br />
Baumdiagrammen (ggf. mit zusätzlichen Anmerkungen). Wenn die<br />
Begriffe komplexer miteinander verbunden werden können, spricht man auch<br />
<strong>von</strong> semantischen Netzen, wo die mit Linien und Pfeilen dargestellten Beziehungen<br />
zwischen einzelnen Begriffen eine definierte Bedeutung besitzen können.<br />
Musskriterien: Musskriterien sind Kernfunktionen der abzuliefernden Software, die<br />
auf jeden Fall implementiert werden müssen. (→Wunschkriterien).<br />
Netz: Ein Netz bezeichnet bei uns die Gesamtheit <strong>von</strong> Knoten und Verbindungen.<br />
Open Source: Open Source steht für Programme, deren Quellcode veröffentlicht worden<br />
ist. Dadurch kann jeder Interessierte das Funktionieren der Software nachvollziehen.<br />
Open-Source-Programme sind oftmals verbunden mit einer freien Lizenz,<br />
so dass Außenstehende Veränderungen vornehmen oder auf bestehenden<br />
Programmen basierende Anwendungen entwickeln können.<br />
81
82 ANHANG B. GLOSSAR<br />
<strong>Pflichtenheft</strong>: Das <strong>Pflichtenheft</strong> spezifiziert verbindlich die genaue Aufgabenstellung<br />
und die Anforderungen der abzuliefernden Software zwischen dem Auftraggeber<br />
und dem Auftragnehmer.<br />
semantische Netze: Ein semantisches Netz besteht aus Knoten, die Konzepte repräsentieren<br />
und Verbindungen, die Beziehungen zwischen den Knoten herstellen.<br />
Semantische Netze werden zur formalen Wissensrepräsentation genutzt und können<br />
in Form <strong>von</strong> verallgemeinerten Graphen dargestellt werden. Ein mögliches<br />
Format der Speicherung ist der Topicmap-Standard. (→ Mindmap)<br />
Server: Rechner, der durch geeignete Software in der Lage ist, bestimmte Dienste in<br />
einem Netzwerk anzubieten.<br />
Software Engineering Praktikum: Das Software Engineering Praktikum ist ein Praktikum,<br />
das jedes Wintersemester an der TU Darmstadt beginnt und sich über ein<br />
Jahr erstreckt. Reale Unternehmen vergeben, unter Vermittlung und Betreuung<br />
des Fachgebietes <strong>Praktische</strong> <strong>Informatik</strong> des Fachbereiches <strong>Informatik</strong>, reale Aufträge,<br />
die <strong>von</strong> einer Gruppe mit 5-7 Studenten übernommen und ausgeführt werden.<br />
Auf den Software Engineering Messen im November jeden Jahres werden<br />
neue Aufträge vorgestellt bzw. die Ergebnisse der alten Aufgaben präsentiert.<br />
Soll-Zustand: Beschreibt den <strong>von</strong> unserem Auftraggeber erwarteten Zustand zum Zeitpunkt<br />
der Übergabe der Software.<br />
SourceForge: SourceForge 1 ist ein gemeinschaftliches Softwareentwicklungs-Managementsystem,<br />
das ein Portal zur Verfügung stellt, wo Software-Entwickler ihre<br />
Open-Source-Software verwalten und präsentieren können.<br />
TM4J: TM4J ist eine <strong>von</strong> uns verwendete Open-Source-Bibliothek, die auf dem Topicmap-<br />
Standard basiert und uns die Möglichkeit bietet, neben der Topicmap-Repräsentation<br />
auch Dienste zum Im- und Export <strong>von</strong> Topicmaps im XTM-Format verwenden<br />
können.<br />
Topicmap: Ein Topicmap ist ein abstraktes Modell und ein dazu gehöriges in XMLbasiertes<br />
Datenformat zur Formulierung <strong>von</strong> Wissensstrukturen. Topicmaps bestehen<br />
aus so genannten Topics (Themen, Personen, Orte...), Associations und<br />
Occurences (Instanzen <strong>von</strong> oder Dokumente zu Topics). (siehe Anhang A)<br />
UML: Abkürzung für „Unified Modeling Language“. Grafische Beschreibungssprache<br />
zum strukturierten, abstrahierten Design <strong>von</strong> (Software-) Systemen.<br />
URL: Dokumente werden im World Wide Web mittels sog. URLs (Uniform Resource<br />
Locator) adressiert.<br />
Use Case: Textuelle und/oder grafische Beschreibung <strong>von</strong> Anwendungsfällen, die in<br />
einem Softwaresystem auftreten können. Die Menge aller Use Cases sollte die<br />
gesamte Funktionalität einer Software erfassen. Englisch für „Anwendungsfall“;<br />
dies bezeichnet einen Arbeitsschritt, der bei der Behandlung des gesamten Problemkomplexes<br />
als einzelner Teilschritt auftreten kann.<br />
Use Case Modell: Das Use Case Modell stellt die für die Behandlung des Problemkomplexes<br />
nötigen Teilschritte (einzelne Use Cases) und ihre Zusammenhänge<br />
zum einen graphischen und zum anderen verbal (in Tabellen) dar.<br />
1 http://www.sourceforge.net/
83<br />
Verbindung: Eine zwischen zwei Knoten bestehende Beziehung wird durch eine Verbindung<br />
dargestellt.<br />
Visualisierung: Die grafische Darstellung des → Netzes<br />
W3C: Das World Wide Web Consortium (W3C) ist ein im Oktober 1994 gegründeter<br />
Zusammenschluss verschiedener Institutionen, die das World Wide Web weiterentwickeln,<br />
zum Beispiel durch die Verabschiedung <strong>von</strong> Standards für Datenübertragungsprotokolle.<br />
Wir: Dies bezeichnet die Studentengruppe ByteMe, die an dem Software Engineering<br />
Praktikum im Wintersemester 2003/2004 des Fachbereichs <strong>Informatik</strong>, Fachgebiet<br />
<strong>Praktische</strong> <strong>Informatik</strong> der TU Darmstadt teilnimmt.<br />
Wiki: Ein Wiki ist eine im World Wide Web verfügbare Sammlung <strong>von</strong> Seiten, die <strong>von</strong><br />
den Benutzern nicht nur gelesen, sondern auch online geändert werden können.<br />
Wunschkriterien: Wunschkriterien sind Funktionen der abzuliefernden Software, die<br />
vom Auftraggeber erwünscht sind, die <strong>von</strong> der Gruppe jedoch nur bei ausreichender<br />
Zeit implementiert werden können (→ Musskriterien).<br />
XML: Die „Extensible Markup Language“ ist ein Quasi-Standard zur Erstellung strukturierter<br />
Dokumente im World Wide Web, der <strong>von</strong> einer Arbeitsgruppe entwickelt<br />
wurde, die unter der Schirmherrschaft des → W3C steht.<br />
XTM: XTM ist eine Spezifikation, die ein abstraktes Modell und eine → XML-Grammatik<br />
für den Austausch <strong>von</strong> Topicmaps beschreibt. Sie wurde <strong>von</strong> den Mitgliedern der<br />
Topicmaps.Org Authoring Group verfasst.
84 ANHANG B. GLOSSAR
Literaturverzeichnis<br />
[1] Tom DeMarco, Timothy Lister: Waltzing With Bears: Managing Risk on Software<br />
Projects, Dorset House 2003<br />
[2] Alistair Cockburn: Writing Effective Use Cases, Addison-Wesley 2000<br />
[3] Kent Beck: Extreme Programming Explained: Embrace Change, Addison-Wesley<br />
1999<br />
[4] Steve Pepper: The TAO of Topic Maps,<br />
http://www.gca.org/papers/xmleurope2000/papers/s11-01.html<br />
85
Index<br />
Änderbarkeit, 61<br />
Änderungen, 64<br />
Übergangsphase, 54<br />
Übertragbarkeit, 62<br />
öffnen, 17<br />
Abgabetermin, 59<br />
Aktion, 14, 39<br />
Analysierbarkeit, 61<br />
Anforderungs-Inflation, 69<br />
Anforderungsspezifikation, 69<br />
anlegen, 18, 21, 33<br />
Anwendbarkeit, 62<br />
Associations, 78<br />
Außenminister, 66<br />
auflösen, 25<br />
Auftraggeber, 9, 56, 62, 66<br />
Auftragnehmer, 9<br />
Ausfälle, 62<br />
Ausnahmesituationen, 62<br />
bearbeiten, 23, 26, 37<br />
Benutzerfreundlichkeit, 62<br />
Benutzerinterface, 45<br />
Benutzeroberfläche, 62<br />
Bibliotheken, 51<br />
Blickpunkt, 28<br />
Bookmark, 41, 42, 49<br />
ByteMe, 9<br />
Change-Request-Verfahren, 73<br />
CVS, 60, 63, 64<br />
Daedalos, 9, 66<br />
Datenbank, 14, 17<br />
Dialogbox, 45<br />
DIN ISO 9126, 61<br />
Dokumentation, 59, 61, 64<br />
Eclipse, 60<br />
editieren, 21<br />
Effizienz, 63<br />
Eigenschaften, 21, 24, 26<br />
Eigenschaftspanel, 45<br />
Eigenverantwortung, 55<br />
Einarbeitungszeit, 62<br />
einfügen, 21<br />
Einführungsphase, 54<br />
Einfachheit, 55<br />
Entwicklung, 60<br />
Entwicklungsprozess, 53<br />
Entwurfsphase, 54<br />
erstellen, 24<br />
Erstellungsdatum, 21<br />
exportieren, 19<br />
Farbcodierung, 14<br />
Feedback, 55, 56, 58<br />
Fehlerdokumetation, 66<br />
Filter, 28, 31<br />
fokussieren, 28<br />
Formatvorlage, 64<br />
Funktionsumfang, 15<br />
Gedanken, 21<br />
Gerichtsstand, 74<br />
Gewährleistung, 74<br />
Glossar, 81<br />
Google, 11<br />
GraphLayout, 51<br />
GUI, 66<br />
Handbuch, 61<br />
hinzufügen, 35<br />
Implementierung, 61<br />
Information Designer, 15<br />
Information User, 15<br />
Ist-Zustand, 11<br />
Iteration, 56, 66<br />
Iterationsplan, 56<br />
Java, 51<br />
JavaDoc, 65<br />
86
INDEX 87<br />
JUnit, 60<br />
Kernfunktionalität, 68<br />
Klassendesign, 64<br />
Knoten, 11, 12<br />
Knotenmanagement, 21, 47<br />
Kommunikation, 55, 64, 66<br />
Komponenten, 61<br />
Konfigurierbarkeit, 62<br />
Konformität, 62<br />
Konstruktionsphase, 54<br />
Kontrolle, 67<br />
löschen, 21, 22, 36<br />
laden, 34<br />
LaTeX, 60<br />
Lesbarkeit, 64<br />
Lesezeichen, 28<br />
Lizenz, 51<br />
Lizenzvereinbarung, 73<br />
Log4J, 52<br />
LyX, 60<br />
Meilenstein, 56, 59<br />
Meilensteine, 58<br />
Mindmap, 11<br />
Missverständnisse, 66<br />
Modell, 15<br />
Musskriterien, 14<br />
Namensgebung, 65<br />
Namenskonventionen, 65<br />
Navigation, 14, 28, 29<br />
nicht-funktional, 42<br />
Nutzungsrechte, 73<br />
Nutzwert, 62<br />
Occurences, 78<br />
Open Source, 65<br />
OpenOffice, 60<br />
Pair-Programming, 55<br />
Persistenzmanagement, 15, 17, 45<br />
Personal, 70<br />
PersonalBrain, 11<br />
<strong>Pflichtenheft</strong>, 61, 62<br />
Plattformunabhängigkeit, 62<br />
Priorisierung, 42<br />
Programmfehler, 62<br />
Programmierstandard, 65<br />
Programmierstil, 64<br />
Projektumfang, 68<br />
Prototyp, 58<br />
Prozessqualität, 63<br />
Prozessstruktur, 53<br />
Pufferzeiten, 59<br />
Qualitätsmerkmale, 61<br />
Qualitätssicherung, 61<br />
Quelltext, 42, 64<br />
Rücksprachen, 62<br />
Rechtsgrundlagen, 73<br />
Redo, 40, 49<br />
Refactoring, 56<br />
Relation, 21<br />
Release, 56, 63<br />
Richtlinien, 64<br />
Risikomanagement, 67<br />
Rollen, 78<br />
RUP, 53, 54<br />
Schadensersatzansprüche, 74<br />
Schnittstellen, 61<br />
Scope, 78<br />
Sichtweisen, 12<br />
Software, 59<br />
Software Engineering, 9<br />
Soll-Zustand, 12<br />
speichern, 17, 19<br />
Spezifikation, 68<br />
Stabilität, 62<br />
Stil, 64<br />
Style Guide, 64, 65<br />
suchen, 32, 48<br />
Tagesordnung, 53<br />
Teamsitzung, 66<br />
Termine, 58<br />
Tests, 65<br />
TM4J, 51<br />
Together, 60<br />
Toolbar, 45<br />
Tools, 59<br />
Topic, 78<br />
Topic Map, 51<br />
Topicmap, 14, 77<br />
Transparenz, 67<br />
Traversieren, 28<br />
Typenmanagement, 15, 33, 48<br />
Typenprofil, 33
88 INDEX<br />
Umsetzung, 63<br />
Umzug, 70<br />
Undo, 40, 49<br />
Unittests, 65<br />
Use Case, 15<br />
Verbindungen, 11, 12, 24<br />
Verbindungsmanagement, 24, 47<br />
Versionskontrolle, 64<br />
Vertragsverhältnis, 74<br />
Visualisierung, 15, 28, 48<br />
Visualisierungsmodus, 30<br />
W3C, 11<br />
Wartbarkeit, 63<br />
Wartung, 74<br />
Wartungsansprüche, 74<br />
Web, 11<br />
Werkzeuge, 59<br />
Werkzeugleiste, 45<br />
Wiederherstellen, 17<br />
Wiki, 53, 56, 60, 66<br />
Wunschkriterien, 14<br />
XML, 11, 14<br />
XP, 53, 55<br />
XTM, 11, 14, 51<br />
Zeitplan, 68<br />
Zeitplanung, 42, 58<br />
Zielknoten, 27<br />
zusammenführen, 14, 20<br />
Zusicherungen, 74<br />
Zuverlässigkeit, 62
Unterschriftenseite<br />
Das vorstehende <strong>Pflichtenheft</strong> wird <strong>von</strong> der Firma Daedalos Consulting GmbH und der<br />
Studentengruppe ByteMe als Grundlage für das Software-Engineering-Projekt „Visualisierung<br />
und Bearbeitung <strong>von</strong> Informationen in Form semantischer Netze“ anerkannt.<br />
__________________________<br />
Daedalos Consulting GmbH<br />
__________________________<br />
Djukanovic, Sinisa<br />
__________________________<br />
Eifert, Sebastian<br />
__________________________<br />
Orgler, Matthias<br />
__________________________<br />
Stroh, Kai<br />
__________________________<br />
Urvoy, Carole<br />
__________________________<br />
Vekic, Mario<br />
89