Softwareengineering für Ingenieure und Informatiker: Planung, Entwurf und Implementierung PDF
Preview Softwareengineering für Ingenieure und Informatiker: Planung, Entwurf und Implementierung
Peter 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.
The list of books you might like
