Table Of ContentPeter Zöller-Greer
Softwareengineering für
Ingenieure und Informatiker
Aus dem Programm
Informationstechnik
Kommunikationstechnik
von M. Meyer
Signalverarbeitung
von M. Meyer
Grundlagen der Informationstechnik
von M. Meyer
Softwareengineering für Ingenieure
und Informatiker
von P. Zöller-Greer
Informatik für Ingenieure kompakt
herausgegeben von K. Bruns und P. Klimsa
Informationstechnik kompakt
herausgegeben von O. Mildenberger
Mobilfunknetze
von M. Duque-Ant6n
Datenübertragung
von P. Welzel
Telekommunikation
von D. Conrads
Von Handy, Glasfaser und Internet
von W. Glaser
vieweg __________________ _''
Peter Zöller-Greer
Softwareengineering für
Ingenieure und Informatiker
Planung, Entwurf und Implementierung
Mit 198 Abbildungen
Herausgegeben von Otto Mildenberger
~
vleweg
Studium Technik
Die Deutsche Bibliothek - CIP-Einheitsaufnahme
Ein Titeldatensatz für diese Publikation ist bei
Der Deutschen Bibliothek erhältlich.
Herausgeber: Prof. Dr.-Ing. atto Mildenberger lehrte an der Fachhochschule Wiesbaden in den
Fachbereichen Elektrotechnik und Informatik.
1. Auflage August 2002
Alle Rechte vorbehalten
© Friedr. Vieweg & Sohn Verlags gesellschaft mbH, Braunschweig/Wiesbaden, 2002
Der Vieweg Verlag ist ein Unternehmen der Fachverlagsgruppe BertelsmannSpringer.
www.vieweg.de
Das Werk einschließlich aller seiner Teile ist urheberrechtlich geSChützt.
Jede Verwertung außerhalb der engen Grenzen des Urheberrechts
gesetzes ist ohne Zustimmung des Verlags unzulässig und strafbar. Das
gilt insbesondere für Vervielfältigungen, Übersetzungen, Mikrover
filmungen und die Einspeicherung und Verarbeitung in elektronischen
Systemen.
Umschlaggestaltung: Ulrike Weigel, www.CorporateDesignGroup.de
Gedruckt auf säurefreiem und chlorfrei gebleichtem Papier.
ISBN 978-3-528-03939-4 ISBN 978-3-663-01465-2 (eBook)
DOI 10.1007/978-3-663-01465-2
v
Vorwort
Seit der Softwarekrise der 60er Jahre wurde für die Entwicklung von Softwaresystemen der Ruf
nach besser planbarem, systematischem Vorgehen laut. Nach und nach hat sich daraus das
heutige Softwareengineering entwickelt. Weitgehend standardisiert, liefert es für alle an der
Entwicklung Beteiligten methodische Ansätze zur effektiven und ökonomischen Softwareerstd
lung. Trotz der häufigen Kurzlebigkeit von Softwaren haben sich in jüngster Zeit die Methoden
zu ihrer Erzeugung stabilisiert. Noch vor wenigen Jahren waren viele verschiedene Ansätze in
Konkurrenz, doch mit der Einführung der Unified Modeling Language (UML) hat sich eine
Methode etabliert, die alle anderen Konkurrenten weit hinter sich gelassen hat. Es besteht daher
Aussicht, dass die in diesem Buch beschrieben Methoden und Verfahren für die nächsten Jahre
aktuell bleiben, da deren Akzeptanz und Verbreitung sehr groß ist.
Eine Besonderheit dieses Buches besteht darin, dass es sowohl die Zielgruppe der Ingenieure
als auch die der Informatiker im Auge hat. So wurden in Kapitel I eine allgemeine Einführung
gegeben und in Kapitel 2 die wichtigsten Phasenmodelle des Softwareengineerings vorgestellt.
Neu ist dabei ein Vorgehensmodell mit Aufwandsabschätzung für die Entwicklung von Multi
Media Anwendungen. Im Bereich Teachware und Internet werden solche Anwendungspro
gramme immer wichtiger. Daran schließt sich die ausführliche Planung eines Softwareprojekts
in Kapitel 3 an. Hier werden unter anderem methodische Ansätze zur Erstellung eines Pflich
tenhefts vorgestellt und an Beispielen erläutert. Kapitel 4 nimmt breiten Raum ein, da hier die
für ein gutes Gelingen eines Softwareprojekts so wichtige Entwurfsphase ausführlich beschre
ben wird. Neben der heute wohl wichtigsten ModelIierungsmethode UML werden auch die
klassischen Ansätze wie Entity-Relationship-Diagramme (ERD), Coad & Yourdon etc. betrach
tet. Auch wird die Umsetzung objektorientierter Modelle in relationale Datenbankschemata
beschrieben und an Beispielen erläutert. Ebenfalls recht umfangreich ist Kapitel 5, wo die Imp
lementierung der Datenmodelle vorgenommen wird. Es werden auf diverse Prinzipien hierzu
eingegangen und an Beispielen erläutert. Die Beispiele sind vornehmlich in Visual Basic for
Applications (VBA) innerhalb MS-Access® dargeboten. Auch ohne Kenntnis dieser verbreite
ten Entwicklungssprache kann den dargestellten Implementierungsprinzipien gefolgt werden,
da die wichtigsten benutzten Befehle erläutert werden. Zudem besitzt VBA den Vorteil, dass es
sich dabei um eine relativ unkryptische Sprache handelt, die gut lesbar und selbstsprechend ist.
Eine weitere, standardisierte Sprache für Datenbankentwicklungen ist die Standard Query Lan
guage (SQL), auf die ebenfalls kurz eingegangen wird. Auch SQL ist selbstsprechend und
leicht erlernbar. Kapitel 6 beschäftigt sich schließlich mit einigen gängigen Methoden zum
Testen der entwickelten Software. Die Kapitel I bis 6 sind sowohl für die Zielgruppe der Inge
nieure wie auch die der Informatiker gleichermaßen wichtig, denn sie enthalten allgemeine,
grundlegende Prinzipien des Softwareengineerings. In Kapitel 7 werden dann spezifische Prob
lemfelder behandelt. So wird hier über die Entwicklung von betrieblichen Informationssys1e
men, Realzeitanwendungen, Scientific Computing, Expertensystemen, Fuzzy Systemen, Neuro
nalen Netzen und Internetanwendungen gesprochen und auf die jeweiligen Besonderheiten bei
der Erstellung entsprechender Anwendungen eingegangen. Auch dies wird überwiegend wieder
an praktischen Beispielen demonstriert.
Die Art und Weise der Darstellung des vorliegenden Buches ist so gewählt, dass es sowohl für
Praktiker als auch für Studierende geeignet ist. Es werden keine speziellen Vorkenntnisse vor
ausgesetzt und das Buch kann sowohl im Selbststudium wie auch begleitend zum Unterricht
VI
eingesetzt werden. Zudem kann es als Nachschlagewerk dienen. Anhand der ausführlichen
Beispiele werden die behandelten Themen vertieft und ihr Bezug zur Praxis dargelegt.
Auf der Web-Seite http://www.th-frankfurt.de/-zoellerg sind Links zu den Quellecodes einiger
in diesem Buch enthaltenen Beispielprogramme vorhanden.
Dank gilt den Studenten Georg Gebert und Gerardo Thierauf, welche im Rahmen eines Ü
bungsprojekts im Studiengang Informatik der FH Frankfurt am Main die Software ,,Lizenzab
rechnung" entwickelten, die als Beispiel des Öfteren herangezogen wird. Sie erstellten auch das
Benutzerhandbuch hierfür, welches dem Anhang zu entnehmen ist. Weiterer Dank geht an
meine Diplomanden Debesay Neberay und Jan Haghnazarian, welche die php-Skripte der
Internetanwendungsbeispiele aus Kapitel 7 entwickelten, sowie an die Teilnehmer der Projekt
veranstaltung Multi Media im WS 200112002, welche die technische Realisierung der ebenfalls
in Kapitel 7 beschriebenen virtuellen Vorlesung über Künstliche Intelligenz durchgeführt ha
ben.
Ganz besonderer Dank gilt meiner lieben Frau Diana, die mich mit großem Verständnis viele
Stunden für das Zustandekommen des vorliegenden Buches entbehren musste. Mein Dank gilt
auch dem Vieweg Verlag und insbesondere dem Herausgeber Herrn Prof. Dr. Otto Mildenber
ger, ohne die das Buch nicht zustande gekommen wäre.
Peter Zöller-Greer Im Juni 2002.
VII
Inhaltsverzeichnis
1 Einführung ......................................................................................................................... 1
1.1 Die Software-Krise: Murphys Gesetze und der Lebenszyklus einer Software ............ 1
1.2 Methodische Ansätze ................................................................................................... 2
2 Phasenmodelle .................................................................................................................... 5
2.1 Wozu Phasenmodelle? ................................................................................................ 5
2.2 Das klassische Wasserfallmodell ................................................................................. 5
2.3 Tugend aus der Not: Spiralmodell und Prototyping ................................................... 14
2.4 Entwicklung von Multi-Media-Anwendungen ........................................................... 16
2.4.1 Planungs-und Entwicklungsphasen ................................................................. 17
2.5 Weitere Ansätze ......................................................................................................... 27
2.5.1 Das V-Modell ................................................................................................... 27
2.5.2 Das Ontogenese-Modell ................................................................................... 28
2.6 Werkzeuge, CASE ..................................................................................................... 28
3 Planung eines Softwareprojekts ..................................................................................... 30
3.1 Erste Analyse des Problems ....................................................................................... 30
3.2 Verfeinerte Analyse des Problems: Erstellung des Pflichtenhefts .............................. 33
3.2.1 Die SAlSD-Methode ........................................................................................ 35
3.2.2 Analyse Ist/Soll-Zustände ................................................................................. 39
3.2.3 Vorhandene Hard/Software .............................................................................. 48
3.2.4 Szenarien und Zustandsdiagramme .................................................................. 48
3.2.5 Semantische Datenmodellierung ...................................................................... 49
3.2.6 Projektplan ....................................................................................................... 50
4 Entwurf der zu entwickelnden Software ....................................................................... 51
4.1 Grundlegende Begriffe ............................................................................................... 51
4.1.1 Relationen, Operationen, Normalformen .......................................................... 51
4.1.2 Objekte, Klassen und Instanzen ........................................................................ 60
4.1.3 Entitäten, Attribute und Beziehungen ............................................................... 63
4.1.4 Kardinalitäten ................................................................................................... 65
4.2 Datenmodellierung ..................................................................................................... 66
4.2.1 Relationale Ansätze .......................................................................................... 66
4.2.2 Objektorientierte Ansätze ................................................................................. 90
VIII
5 Implementierung ............................................................................................................ 120
5.1 Klassenschemata und Generalisierungen ................................................................. 120
5.2 Tabellenobjekte, Beziehungsklassen ........................................................................ 126
5.2.1 SQL .................................................................................................................. 126
5.2.2 Objektorientierte Prinzipien ............................................................................. 141
5.3 Dialogobjekte, Screens ............................................................................................ 153
5.3.1 Navigationsmasken .......................................................................................... 155
5.1.1 Eingabemasken ................................................................................................ 163
5.4 Ausgabe-Objekte, Reports ....................................................................................... 185
5.4.1 Ausgaben rur den Bildschirm/Drucker. ............................................................ 186
5.4.2 Ausgaben in eine externe Datei ........................................................................ 200
5.4.3 Maskenhierarchiedarstellungen ........................................................................ 214
6 Testen und Installieren .................................................................................................. 216
6.1 Fehlerursachen ......................................................................................................... 216
6.2 Testmethoden ........................................................................................................... 218
6.2.1 Dynamische Testverfahren ............................................................................... 220
6.2.2 Statische Testverfahren .................................................................................... 225
6.3 Anwendertests .......................................................................................................... 226
6.4 Installation ............................................................................................................... 226
6.5 Einruhrung und Schulung. ........................................................................................ 227
6.6 Wartung ................................................................................................................... 227
7 Spezielle Gebiete des Softwareengineering .................................................................. 229
7.1 Betriebliche Informations systeme ............................................................................ 229
7.2 Realzeitanwendungen .............................................................................................. 236
7.2.1 Komplexität von Algorithmen. ......................................................................... 237
7.2.2 Planung und Entwurf von Realzeitanwendungen ............................................. 241
7.3 Scientific Computing ............................................................................................... 248
7.4 Entwicklung von Expertensystemen ........................................................................ 253
7.5 Entwicklung von Fuzzy-Systemen ........................................................................... 266
7.6 Lernfähige Systeme (neuronale Netze) .................................................................... 274
7.7 Internetanwendungen ............................................................................................... 297
7.7.1 Datenbankzugriffe über das Internet ................................................................ 297
7.7.2 eLearning-Anwendungen ................................................................................. 305
Anhang (Lizenzabrechnungssystem: Benutzerhandbuch) ....................................................... 311
Literaturverzeichnis .............................................................................................................. 328
Sachwortverzeichnis .............................................................................................................. 329
1 Einführung
1.1 Die Software-Krise: Murphys Gesetze und der Lebenszyklus
einer Software
Als zu Beginn der 60er Jahre des 20. Jahrhunderts Computer in jedem größeren Industrieunter
nehmen Einzug hielten, steckte die systematische Entwicklung von darauf laufender Software
noch in den Kinderschuhen. Software wurde in der Regel in einem zentralen Rechenzentrum
für umliegende Fachabteilungen von einem Spezialistenteam entwickelt. Wobei der Ausdruck
"Team" hier nicht unbedingt bedeutete, dass mehrere Personen am gleichen Projekt zusammen
arbeiteten, sondern es war in der Regel so, dass jeder ProgrJmmierer komplett ein Programm
oder zumindest einen abgegrenzten Programmteil entwick;lt~, der relativ isoliert gewesen ist.
Hinzu kam die Tatsache, dass solche Programme nicht in großem Umfang geplant wurden,
sondern die meisten Programmierer begannen häufig einfach mit der Programmierung loszule
gen, noch bevor genau klar war, was überhaupt der spätere Benutzer wollte. Dieses relativ
unsystematische Vorgehen erzeugte natürlich hohen Entwicklungsaufwand und damit Unsi
cherheit hinsichtlich der Kosten und der Entwicklungsdauer.
Schon bald wurde die Notwendigkeit einer besseren Planung von Software erkannt und es wur
de begonnen, sog. Pflichtenhefte zu schreiben. Diese enthielten mehr oder weniger präzise die
jeweiligen Anforderungen an die zu entwickelnde Software. Das Aussehen solcher Pflichten
hefte war allerdings keinem bestimmten Standard unterworfen und dadurch war es dem jeweili
gen Autor überlassen, wie genau das Problem und evtl. Lösungen beschrieben wurden.
Zu dieser Zeit wurde auch dazu übergegangen, die Planung der Software von ihrer Kodierung
zu trennen. Sogenannte Systemanalytiker hatten die Aufgabe, das Problem zu analysieren und
eine algorithmische Lösung zu entwickeln, welche dann einem Programmierer zum Zwecke der
Kodierung übergeben wurde. Im kommerziell-administrativen Bereich waren dies auch wirk
lich verschiedene Personen, während im naturwissenschaftlich-technischen Bereich Systemana
lyse und Programmierung häufig von ein- und derselben Person durchgeführt wurden. Dies
machte insofern Sinn, als hier die Probleme oft so kompliziert waren, dass dies die Kommuni
kation zwischen Analytiker und Programmierer sehr erschwert hätte.
Trotz dieser Anstrengungen war der gesamte Entwicklungszyklus einer Software noch von zu
vielen Unsicherheitsfaktoren begleitet. Die abgeschätzten Entwicklungskosten wurden regel
mäßig erheblich überschritten, ebenso wie die geplanten Entwicklungszeiten. Es war festzustel
len, dass dies in erster Linie an mangelhafter Planung lag. Planungsfehler wurden erst sehr spät
entdeckt und waren nur unter erheblichem Aufwand zu korrigieren. Außerdem wiesen die
Pflichtenhefte häufig Inkonsistenzen auf, die zunächst nicht bemerkt wurden. Diese Situationen
bezeichnet man heute als die Softwarekrise der 60er Jahre.
Um aus dieser Krise herauszukommen wurden einige Anstrengungen unternommen. Zunächst
wurde die Planungsphase versucht zu standardisieren, wobei ingenieurwissenschaftliche Me
thoden als Vorbild dienen sollten. Die Grundidee dabei war, gerade besagte Planungsphase
systematisch zu erarbeiten und methodische Ansätze zu entwickeln. Man erhoffte sich dadurch
P. Zöller-Greer, Softwareengineering für Ingenieure und Informatiker
© Friedr. Vieweg & Sohn Verlagsgesellchaft mbH, Braunschweig/Wiesbaden 2002
2 1 Einführung
weniger Planungsfehler zu machen und eine Kodierung zu ermöglichen, die ein Programm
liefert, welches die geforderten Spezifikationen so gut wie möglich erfüllt.
EntwickJungsaufwand
Ideal
-
Real
....
Zeit
Bild 1-1 Entwicklungszyklus einer Software
Bild 1-1 stellt den idealen Lebenszyklus einer Softwareentwicklung dem seinerzeit realen ge
genüber. Im Idealfall steckt man den meisten Aufwand in die Planungsphase, so dass die sich
anschließende Kodierungsphase ohne großen Aufwand vonstatten geht und auch keine wesent
lichen Korrekteren erforderlich sind. Demgegenüber stand der Realfall, wo die Planungsphase
nicht sonderlich intensiv durchdacht wurde und die Kodierung demzufolge fehlerhaft und kor
rekturanrallig gewesen ist: Die wohlbekannten Gesetzte von Dr. Joseph Murphy finden auch
hier ihre Anwendung.
Murphys Gesetze:
• Alles dauert länger als man denkt
• Alles ist teurer als man denkt
• Alles ist komplizierter als man denkt
• Wenn ein Fehler passieren kann, dann passiert er auch.
(-7 Murphy war Optimist)
Diese etwas scherzhafte Formulierung von Murphys Gesetzen zeigt dennoch einen großen Teil
der tatsächlichen Probleme auf, die mit der Entwicklung von Software verbunden sind.
1.2 Methodische Ansätze
Die Softwarekrise der 60er Jahre fiihrte, wie aufgezeigt, also zu der Notwendigkeit, Software
systematisch zu planen und zu entwickeln. Dies mündete in der wissenschaftlichen Disziplin
des Software Engineering.
