Inhalt der Vorlesung ist der gesamte Lebenszyklus von Software von der Projektplanung über die Systemanalyse, die Kostenschätzung, den Entwurf und die Implementierung, die Validation und Verifikation, bis hin zur Wartung von Software. Weiter werden UML, Entwurfsmuster, Software-Werkzeuge, Programmierumgebungen und Konfigurationskontrolle behandelt.

Lernziele:

Studierende kennen und verstehen die Bedeutung der sechs Phasen Planung, Definition, Entwurf (Design), Implementierung, Testen und Abnahme, Einsatz und Wartung des Wasserfallmodells für den Softwareentwicklungsprozess und kennen die verschiedenen Schritte und Artefakte, die in den einzelnen Phasen entstehen.

Studierende beherrschen die Modellierung von Anwendungsfällen eines Szenarios mithilfe von UML-Anwendungsfalldiagrammen. Studierende kennen die unterschiedlichen Arten von Anforderungen sowie Probleme und Techniken der Anforderungsermittlung. Studierende kennen Aufbau und Gliederung eines Lastenhefts und verstehen die Notwendigkeit eines Glossars und einer Durchführbarkeitsuntersuchung.

Studierende können für eine vorgegebene Aufgabenstellung ein Pflichtenheft entsprechend dem beschriebenen Pflichtenheft-Schema erstellen.

Studierende kennen das Konzept der Modellierung sowie verschiedene Arten von UML-Modellen und deren Elemente. Studierende beherrschen die Erstellung von Objektmodellen und dynamischen Modellen mit den UML-Diagrammtypen Klassendiagramm, Anwendungsfalldiagramm, Aktivitätsdiagramm, Interaktionsdiagramm, Sequenzdiagramm, Zustandsdiagramm und Paketdiagramm.

Studierende verstehen die grundlegenden OO-Konzepte Objekt, Klasse, Exemplar, Attribut, Zustand, Kapselungsprinzip, Assoziation und Relation, Kardinalität, Multiplizität, Vererbung, Ist-ein Beziehung, abstrakte Methode, Schnittstelle, Ko-/Kontravarianz, In-/Varianz, Polymorphie, Sichtbarkeit/"Zugriffsschutz".

Studierende verstehen die Notwendigkeit von Entwurfs-Abwägungen und die Konzepte modularer und Objekt-orientierter Entwurf sowie Architektur- und Entwurfsmuster und können diese vergleichen und anwenden.

Studierende kennen die Begriffe abstrakte Maschine/virtuelle Maschine sowie Programmfamilie/Software-Produktlinie.

Studierende kennen und verstehen die Architekturstile Schichtenarchitektur, Klient/Dienstgeber (engl. client/server), Partnernetze (engl. peer-to-peer), Datenablage (engl. repository), Modell-Präsentation-Steuerung (engl. Model-View-Controller), Fließband (engl. pipeline), Rahmenarchitektur (engl. framework) und Dienstorientierte Architektur (engl. service oriented architecture)

Studierende kennen die verschiedenen Kategorien von Entwurfsmustern und können die Entkopplungsmuster Adapter, Beobachter, Brücke, Iterator, Stellvertreter und Vermittler, die Varianten-Muster Abstrakte Fabrik, Besucher, Fabrikmethode, Kompositum, Schablonenmethode, Strategie und Dekorierer, die Zustandshandhabungs-Muster Einzelstück, Fliegengewicht, Memento, Prototyp und Zustand und die Steuerungs-Muster Befehl und Master/Worker sowie die Bequemlichkeitsmuster Bequemlichkeits-Klasse, Bequemlichkeits-Methode, Fassade und Null-Objekt anwenden und bewerten.

Studierende beherrschen die Abbildung von UML-Modellen auf Code.

Studierende verstehen die Notwendigkeit von Programmierrichtlinien und selbstkontrolliertem Programmieren und kennen typische Programmierfehler und können den Nutzen von Fehler- und Zeitlogbüchern erläutern.

Studierende verstehen die Notwendigkeit von Softwaretests und kennen die drei verschiedenen Arten von Fehlern, Versagen oder Ausfall (engl. failure, fault), Defekt (engl. defect, bug) und Irrtum oder Herstellungsfehler (engl. mistake) und deren Zusammenhang.

Studierende verstehen die Testhelfer Stummel (engl. stub), Attrappe (engl. dummy) und Nachahmung (engl. mock object) und können diese anwenden.

Studierende verstehen die Unterschiede zwischen testenden, verifizierenden und analysierenden Testverfahren. Studierende können die verschiedenen Fehlerklassen Anforderungsfehler, Entwurfsfehler und Implementierungsfehler erklären und unterscheiden.

Studierende verstehen die grundlegenden Begriffe (Software-)Test, Testling/Prüfling/Testobjekt (engl. test object, component under test, CUT), Testfall (engl. test case), Testtreiber (engl. test driver) und Testrahmen (engl. testing framework) und können diese wiedergeben.

Studierende kennen die verschiedenen Testarten Komponenten-Test (unit test), Integrationstest (integration test), Systemtest (system test), Abnahmetest (acceptance test) die dazugehörigen Phasen im Softwarentwicklungsprozess und die Artefakte auf denen sie angewendet werden.

Studierende beherrschen die dynamischen Testverfahren Strukturtest (kontrollflussorientierter Test, datenflussorientierter Test, white/glass box testing), funktionaler Test (black box testing), und Leistungstest (Last- und Stresstest) sowie statische Prüfverfahren, darunter Prüfprogramme zur statischen Analyse und die manuellen Prüfmethoden Inspektion, Review, Durchsichten (engl. inspection, review, walkthrough).

Studierende können aus einem gegebenen Programm einen Kontrollflussgraphen erstellen.

Studierende kennen und verstehen die kontrollflussorientierten Testverfahren Anweisungs-, Zweig- und (vollständige oder strukturierte) Pfadüberdeckung und die Behandlung von Schleifen mit dem "Boundary-Interior Test" (Grenz- und Innen-Test) und können diese anwenden. Studierende kennen einfache, mehrfache und minimal-mehrfache Bedingungsüberdeckungsverfahren und können diese anwenden.

Studierende verstehen das Konzept automatisch ablaufender Testfälle und deren Bedeutung als Regressionstests und kennen und beherrschen die Erstellung und Überprüfung von Tests mithilfe der Rahmenarchitektur JUnit. Studierende kennen Prüfprogramme zur Ermittlung der Anweisungsabdeckung von Testfällen (EMMA) und zur Prüfung des Programmierstils (Checkstyle). Studierende kennen Werkzeuge zur (Teil-)Automatisierung von Aufgaben während des Entwicklungsprozesses (Maven).

Studierende beherrschen die Verfahren funktionale Äquivalenzklassenbildung, Grenzwertanalyse, Zufallstest und Test von Zustandsautomaten zur Testfallbestimmung.

Studierende beherrschen Regressionstests, die verschiedenen Integrationsstrategien von Integrationstests (unmittelbar, inkrementell, vorgehensorientiert und testzielorientiert) und kennen den Unterschied zwischen funktionalen und nichtfunktionalen Systemtests.

Studierende kennen Testwerkzeuge und -konzepte wie Zusicherungen (engl. Assertions) und Prüfprogramme zum Identifikation von Defekten anhand von Fehlermustern (Findbugs).

Studierende verstehen die einzelnen Tätigkeiten und Abläufe der Abnahme-, Einführungs- und Wartungsphase und können diese wiedergeben. Studierende kennen die Unterschiede zwischen Wartung und Pflege. Studierende verstehen die Konzepte Änderungsverwaltung und –verfolgung (Fehlermeldungen und Verbesserungsvorschläge).

Studierende können Methoden zur Kosten- und Terminschätzung wie Umfang (in Codezeilen, engl. Lines of Code (LOC)) oder Personenmonate (PM) wiedergeben und auf Beispiele anwenden. Studierende verstehen wichtige Einflussfaktoren der Aufwandsschätzung ("Teufelsquadrat": Quantität, Qualität, Entwicklungsdauer, Kosten) und Basismethoden der Aufwandsschätzung (Analogiemethode, Relationsmethode, Multiplikatormethode, COCOMO II, Konsens-Schätzmethoden (Delphi-Methode (engl. Delphi method), Planungspoker (engl. planning poker)) und können diese anwenden.

Studierende kennen die verschiedenen Prozessmodelle Programmieren durch Probieren, Wasserfallmodell, V-Modell, Prototypenmodell, Iterative Modelle, Synchronisiere und Stabilisiere, Extreme Programming und Scrum und können sie vergleichen.

Studierende können grafische Benutzeroberflächen (GBO, engl. Graphical User Interface, GUI) in Java gestalten und bauen. Studierende beherrschen das Entwickeln von ereignisgetriebener Software.

Studierende kennen und verstehen Konzepte zur Identifikation und Verfolgung von Softwareänderungen mithilfe von Versionsverwaltungen und kennen grundlegende Begriffe von (Software-) Konfigurationen wie bspw. Version, Revisionen und Varianten. Studierende beherrschen die Konzepte Einbuchen/Ausbuchen (Check-In/Check-Out), Verschmelzen und Konfliktauflösung sowie das Anlegen und Zusammenführen von Entwicklungslinien. Sie kennen die Unterschiede der Versionsverwaltungen Revision Control System, Subversion und Git.

Arbeitsaufwand:

6 LP entspricht ca. 180 Arbeitsstunden, davon

ca. 45 Std. Vorlesungsbesuch
ca. 15 Std. Nachbearbeitung
ca. 15 Std. Übungsbesuch
ca. 15 Std. Tutoriumsbesuch
ca. 45 Std. Bearbeitung Übungsaufgaben
ca. 1,5 Std. schriftliche Prüfung (90 Minuten)
ca. 44 Std. Prüfungsvorbereitung