Grundkurs Software-Engineering mit UML

Stephan Kleuker

Grundkurs Software- Engineering mit UMLDer pragmatische Weg zu erfolgreichen Softwareprojekten

4. Auflage

Stephan KleukerFakultät Ingenieurwissenschaften und InformatikHochschule OsnabrückOsnabrück, Deutschland

ISBN 978-3-658-19968-5 ISBN 978-3-658-19969-2 (eBook)https://doi.org/10.1007/978-3-658-19969-2

Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detail-lierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar.

Springer Vieweg© Springer Fachmedien Wiesbaden GmbH 2008, 2011, 2013, 2018Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Jede Verwertung, die nicht ausdrücklich vom Urheberrechtsgesetz zugelassen ist, bedarf der vorherigen Zustimmung des Verlags. Das gilt insbesondere für Vervielfältigungen, Bearbeitungen, Übersetzungen, Mikroverfilmungen und die Einspeicherung und Verar-beitung in elektronischen Systemen.Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Werk berechtigt auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne der Warenzeichen- und Markenschutz-Gesetzgebung als frei zu betrachten wären und daher von jedermann benutzt werden dürften.Der Verlag, die Autoren und die Herausgeber gehen davon aus, dass die Angaben und Informationen in diesem Werk zum Zeitpunkt der Veröffentlichung vollständig und korrekt sind. Weder der Verlag, noch die Autoren oder die Herausgeber übernehmen, ausdrücklich oder implizit, Gewähr für den Inhalt des Werkes, etwaige Fehler oder Äußerungen. Der Verlag bleibt im Hinblick auf geografische Zuordnungen und Gebietsbezeichnungen in veröf-fentlichten Karten und Institutionsadressen neutral.

Gedruckt auf säurefreiem und chlorfrei gebleichtem Papier

Springer Vieweg ist Teil von Springer NatureDie eingetragene Gesellschaft ist Springer Fachmedien Wiesbaden GmbHDie Anschrift der Gesellschaft ist: Abraham-Lincoln-Str. 46, 65189 Wiesbaden, Germany

V

Vorwort

Das Ziel dieses Buches ist es, ein Meilenstein in der systematischen Ausbildung von Software- Entwicklern zu sein und Lösungsansätze für die unterschiedlichen Herausforde-rungen des Software-Engineerings zu zeigen. In einer Zeit, in der immer neue Technolo-gien entwickelt werden, zeigt dieses Buch die Fundamente der Entwicklung, die sich langfristig als ingenieurmäßige Vorgehensweisen etabliert haben. Erfahrenen Entwicklern und anderen an IT-Projekten beteiligten Personen kann dieses Buch helfen, sich intensiver mit aktuellen Ansätzen zu beschäftigen und so an der kontinuierlichen Weiterentwicklung des Software-Engineerings teilzunehmen. Für die Lektüre des Buches ist es sinnvoll, einen ersten Grundkurs in einer objektorientierten Programmiersprache wie Java, C# oder C++ abgeschlossen zu haben, da die grundlegenden Begriffe wie Klasse, Objekt, Verer-bung und Polymorphie nur kurz aufgefrischt werden.

Der Inhalt dieses Buches basiert auf den Erfahrungen des Autors als Systemanalytiker und Systemberater für recht unterschiedliche komplexe Software-Systeme, die in ver-schiedenen Vorlesungen zunächst an der Fachhochschule Nordakademie in Elmshorn und dann an der Fachhochschule Wiesbaden erfolgreich an Informatik-Studierende weiterge-geben wurden. Den beteiligten Studierenden sei auf diese Weise besonders gedankt, da sie mit ihren Ideen und vielfältigen Fragestellungen sehr zur Abrundung der Veranstaltungen und dieses Buches beigetragen haben.

Sie haben mir weiterhin gezeigt, dass der Spaß an der Informatik häufig mit dem Spaß an selbst entwickelter Software zusammenhängt, die auf Basis gelernter Grundlagen zusammen mit der individuellen Kreativität zum Laufen gebracht wird. Software- Engineering ist in diesem Zusammenhang ein Hilfsmittel, das keine Energie in das erneute Entwickeln bereits etablierter Lösungen fließen lässt, sondern die Kreativität für neue Her-ausforderungen kanalisiert.

Software-Engineering wird dabei als die Wissenschaft der systematischen Entwicklung von Software, beginnend bei den Anforderungen bis zur Abnahme des fertigen Produkts und der anschließenden Wartungsphase definiert, deren Ziel die Verknüpfung etablierter Lösungs-ansätze mit neuen Technologien ist. Als wichtiges Hilfsmittel wird dazu in diesem Buch die Unified Modeling Language (UML) vorgestellt, die es ermöglicht, Entwicklungsergebnisse

VI

in solch einer Form festzuhalten, dass sie leicht von anderen IT-Professionals gelesen und weiter bearbeitet werden können.

Das Buch folgt dem Ablauf eines IT-Projektes, ausgehend von den Anforderungen und der besonderen Herausforderung, mit dem Kunden über das gleiche Ziel zu reden, über die erste Modellierung zur systematischen Erfassung dieser Anforderungen. Die schrittweise Optimierung dieser Modelle und die unterschiedlichen Randbedingungen der Implemen-tierung werden diskutiert. Es wird gezeigt, wie Ergebnisse so aufbereitet werden, dass andere Entwickler die Ideen des eigentlichen Autoren nachvollziehen können. Generell stehen dabei die ingenieurmäßigen Überlegungen, wie man Erfahrungen aus erfolgreichen Projekten auf die Anwendbarkeit im eigenen Projekt überprüfen und dann auch übertra-gen kann, im Mittelpunkt. Dem querschnittlichen Thema Qualitätssicherung ist ein eige-nes Kapitel gewidmet.

Aus meinen Praxiserfahrungen folgt auch, dass eine gute Software-Entwicklung zwar die Grundlage eines erfolgreichen Projekts ist, es aber vielfältige Randbedingungen gibt, die von der Entwicklungsumgebung bis zum Miteinander der Projektmitglieder gehen, die den Projekterfolg beeinflussen. Diese Randbedingungen werden in diesem Buch im abschließenden Kapitel diskutiert.

Zu jedem Kapitel gibt es eine Liste von möglichen Risiken, die man zur Überprüfung eigener Projekte nutzen sollte. Jedes Kapitel schließt mit zwei Arten von Aufgaben ab. Im ersten Aufgabenteil werden Wiederholungsfragen gestellt, die man nach intensiver Lektüre des vorangegangenen Kapitels beantworten können sollte. Die Lösungen zu diesen Aufga-ben kann man selbst im Buch nachschlagen. Der zweite Aufgabenteil umfasst Übungsauf-gaben, in denen man gezielt das angelesene Wissen anwenden soll. Diese Übungsaufgaben sind in verschiedenen Lehrveranstaltungen erfolgreich eingesetzt worden.

Die Bilder, Spezifikationen, Programme und Lösungsvorschläge zu den Aufgaben die-ses Buches sowie weitere Information können von der Web-Seite

http://home.edvsz.hs-osnabrueck.de/skleuker/SoftwareEngineering.htmloder den Informationsseiten des Verlages zum Buch herunter geladen und unter

Berücksichtigung des Copyrights genutzt werden.In diesem Buch benutze ich verkürzend ohne Hintergedanken bei Einzahlen wie Leser

oder Entwickler die männliche Form. Natürlich möchte ich mit diesem Buch auch die weiblichen Leser Leserinnen ansprechen.

Zum Abschluss wünsche ich Ihnen viel Spaß beim Lesen. Konstruktive Kritik wird immer angenommen. Bedenken Sie, dass das Lesen nur ein Teil des Lernens ist. Ähnlich wie in diesem Buch kleine Beispiele eingestreut sind, um einzelne Details zu klären, sollten Sie sich mit den hier vorgestellten Ideen hinsetzen und meine, aber vor allem selbst konstruierte Bei-spiele durchspielen. Sie runden das Verständnis des Themas wesentlich ab.

Wiesbaden, Mai 2008 Stephan Kleuker

Vorwort

VII

Ergänzung zur zweiten Auflage

Neben dem fast immer sehr positiven Feedback zur ersten Auflage, habe ich viele Anre-gungen zur Erweiterung des Buches und zur Korrektur einiger Tippfehler erhalten. Neben den Studierenden der Hochschule Osnabrück und anderer Hochschulen, gilt mein beson-derer Dank für Anregungen meinen Kollegen Prof. Dr. Grit Behrens, Prof. Dr. Theo Ger-vens, Ralf Neugebauer, Prof. Dr. Andreas Terstegge, Prof. Dr. Frank Thiesing und Prof. Dr. Michael Uelschen.

Es konnten zwar nicht alle Erweiterungswünsche berücksichtigt werden, dafür wurden aber dann einige Verweise auf weitere Ansätze und Vertiefungsmöglichkeiten ergänzt, damit der Umfang dieses Buches nicht gesprengt wird. Hinweise auf gewünschte Ergän-zungen, unklare Formulierungen und Tippfehler werden immer gerne entgegen genom-men. Die Korrekturen sind auf der Web-Seite zum Buch online erhältlich.

Für die kompetente und freundliche Betreuung der zweiten Auflage möchte ich mich bei Dr. Christel Roß und den weiteren Mitarbeitern des Verlags Vieweg+Teubner bedanken.

Osnabrück, September 2010 Stephan Kleuker

IX

Ergänzung zur dritten Auflage

Aus dem weiteren Feedback von Lesern und aktuellen Trends der Software-Technologie sind kleine Ergänzungen und Konkretisierungen in das Buch eingeflossen. Gerade agile Methoden, die ohnehin Teil des Buches waren, sind noch weiter an verschiedenen Stellen im Buch, neu auch bei der Aufwandsschätzung, verankert. Im Kapitel zu Design-Pattern wird noch intensiver betont, dass Varianten von Pattern existieren und dass ihre Nutzung immer mehr in die Standardentwicklung z. B. durch die Nutzung von Annotationen einfließt.

Für die kompetente und freundliche Betreuung der dritten Auflage möchte ich mich bei Andrea Broßler, Bernd Hansemann, Maren Mithöfer und den weiteren Mitarbeitern des Verlags Springer Vieweg sowie Sorina Moosdorf und Anne Strohbach bedanken.

Osnabrück, Mai 2013 Stephan Kleuker

XI

Ergänzung zur vierten Auflage

Ziel dieses Buches bleibt es weiterhin, einen zentralen sinnvollen Weg von der ersten Idee einer Software bis zur erfolgreichen und wartbaren Umsetzung zu zeigen. Natürlich gibt es auch andere Ansätze, die zum Erfolg führen können. Einige dieser Ideen, die der Autor neben seiner Beratertätigkeit in der persönlichen Betreuung von mehr als 100 Abschluss-arbeiten in IT-Unternehmen kennenlernen konnte, fließen zumindest in kompakten Über-blicken als Ergänzungen in diese Auflage ein.

Deshalb sei neben den gesamten Unterstützern aus dem Verlag explizit den vielen betrieblichen Betreuern und Studierenden gedankt, die mir ihre Wege zur Umsetzung von Software-Projekten gezeigt und dabei oft Teile des Buches genutzt haben. Einige dieser Wege werden in diesem Buch kritisch analysiert.

Osnabrück, September 2017 Stephan Kleuker

XIII

Danksagung

Ein Buch kann nicht von einer Person alleine verwirklicht werden. Zu einer gelungenen Entstehung tragen viele Personen in unterschiedlichen Rollen bei, denen ich hier danken möchte.

Mein erster Dank geht an meine Ehefrau Frau Dr. Cheryl Kleuker, die nicht nur die erste Kontrolle der Inhalte und Texte vorgenommen hat, sondern mir erlaubte, einen Teil der ohnehin zu geringen Zeit für die Familie in dieses Buchprojekt zu stecken.

Dank gilt meinem Kollegen Prof. Dr. Sven Eric Panitz von der Fachhochschule Wies-baden, der sich eine Vorversion dieses Buches kritisch durchgelesen hat und interessante Anregungen lieferte. Viele Studierende, die Veranstaltungen zum Thema Software- Entwicklung bei mir gehört haben, trugen durch ihre Fragen und Probleme wesentlich zu der Herangehensweise an die Themen des Buches bei.

Abschließend sei Sybille Thelen, Günter Schulz, Andrea Broßler, Albrecht Weis und den weiteren Mitarbeitern des Verlags Vieweg+Teubner für die konstruktive Mitarbeit gedankt, die dieses Buchprojekt erst ermöglichten.

XV

Inhaltsverzeichnis

1 Was ist Software-Engineering? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2 Prozessmodellierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 2.1 Unternehmensprozesse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 2.2 Prozessmodellierung mit Aktivitätsdiagrammen . . . . . . . . . . . . . . . . . . . . . 10 2.3 Risikomanagement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 2.4 Risikoanalyse Prozessmodellierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 2.5 Anmerkungen zur Praxis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 2.6 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3 Vorgehensmodelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 3.1 Phasen der Software-Entwicklung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 3.2 Wasserfallmodell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 3.3 Prototypische Entwicklung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 3.4 Iterative Entwicklung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 3.5 Iterativ-inkrementelle Entwicklung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 3.6 Allgemeines V-Modell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 3.7 Das V-Modell der Bundesrepublik Deutschland . . . . . . . . . . . . . . . . . . . . . 34 3.8 Rational Unified Process . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 3.9 Agile Vorgehensmodelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 3.10 Scrum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 3.11 Extreme Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 3.12 Test Driven und Behaviour Driven Development . . . . . . . . . . . . . . . . . . . . 49 3.13 Risikoanalyse Vorgehensmodell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 3.14 Anmerkungen zur Praxis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 3.15 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

XVI

4 Anforderungsanalyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 4.1 Stakeholder und Ziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 4.2 Klärung der Hauptfunktionalität (Use Cases) . . . . . . . . . . . . . . . . . . . . . . . 62 4.3 Beschreibung typischer und alternativer Abläufe . . . . . . . . . . . . . . . . . . . . 71 4.4 Ableitung funktionaler Anforderungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 4.5 Nicht-funktionale Anforderungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 4.6 Lasten- und Pflichtenheft . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 4.7 Varianten und ergänzende Ansätze der Anforderungsanalyse . . . . . . . . . . . 86 4.8 Risikoanalyse Anforderungsanalyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 4.9 Anmerkungen zur Praxis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 4.10 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

5 Grobdesign . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 5.1 Systemarchitektur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 5.2 Ableitung von grundlegenden Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 5.3 Ableitung von Methoden und Kontrollklassen . . . . . . . . . . . . . . . . . . . . . . 101 5.4 Validierung mit Sequenzdiagrammen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 5.5 Überlegungen zur Oberflächenentwicklung. . . . . . . . . . . . . . . . . . . . . . . . . 116 5.6 Anforderungsverfolgung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118 5.7 Risikoanalyse Grobdesign . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120 5.8 Anmerkungen zur Praxis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 5.9 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

6 Vom Klassendiagramm zum Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 6.1 CASE-Werkzeuge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126 6.2 Übersetzung einzelner Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 6.3 Übersetzung von Assoziationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131 6.4 Spezielle Arten der Objektzugehörigkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . 137 6.5 Aufbau einer Software-Architektur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142 6.6 Weitere Schritte zum lauffähigen Programm . . . . . . . . . . . . . . . . . . . . . . . . 147 6.7 Risikoanalyse Klassendiagrammübersetzung . . . . . . . . . . . . . . . . . . . . . . . 151 6.8 Anmerkungen zur Praxis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 6.9 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155

7 Konkretisierungen im Feindesign . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157 7.1 Zustandsdiagramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158 7.2 Object Constraint Language . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167 7.3 Risikoanalyse Feindesign . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 7.4 Anmerkungen zur Praxis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 7.5 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176

Inhaltsverzeichnis

XVII

8 Optimierung des Designmodells . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179 8.1 Design im Kleinen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180 8.2 Model View Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188 8.3 Vorstellung einiger GoF-Pattern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 8.4 Abschlussbemerkungen zu Pattern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220 8.5 Risikoanalyse Design-Optimierungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222 8.6 Anmerkungen zur Praxis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223 8.7 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227

9 Implementierungsaspekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229 9.1 Einfluss nicht-funktionaler Anforderungen . . . . . . . . . . . . . . . . . . . . . . . . . 230 9.2 Verteilte Systeme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232 9.3 Grundideen von XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236 9.4 Programmbibliotheken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237 9.5 Komponenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239 9.6 Frameworks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244 9.7 Persistente Datenhaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249 9.8 Annotationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252 9.9 Domain Specific Languages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256 9.10 Model Driven Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258 9.11 Refactoring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260 9.12 Konkretes Beispiel: JSF, JPA, CDI und EJB . . . . . . . . . . . . . . . . . . . . . . . . 263 9.13 Risikoanalyse Implementierungsaspekte . . . . . . . . . . . . . . . . . . . . . . . . . . . 277 9.14 Anmerkungen zur Praxis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278 9.15 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281

10 Oberflächengestaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283 10.1 Hintergründe der Oberflächengestaltung . . . . . . . . . . . . . . . . . . . . . . . . . . 283 10.2 Konkretisierung des Nutzbarkeitsbegriffs . . . . . . . . . . . . . . . . . . . . . . . . . 285 10.3 Berücksichtigung der Ergonomie im Software-Entwicklungsprozess . . . . 290 10.4 Prüfung der Nutzbarkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292 10.5 Risikoanalyse Oberflächengestaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295 10.6 Anmerkungen zur Praxis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296 10.7 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297

11 Qualitätssicherung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299 11.1 Formale Korrektheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300 11.2 Zusicherungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302 11.3 Unit-Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305 11.4 Testbarkeit von Systemen herstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313 11.5 Äquivalenzklassentests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317

XVIII

11.6 Kontrollflussbezogene Testverfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325 11.7 Testarten und Testumfeld . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332 11.8 Metriken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337 11.9 Konstruktive Qualitätssicherung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342 11.10 Manuelle Prüfverfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343 11.11 Risikoanalyse Qualitätssicherung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346 11.12 Anmerkungen zur Praxis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347 11.13 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353

12 Umfeld der Software-Entwicklung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355 12.1 Versionsmanagement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356 12.2 Build-Management . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361 12.3 Grundlagen der Projektplanung und -verfolgung . . . . . . . . . . . . . . . . . . . 366 12.4 Aufwandsschätzung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375 12.5 Qualitätsmanagement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386 12.6 Der Mensch im Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393 12.7 Risikoanalyse Projektumfeld . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399 12.8 Anmerkungen zur Praxis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400 12.9 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403

A UML-Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405

Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411

Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413

Inhaltsverzeichnis