Grundkurs Software-Engineering
mit UML
Konzepte für die erfolgreiche SoftwareEntwicklung
Prof. Dr. Stephan Kleuker
• Bitte beachten Sie die Rechte des Verlages SpringerTeubner an
der Buchinhalten und Bildern
• Diese Folien sind als Begleitfolien für das Buch konzipiert
Grundkurs Software-Engineering mit UML
Stephan Kleuker
1
Inhaltsverzeichnis
1 Was ist Software-Engineering?
2 Prozessmodellierung
3 Vorgehensmodelle
4 Anforderungsanalyse
5 Grobdesign
6 Vom Klassendiagramm zum Programm
7 Konkretisierungen im Feindesign
8 Optimierung des Designmodells
9 Implementierungsaspekte
10 Oberflächengestaltung
11 Qualitätssicherung
12 Umfeld der Software-Entwicklung
Hinweis: grüne Kästchen verlinken auf das genannte Kapitel
Grundkurs Software-Engineering mit UML
Stephan Kleuker
2
1. Motivation von SoftwareEngineering
Grundkurs Software-Engineering mit UML
Stephan Kleuker
3
Historie des SW-Engineering (1/4)
•
•
Ende 60er
– Bedarf für Softwaretechnik neben der reinen
Programmierung erstmals voll erkannt
– Vorher sind zahlreiche große Programmentwicklungen
(möglich durch verbesserte Hardwareeigenschaften)
gescheitert
– Arbeiten von Dijkstra 1968 (u.a. gegen Verwendung von
GOTO) und Royce 1970 (Software-Lebenszyklus),
• Top-Down-Entwurf, graphische Veranschaulichungen
(Nassi-Shneiderman Diagramme)
Mitte 70er
– Top-Down-Entwurf für große Programme nicht
ausreichend, zusätzlich Modularisierung erforderlich
– Entwicklung der Begriffe Abstrakter Datentyp,
Datenkapselung und Information Hiding
Grundkurs Software-Engineering mit UML
Stephan Kleuker
4
Historie des SW-Engineering (2/4)
•
•
•
Ende 70er
– Bedarf für präzise Definition der Anforderungen an ein
Softwaresystem, Entstehen von Vorgehensmodellen, z. B.
Structured Analysis Design Technique (SADT)
80er Jahre
– Vom Compiler zur Entwicklungsumgebung (Editor,
Compiler, Linker, symbolischer Debugger, Source Code
Control Systems)
– Weiterentwicklung der Modularisierung und der
Datenkapselung zur objektorientierten Programmierung
90er Jahre
– Objektorientierte Programmierung nimmt zu (wieder
ausgehend von der Implementierung)
– Neue Programmiersprache Java (ab Mitte 80er C++)
– Anwendungs-Rahmenwerke (Application Frameworks) zur
Vereinfachung von Design und – vor allem –
Programmierung
Grundkurs Software-Engineering mit UML
Stephan Kleuker
5
Historie des SW-Engineering (3/4)
•
•
•
•
90er Jahre
– Geeignete Analyse- und Entwurfsmethoden entstehen
(Coad/Yourdon, Rumbaugh, Booch, Jacobson und andere)
1995
– Vereinigung mehrerer Ansätze zunächst als Unified Method
(UM) von Booch und Rumbaugh, dann kommt Jacobson
hinzu (Use Cases).
– 3 Amigos definieren die Unified Modeling Language (UML)
als Quasi-Standard.
1997
– UML in der Version 1.1 bei der OMG (Object Management
Group) zur Standardisierung eingereicht und angenommen
– UML ist jedoch keine Entwicklungsmethode
(Phasenmodell), nur eine Beschreibungssprache
1999
– Entwicklungsmethode: Unified Process (UP) und Rational
Unified Process (RUP) (erste Version)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
6
Historie des SW-Engineering (4/4)
• Heute
– Vorgehensweisen auf individuelle
Projektanforderungen abgestimmt
– CASE-Methoden und –Tools orientieren sich an
der UML
– Aktueller Stand 2013: UML 2.4.1
(http://www.uml.org/)
– Aufbauend auf Analyse und Design erzeugen
Codegeneratoren Programmgerüste
– Haupttätigkeiten bei Softwareentwicklung sind
Analyse und Design, vieles andere versucht man
zu automatisieren (!?)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
7
Warum scheitern SW-Projekte (kleine Auswahl)
• Die Software wurde wesentlich zu spät geliefert
• Die Software erfüllt nicht die Wünsche des Kunden
• Die Software läuft nicht auf den vereinbarten
Rechnersystemen, sie ist zu langsam oder kommt
mit dem Speicher nicht aus
• Die Software kann nicht erweitert werden oder mit
anderer Software zusammenarbeiten
• …
Grundkurs Software-Engineering mit UML
Stephan Kleuker
8
Antworten des Software-Engineering
• 1967: Prägung des Begriffs Software-Krise
• Lösungsansätze:
– Programmiersprachen: kontinuierliche Einführung
von Abstraktion (Datentypen, Funktionen,
Modulen, Klassen, Bibliotheken, Frameworks)
– Dokumentation: Einheitliche Notationen für
Entwicklungsergebnisse (UML)
– Entwicklungsprozesse: Aufgabenbeschreibungen,
wann was wie gemacht wird
– Vorgehensmodelle: Entwicklung passt sich an
Bedürfnisse des Kunden an
Grundkurs Software-Engineering mit UML
Stephan Kleuker
9
Definitionsversuch Software-Engineering
Zusammenfassend kann man Software-Engineering
als die Wissenschaft der systematischen
Entwicklung von Software, beginnend bei den
Anforderungen bis zur Abnahme des fertigen
Produkts und der anschließenden Wartungsphase
definieren. Es werden etablierte Lösungsansätze für
Teilaufgaben vorgeschlagen, die häufig kombiniert
mit neuen Technologien, vor Ihrer Umsetzung auf
ihre Anwendbarkeit geprüft werden. Das zentrale
Mittel zur Dokumentation von Software-EngineeringErgebnissen sind UML-Diagramme.
Grundkurs Software-Engineering mit UML
Stephan Kleuker
10
2. Prozessmodellierung
2.1 Unternehmensprozesse
2.2 Prozessmodellierung mit Aktivitätsdiagrammen
2.3 Risikomanagement
Grundkurs Software-Engineering mit UML
Stephan Kleuker
11
Umfeld von SW-Projekten
2.1
Unternehmensführung
Unterstützung
Vertrieb
Projektmanagement
Controlling
SW-Projekt
Grundkurs Software-Engineering mit UML
Stephan Kleuker
12
Prozesse in Unternehmen aus SW-Projektsicht
(Annahme SW ist wichtiges Kernprodukt)
• Unternehmensführung gibt Geschäftsfelder und
Strategien vor
• Vertriebsleute müssen Kunden finden, überzeugen
und Aufträge generieren
• Aufträge führen zu Verträgen, die geprüft werden
müssen
• Das Personal für Aufträge muss ausgewählt werden
und zur Verfügung stehen
• Der Projektablauf muss beobachtet werden,
Abweichungen z. B. in Zeitplan müssen zu
Steuerungsmaßnahmen führen
• Die SW muss realisiert werden
Grundkurs Software-Engineering mit UML
Stephan Kleuker
13
Rollenbegriff
• Unterschiedliche Menschen arbeiten in
verschiedenen Rollen zusammen
• Rolle: genaue Aufgabenbeschreibung, mit
Verantwortlichkeiten (was soll gemacht werden) und
Kompetenzen (welche Entscheidungen können
getroffen werden, z. B. „Arbeit anweisen“)
• Mensch kann in einem Unternehmen/Projekt
mehrere Rollen haben
• Eine Rolle kann von mehreren Menschen besetzt
werden
• Beispielrollen: Vertriebsleiter, Vertriebsmitarbeiter,
Projektleiter, Analytiker, Implementierer, Tester
Grundkurs Software-Engineering mit UML
Stephan Kleuker
14
Prozessbegriff
Prozessbeschreibungen regeln die Zusammenarbeit
verschiedene Menschen (genauer Rollen),
• Was soll in diesem Schritt getan werden?
• Wer ist verantwortlich für die Durchführung des Schritts?
• Wer arbeitet in welcher Rolle in diesem Schritt mit?
• Welche Voraussetzungen müssen erfüllt sein, damit der Schritt
ausgeführt werden kann?
• Welche Teilschritte werden unter welchen Randbedingungen
durchgeführt?
• Welche Ergebnisse kann der Schritt abhängig von welchen
Bedingungen produzieren?
• Welche Hilfsmittel werden in dem Prozessschritt benötigt?
• Welche Randbedingungen müssen berücksichtigt werden?
• Wo wird der Schritt ausgeführt?
Prozesse sind zu dokumentieren und zu pflegen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
15
Prozessmodellierung mit Aktivitätsdiagrammen
2.2
Zur Beschreibung werden folgende elementare Elemente genutzt:
genau ein Startpunkt
einzelner Prozessschritt (Aktion)
Kontrollknoten (Entscheidung)
Kontrollknoten (Zusammenführung)
Endpunkt (Terminierung)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
16
Parallelität in Prozessen
• Waagerechter oder senkrechter
Strich steht für mögliche
Prozessteilung (ein Pfeil rein,
mehrere raus) oder
Zusammenführung (mehrere
Pfeile rein, ein Pfeil raus)
• Am zusammenführenden Strich
steht Vereinigungsbedingung,
z. B.
– {und}: alle Aktionen
abgeschlossen
– {oder}: (mindestens) eine
Aktion abgeschlossen
• UML 1.1 hatte andere
Restriktionen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
17
Beteiligte, Produkte, Werkzeuge
• Beteiligte, Produkte,
Werkzeuge werden hier als
einfache Datenobjekte
modelliert, dabei steht
zunächst die Objektart und
dann die genaue
Bezeichnung
• In eckigen Klammern kann
der Zustand eines Objekts
beschrieben werden
• neben „Verantwortlicher“
noch „Mitwirkender“
möglich
• auch Entscheidungen
können Verantwortliche
haben
Grundkurs Software-Engineering mit UML
Stephan Kleuker
18
Anmerkungen
• Lesbarkeit leidet unter
Beteiligte, Produkte,
Werkzeuge, da zentraler
Ablauf versteckt
• immer erst ohne
"Kästen" modellieren
• häufig alternative
Darstellungen für Rollen
und Werkzeuge
• Variante: nur Ablauf,
Rest in
Textdokumentation
Grundkurs Software-Engineering mit UML
Stephan Kleuker
19
Beispiel: Vertrieb (1/4)
• Zu modellieren ist der Vertriebsprozess eines Unternehmens,
das SW verkauft, die individuell für den Kunden angepasst und
erweitert werden kann
• Modelle werden wie SW inkrementell erstellt; zunächst der
(bzw. ein) typische Ablauf, der dann ergänzt wird
• Typisches Szenario: Vertriebsmitarbeiter kontaktiert Kunden
und arbeitet individuelle Wünsche heraus; Fachabteilung
erstellt Kostenvoranschlag; Kunde unterschreibt Vertrag;
Projekt geht in den Prozess Projektdurchführung (hier nicht
modelliert)
• Beteiligt: Vertriebsmitarbeiter, Kunde, Fachabteilung
• Produkt: Individualwünsche, Kostenvoranschlag, Vertrag
• Aktionen: Kundengespräch, Kosten kalkulieren,
Vertragsverhandlung
Grundkurs Software-Engineering mit UML
Stephan Kleuker
20
Beispiel: Vertrieb (2/4)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
21
Beispiel: Vertrieb (3/4)
nächster Schritt: Einbau alternativer Abläufe
• Kunde ist am Angebot nicht interessiert
• In den Vertragsverhandlungen werden neue
Rahmenbedingungen formuliert, so dass eine
Nachkalkulation notwendig wird [nächste Folie]
• Bis zu einem Vertragsvolumen von 20 T€
entscheidet der Abteilungsleiter, darüber die
Geschäftsleitung ob vorliegender Vertrag
abgeschlossen werden soll oder
Nachverhandlungen nötig sind
• Die Fachabteilung hat Nachfragen, die der
Vertriebsmitarbeiter mit dem Kunden klären muss
Grundkurs Software-Engineering mit UML
Stephan Kleuker
22
Beispiel: Vertrieb (4/4)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
23
Modellierungsfalle
• Basierend auf Erfahrungen mit Flussdiagrammen könnte man
zu folgender Modellierung kommen
• Dies würde nach UML-Semantik bedeuten, dass für die Aktion
Vertragsverhandlung zwei Kostenvorschläge (initial und
aktualisiert) vorliegen müssten
• Wenn verschiedenen Wege zu einer Aktion führen sollen, muss
vor der Aktion ein Zusammenführungs-Kontrollknoten stehen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
24
Problem Lesbarkeit
• Diagramme können leicht komplex werden
Lösungsmöglichkeiten:
• Verteilung von Diagrammen auf mehrere Seiten mit
Ankerpunkten
• Verzicht, alle Elemente in einem Diagramm
darzustellen (z. B. Produkte weglassen; dies nur in
der immer zu ergänzenden Dokumentation
erwähnen)
• Diagramme hierarchisch gestalten; eine Aktion kann
durch ein gesamtes Aktivitätsdiagramm verfeinert
werden, z. B. ist „Kosten kalkulieren“ eigener
Prozess; dies sollte im Modell sichtbar werden
Grundkurs Software-Engineering mit UML
Stephan Kleuker
25
Prozessverfeinerung: Kosten kalkulieren
Anmerkung: Verantwortliche
weggelassen, da immer „Projektbegleiter der Fachabteilung“
Grundkurs Software-Engineering mit UML
Stephan Kleuker
26
Nutzung von Schwimmbahnen (für Rollen)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
27
Problem Abstraktionsgrad
• Frage: Wann nur eine Aktion, wann mehrere Aktionen
• Indikator: Mehrere Aktionen zusammenfassen, wenn
– nur ein Produkt entsteht, das ausschließlich in diesen
Aktionen benötigt wird („lokale Variable“)
– oder diese von nur einer Person bearbeitet werden
• Typischerweise Prozesshierarchie:
– Unternehmensebene; d.h. ein Diagramm für jeden Prozess
der Kern-, Management- und Supportprozesse
– Prozessebene: Verfeinerung des Prozesses, so dass alle
auch nur intern sichtbaren Rollen und Produkte sichtbar
werden
– Arbeitsprozess: Individuelle Beschreibung der
Arbeitsschritte einer Rolle für eine/ mehrere Aktionen
• Probleme: Flexibilität und Akzeptanz
Grundkurs Software-Engineering mit UML
Stephan Kleuker
28
Querschnittsprozess: Projekt-Risikomanagement
2.3
• Projekte stoßen häufig auf Probleme, die man frühzeitig hätte
erkennen und auf die man dann reagieren könnte; dieser Prozess
heißt (Projekt-) Risikomanagement (RM)
• Idee: frühzeitig über potenzielle Probleme nachdenken, genauer:
– Vermeidungsmöglichkeiten
– Maßnahmen zur Verringerung der Eintrittswahrscheinlichkeit
– Maßnahmen beim Eintreffen des Problems
• ersten beiden Ansätze heißen pro-aktives RM, letzter Ansatz
reaktives RM oder Notfall-Plan
DeMarco, T.; Lister, T.: Bärentango – Mit Risikomanagement Projekte zum Erfolg
führen, Hanser, München, 2003
Wallmüller, E.: Risikomanagement für IT- und Software-Projekte, Hanser, München,
2004
Gaulke, M.: Risikomanagement in IT-Projekten, Oldenbourg, München, 2004
Versteegen, G.: Risikomanagement in IT-Projekten, Springer, Berlin, 2003
Grundkurs Software-Engineering mit UML
Stephan Kleuker
29
Beispiel RM bei Projektplanung
• Risiko: Mangelnder Austausch von Know-How im Projektteam
• Auswirkungen: Arbeiten werden doppelt gemacht,
vorhandenes Wissen nicht eingesetzt
• Ursache: Neues Projektteam, dass noch nicht
zusammengearbeitet hat
• Maßnahme: (Verringerung) Erste Projektveranstaltung (Kickoff) findet in kleinem Hotel außerhalb des Unternehmens statt;
moderierte Workshops zum Aufbau des Verständnisses der
Projektaufgabe und zur Findung vorhandener Kompetenzen
• Messung des Maßnahmenerfolgs: Kontrolle auf
Doppelarbeiten; Verfolgung der Qualität der Ergebnisse, die
von mehreren Personen erstellt wurden (nur weiches Maß)
• Hinweis: Ursache und Risiko können verwischen, da Ursachen
wieder Ursachen haben können (... irgendjemand in den Apfel
gebissen hat  )
Grundkurs Software-Engineering mit UML
Stephan Kleuker
30
Risikomanagement
R isike n
ide n tifiz ie re n
O ptim ie re n
R isike n
an a lys iere n
M a ß na hm e n
pla n e n
R isiko D ate nb a nk
M aß n ah m e n
d urchfüh ren
M a ß na hm e n
be w erte n
Grundkurs Software-Engineering mit UML
Stephan Kleuker
31
Phasen des Risikomanagements (1/3)
• Risiken identifizieren
– Identifikation eines Risikos, Festlegung der
Risikoaussage und des Risikokontextes
– Aufnahme in die Risikoliste
• Risiken analysieren
– Festlegung der Eintrittswahrscheinlichkeit, der
Auswirkungen, der erwarteten Tendenz und des
Ursachenfeldes
– Priorisierung der vorhandenen Risiken unter
Berücksichtigung der Gesamtrisikolage
Grundkurs Software-Engineering mit UML
Stephan Kleuker
32
Phasen des Risikomanagements (2/3)
• Maßnahmen planen
– Passende Maßnahmen definieren
– Festlegen der verantwortlichen Personen/Rollen
– Erfolgsfaktoren für Maßnahmen festlegen
• Maßnahmen durchführen
– Sammeln von Informationen/Daten zu den
Veränderungen der Risiken und dem Erfolg der
Maßnahmen
– Erstellen von Risikomeldungen für das
Management
Grundkurs Software-Engineering mit UML
Stephan Kleuker
33
Phasen des Risikomanagements (3/3)
• Maßnahmen bewerten
– Bewertung der Veränderung von Risiken und des
Erfolgs der angewendeten Maßnahmen
– Entscheidungsfindung zur weiteren Behandlung
der Risiken und Anpassung der Maßnahmen
– Informationsverteilung zu den Risiken in Richtung
Team und Vertragspartnern/Kunde
• Optimieren
– Maßnahmen zielgerichtet anpassen
– Hinweise/ Optimierungspotenziale für zukünftige
Projekte erkennen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
34
3. Vorgehensmodelle
3.1 Phasen der Software-Entwicklung
3.2 Wasserfallmodell
3.3 Prototypische Entwicklung
3.4 Iterative Entwicklung
3.5 Iterativ-inkrementelle Entwicklung
3.6 Allgemeines V-Modell
3.7 Das V-Modell der Bundesrepublik Deutschland
3.8 Rational Unified Process
3.9 Agile Vorgehensmodelle
3.10 Scrum
3.11 Extreme Programming
Grundkurs Software-Engineering mit UML
Stephan Kleuker
35
Herausforderungen der SW-Entwicklung
3.1
Software-Systeme sind heutzutage verteilte
Anwendungen
– Anschluss an existierende Software (z.B. SAP, MS
Office, bestehende Unternehmenssoftware...)
– Integration neuer Komponenten in existierende
Systeme
– Erweiterung existierender Systeme
eigene
Komponenten
neues System
?
?
?
Legacy Systeme
Grundkurs Software-Engineering mit UML
Systeme an
anderen Standorten
?
?
Systeme
anderer Anbieter
Stephan Kleuker
36
Die Phasen der SW- Entwicklung
• Erhebung und Festlegung des
Anforderungsanalyse
WAS mit Rahmenbedingungen
Grobdesign
Feindesign
Implementierung
Test und Integration
• Klärung der Funktionalität und
der Systemarchitektur durch
erste Modelle
• Detaillierte Ausarbeitung der
Komponenten, der Schnittstellen,
Datenstrukturen, des WIE
• Ausprogrammierung der
Programmiervorgaben in der
Zielsprache
• Zusammenbau der Komponenten,
Nachweis, dass Anforderungen
erfüllt werden, Auslieferung
Grundkurs Software-Engineering mit UML
Stephan Kleuker
37
Wasserfallmodell
3.2
Anforderungsanalyse
Grobdesign
Feindesign
Implementierung
Test und Integration
Grundkurs Software-Engineering mit UML
Merkmale:
Phasen werden von oben nach unten
durchlaufen
Vorteile:
- Plan auch für Nichtexperten verständlich
- einfache Meilensteinplanung
- lange Zeit am häufigsten eingesetzt
Nachteile:
- Anforderungen müssen 100%-ig sein
- späte Entwicklungsrisiken werden spät
erkannt
- Qualität des Design passt sich Zeitplan an
Optimierung:
es ist möglich, in die vorherige Phase zu
springen
Stephan Kleuker
38
Prototypische Entwicklung
3.3
Anforderungsanalyse
Anforderungsanalyse
Grobdesign
Grobdesign
Feindesign
Feindesign
Implementierung
Implementierung
Test und
Integration
Test und Integration
Prototyp
Grundkurs Software-Engineering mit UML
Merkmale:
- potenzielle Probleme frühzeitig
identifiziert,
- Lösungsmöglichkeiten im Prototypen
gefunden, daraus Vorgaben abgeleitet
Vorteile:
- frühzeitige Risikominimierung
- schnelles erstes Projektergebnis
Nachteile:
- Anforderungen müssen fast 100%-tig
sein
- Prototyp (illegal) in die Entwicklung
übernommen
- Kunde erwartet schnell Endergebnis
Optimierung:
es ist möglich, in die vorherige Phase
zu springen
Stephan Kleuker
39
Iterative Entwicklung
3.4
Anforderungsanalyse
Grobdesign
Feindesign
Implementierung
Test und Integration
Merkmale:
- Erweiterung der Prototypidee; SW wird in
Iterationen entwickelt
- In jeder Iteration wird System weiter verfeinert
- In ersten Iterationen Schwerpunkt auf Analyse
und Machbarkeit; später auf Realisierung
große Vorteile:
- dynamische Reaktion auf Risiken
- Teilergebnisse mit Kunden diskutierbar
Nachteile im Detail:
- schwierige Projektplanung
- schwierige Vertragssituation
- Kunde erwartet zu schnell Endergebnis
- Kunde sieht Anforderungen als beliebig
änderbar
Grundkurs Software-Engineering mit UML
Stephan Kleuker
40
Iterativ Inkrementelle Entwicklung (State of the Art)
3.5
Anforderungsanalyse
Grobdesign
Feindesign
Implementierung
Test und Integration
Bsp.: vier Inkremente
Grundkurs Software-Engineering mit UML
Merkmal:
- Projekt in kleine Teilschritte zerlegt
- pro Schritt neue Funktionalität
(Inkrement) + Überarbeitung
existierender Ergebnisse (Iteration)
- n+1-ter Schritt kann Probleme des nten Schritts lösen
Vorteile:
- siehe „iterativ“
- flexible Reaktion auf neue funktionale
Anforderungen
Nachteile:
- siehe „iterativ“ (etwas verstärkt)
Optimierung/Anpassung:
Anforderungsanalyse am Anfang
intensiver durchführen
Stephan Kleuker
41
Fertigstellung mit Iterationen
Ite ra tio n e n
1.
2.
3.
4.
A n fo rd e ru n g s a n a lys e
G ro b d e sig n
F e in d e s ig n
Im p le m e n tie ru n g
T e st u n d In te g ra tio n
0%
Grundkurs Software-Engineering mit UML
F e rtig ste llu n g s g ra d
Stephan Kleuker
100%
42
Bekanntheit von Vorgehensmodellen (1/2)
41
W a s s e rfa llm o d e ll
71
24
V -M o d e ll
63
19
S p ira lm o d e ll
52
26
In k re m e n te lle E n tw ic k lu n g
45
17
E v o lu tio n ä re s P ro to ty p in g
41
E x tre m e P ro g ra m m in g
4
39
R U P (R a tio n a l U n ifie d P ro c e s s )
15
32
20
k e in e s d ie s e r M o d e lle
11
g e n u tz te M o d e lle
b e k a n n te M o d e lle
Quelle: Softwareentwicklung läuft nicht auf Zuruf, Computer Zeitung Nr. 46/05
Grundkurs Software-Engineering mit UML
Stephan Kleuker
43
Bekanntheit von Vorgehensmodellen (2/2)
W a sse rfa llm o d e ll
5 ,4
V-M o d e ll
p h a se n o rie n tie rt
RUP
54
1 9 ,7
2 ,3
a n d e re s e xp lizite s M o d e ll
1 4 ,3
in d ivid u e lle s M o d e ll
1 2 ,4
S cru m
E xtre m e P ro g ra m m in g
a g il
1 ,3
33
a n d e re s e xp lizite s M o d e ll
in d ivid u e lle s M o d e ll
ke in e s
1 8 ,8
13
Grundkurs Software-Engineering mit UML
4 ,0
8 ,9
13
Stephan Kleuker
44
Struktur komplexer Vorgehensmodelle
3.6
• Aktuelle Vorgehensmodelle, wie
V-Modell XT des Bundes
(Rational) Unified Process
OEP (Object Engineering Process)
enthalten Aktivitäten (was soll gemacht werden), Rollen (wer ist
wie an Aktivität beteiligt) und Produkte (was wird benötigt; bzw.
ist Ergebnis)
• es gibt Vorschläge für typische Anwendungsszenarien, wie
Aktivitäten zu verknüpfen sind
• Rahmenwerke, am Anfang eines Projekts muss
(werkzeuggestützt) bestimmen, welche Aktivitäten, Rollen,
Produkte und Reihenfolgen von Aktivitäten für das individuelle
Projekt relevant sind (tailoring, d. h. „zurecht schneidern“,
benötigt viel Erfahrung)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
45
allgemeines V-Modell
Validierung
Anforderungsdefinition
manuelle
Prüfung
Validierung
Funktionaler
Systementwurf
manuelle
Prüfung
Validierung
Technischer
Systementwurf
manuelle
Prüfung
Konstruktion
KomponentenSpezifikation
manuelle
Prüfung
Abnahmetest
Systemtest
Integrationstest
Validierung Komponenten-
test
Programmierung
Integration
Anmerkung: wird iterativ / inkrementell
zum W-Modell
Grundkurs Software-Engineering mit UML
Stephan Kleuker
46
V-Modell des Bundes
3.7
• Regelung der Softwarebearbeitung (im Bereich der
Bundeswehr, des Bundes und der Länder)
• einheitliche und (vertraglich) verbindliche Vorgabe von
– Aktivitäten und
– Produkten (Ergebnissen),
• Historie: V-Modell 92 (Wasserfall im Mittelpunkt), Überarbeitung
V-Modell 97 (Anpassung an inkrementelle Ideen (W-Modell);
Forderung nach zu früher Festlegung von Anforderungen)
• aktuell: V-Modell XT (eXtreme Tailoring), neuer Erstellung mit
Fokus auf Verhältnis von Auftragnehmer und Auftraggeber
(starker akademischer Einfluss bei Entwicklung)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
47
Struktur des V-Modell XT
http://www.v-modell-xt.de
für V-Modell XT-Informationen:
Copyright Reserved © Bundesrepublik Deutschland 2004.
Grundkurs Software-Engineering mit UML
Stephan Kleuker
48
Produktorientierung im V-Modell XT
• Eine Projektdurchführungsstrategie definiert die Reihenfolge
der im Projekt zu erreichenden Projektfortschrittsstufen; nutzt
Entscheidungspunkte (go, no go)
• Produkte stehen im Mittelpunkt, sie sind DIE Projektergebnisse
• Projektdurchführungsstrategien und Entscheidungspunkte
geben die Reihenfolge der Produktfertigstellung und somit die
grundlegende Struktur des Projektverlaufs vor
• Die detaillierte Projektplanung und -steuerung wird auf der
Basis der Bearbeitung und Fertigstellung von Produkten
durchgeführt
• Für jedes Produkt ist eindeutig eine Rolle verantwortlich und im
Projekt dann eine der Rolle zugeordnete Person
• Die Produktqualität ist überprüfbar durch definierte
Anforderungen an das Produkt und explizite Beschreibungen
der Abhängigkeiten zu anderen Produkten
Grundkurs Software-Engineering mit UML
Stephan Kleuker
49
Entscheidungspunkte des V-Modells XT
relevant für alle V-Modell-Projekte
Schnittstelle Auftraggeber / Auftragnehmer
Organisationsspezifisches V-Modell
Systementwicklung
Projekt
genehmigt
Vorgehensmodell
analysiert
Verbesserung
Vorgehensmodell
konzipiert
Verbesserung
Vorgehensmodell
realisiert
Projekt
definiert
Anforderungen
festgelegt
Geamtprojekt
aufgeteilt
Projekt
ausgeschrieben
Gesamtfortschritt überprüft
Projektfortschritt überprüft
Projekt
beauftragt
Iteration
geplant
System spezifiziert
Abnahme
erfolgt
Projekt
abgeschlossen
Lieferung durchgeführt
System entworfen
System integriert
Feinentwurf abgeschlossen
Grundkurs Software-Engineering mit UML
Angebot
abgegeben
Systemelemente realisiert
Stephan Kleuker
50
Beispiel: Projektdurchführungsplan
(Systementwicklungsprojekt eines Auftraggebers (AG))
Grundkurs Software-Engineering mit UML
Stephan Kleuker
51
Beispielaktivität: Anforderungen festlegen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
52
Rational Unified Process (RUP)
3.8
Phasen
D is zip lin e n
K o n z e p tio n
K o n s tru k tio n
A u s a rb e itu n g
In b e trie b n a h m e
G e s c h ä fts p ro z e s s m o d e ll
A n fo rd e ru n g s a n a ly s e
D e s ig n
Im p le m e n tie ru n g
Test
In s ta lla tio n
K o n fig u ra tio n s - u n d
Ä n d e ru n g s m a n a g e m e n t
P ro je k tm anagem ent
P ro je k tu m fe ld
S tart
aus IBM/Rational:
Rational Unified Process
K o n zep tio n
Iteration 1
Grundkurs Software-Engineering mit UML
K o n zep tio n
Iteration 2
A u sarb eitu ng A u sarb eitu ng A u sarb eitu ng Inb etrieb
Iteration 1
Iteration 2
Iteration n
Iteration 1
Inb etrieb
Iteration 2
Ite ra tio n e n
Stephan Kleuker
53
Phasen des RUP
• inception (Konzeption): Ermittlung zentraler
Anforderungen, Projektumfang definieren, erste
Entwurfs- und Implementierungsansätze,
Identifikation der Projektrisiken und Aufwände
• elaboration (Ausarbeitung): stabile, möglichst
vollständige Anforderungen, Entwurfsspezifikation,
detaillierter Projektplan mit aktivem
Risikomanagement
• construction (Konstruktion): Implementierung,
Integration, auslieferbare Version
• transition (Inbetriebnahme): Beta-Test, Endabnahme,
Inbetriebnahme, Endlieferung
Grundkurs Software-Engineering mit UML
Stephan Kleuker
54
Struktur des RUP
S o ftw a re
E n g in e e rin g
P ro c e s s
A k tiv itä t
R o lle
s tru k tu rie rt
d u rc h
b e s c h rie b e n
in
von
E rg e b n is
E in g a b e
v e ra n tw o rtlic h fü r
D is z ip lin
e rs te llt m it H ilfe
b e a rb e ite t
P ro d u k t
(A rtifa c t)
W e rk z e u g a n le itu n g
A rb e its a b la u f
H ilfs m itte l
v e rfe in e rt
d u rc h
C h e c k lis te
A rb e its a b la u fd e ta ils
H ilfs m itte l
S tru k tu rb e s c h re ib u n g
(T e m p la te )
H ilfs m itte l
B e ric h t
b e s c h rie b e n d u rc h
Grundkurs Software-Engineering mit UML
Stephan Kleuker
55
Kritik an klassischen Vorgehensmodellen
3.9
• Es müssen viele Dokumente erzeugt und gepflegt
werden
• Eigene Wissenschaft Modelle wie V-Modelle und
RUP zu verstehen und zurecht zu schneidern
• Prozessbeschreibungen hemmen Kreativität
• Anpassung an neue Randbedingungen, z. B. neue
Technologien (Web-Services) in Prozessen und
benutzten Werkzeugen ist extrem aufwändig
• alternativer Ansatz: „Menschen machen Projekte
erfolgreich, traue den Menschen“
=>
agile Prozesse (vorherige Name:
leichtgewichtige Prozesse)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
56
Arten von agilen Prozessen (1/2)
• generell: Methoden lernen von einander; es gibt
nicht die eine agile Methode
• Variante 1: Beschreibung auf Metaprozessebene
– Grundregeln zur Projektorganisation
– Vorgehensweisen in Projekten werden vom Team
festgelegt
– Beispiele:
• Scrum (u. a. Ken Schwaber, Jeff Sutherland) [s.
Folien]
• Crystal Methodenfamilie (Alistair Cockburn)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
57
Arten von agilen Prozessen (2/2)
• Variante 2: Konkrete Prozessbeschreibungen
– Für verschiedene Phasen der SoftwareEntwicklung werden konkrete Verfahren
vorgeschlagen
– Abhängigkeiten der Verfahren werden
dokumentiert („wer A macht muss auch B
machen“); Möglichkeiten zur individuellen
Optimierung
– Beispiele:
• eXtreme Programming (XP) (u. a. Kent Beck,
Ward Cunningham) [s. Folien]
• Dynamic Systems Development Method
(Konsortium)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
58
Agiles Manifest (Februar 2001)
We are uncovering better ways of developing
software by doing it and helping others do it.
Through this work we have come to value:
Individuals and interactions over processes and tools
Working software over comprehensive documentation
Customer collaboration over contract negotiation
Responding to change over following a plan
That is, while there is value in the items on
the right, we value the items on the left more.
Kent Beck, Mike Beedle, Arie van Bennekum, Alistair Cockburn, Ward Cunningham, Martin
Fowler, James Grenning, Jim Highsmith, Andrew Hunt, Ron Jeffries, Jon Kern, Brian Marick,
Robert C. Martin, Steve Mellor, Ken Schwaber, Jeff Sutherland, Dave Thomas
www.agileAlliance.org
Grundkurs Software-Engineering mit UML
Stephan Kleuker
59
Scrum (1/2)
3.10
• („Scrum“: Gedränge beim Rugby)
• Scrum Teams mit maximal 7 Personen mit unterschiedlichen
Fähigkeiten, Koordinator (Scrum Master),
Anforderungsdefinerer (Product Owner), Entwickler-Team
• Bei größeren Teams: mehrere Teilteams durch Scrum Master
koordiniert
• Zentrales Steuerungselement: Scrum meetings; jeden Tag 15
Minuten:
– was habe ich seit letztem Meeting gemacht?
– was werde ich bis zum nächsten Meeting machen?
– was hat meine Arbeit behindert?
• Scrum Master ist Koordinator; beseitigt Behinderungen;
kommuniziert im Unternehmen
• Arbeitsablauf im Team wird vom Team selbst geregelt
Grundkurs Software-Engineering mit UML
Stephan Kleuker
60
Scrum (2/2)
• Projektplanung: Eng mit dem Kunden werden Hauptaufgaben
identifiziert (Stack mit product backlog)
• Product Owner nimmt Rolle des Kunden ein (kommt von
Kunden, oder erfahren im Anwendungsgebiet)
• Hauptaufgaben können auch Test von Technologien und die
Entwicklung von Prototypen sein
• Scrum Team schätzt Aufwände; wählt mit Kunden aus product
backlog wichtigste nächste Aufgaben für nächste Iteration
(heißt sprint) aus (in sprint backlog)
• Jeder sprint dauert ca. 5-30 Tage; sprint backlog mit
priorisierten Aufgaben; sorgt für nicht unterbrochene
Arbeitsphase des Teams (Scrum Master kann abbrechen)
• Nach jedem sprint Analyse mit dem Kunden, was wurde
erreicht; wie kann Projekt verbessert werden [zurück Planung]
• siehe auch: www.controlchaos.com
Grundkurs Software-Engineering mit UML
Stephan Kleuker
61
Scrum - Überblick
Product
backlog
sprint
backlog
Aufgabe 1
Teilaufgabe 1
Aufgabe 2
Teilaufgabe 2
...
...
Planung
für sprint
Arbeitstag
Scrum-Meeting
Sprint Review
Sprint Retrospective
Grundkurs Software-Engineering mit UML
sprint
21 Arbeitstage
Stephan Kleuker
62
Ideen des Extreme Programming (XP) (1/3)
3.11
•
•
•
•
•
•
•
•
•
Planning
User stories are written
Release planning creates
the schedule
Make frequent small
releases
The Project Velocity is
measured
The project is divided into
iterations
Iteration planning starts
each iteration
Move people around
A stand-up meeting starts
each day
Fix XP when it breaks
Grundkurs Software-Engineering mit UML
•
•
•
•
•
•
Designing
Simplicity
Choose a system metaphor
Use CRC cards for design
sessions
Create spike solutions to
reduce risk
No functionality is added
early
Refactor whenever and
wherever possible
Stephan Kleuker
63
Ideen des Extreme Programming (XP) (2/3)
•
•
•
•
•
•
•
•
•
Coding
The customer is always
available
Code must be written to
agreed standards
Code the unit test first
All production code is pair
programmed
Only one pair integrates
code at a time
Integrate often
Use collective code
ownership
Leave optimization till last
No overtime
Grundkurs Software-Engineering mit UML
•
•
•
•
Testing
All code must have unit
tests
All code must pass all unit
tests before it can be
released
When a bug is found tests
are created
Acceptance tests are run
often and the score is
published
Stephan Kleuker
64
Ideen des Extreme Programming (XP) (3/3)
Testfälle
neue User-Story
geänderte
Randbedingung
User
Stories
Anforderungen
Systemidee
Architekturansatz
Fehler
Release- ReleaseIteration
plan
Planung
unklare
Annahmen
abgesicherte
Annahmen
aktuelle
Version
nächste
Iteration
Miniprototyp
(Spike)
Akzeptanz
-tests
Kundenzustimmung
kleine
Releases
• Quelle der XP-Folien : www.extremeprogramming.org
• Varianten: z. B. in der Nutzung von Dokumentation (keine –
minimal)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
65
Versuch einer Beurteilung von agilen Methoden
• agile Methoden haben viele Innovationen in verstaubte SWEntwicklungsprozesse gebracht (etwas Neues; viel neu
arrangiertes)
• Einsetzbarkeit hängt stark von technischen und menschlichen
Fähigkeiten des Teams ab
• große Erfolge möglich, wenn Dream-Team gefunden
• Aufpassen bei Beratungs-Hype („XP ist die Zukunft“)
Hamburger Berater: Wir haben agile Methoden erfolgreich in
Versicherung X eingeführt und manifestiert
Projektleiter bei X: Haben neue Ideen zur Optimierung unseres
existierenden Prozesses genutzt; konkret übrig geblieben sind
Stand-Up-Meetings
• Agiles Manifest interessant für alle SW-Entwicklungsprozesse
• Ideen auf andere Ansätze übertragbar
• Überblick mit Kommentaren in Artikeln von J. Coldewey
http://www.coldewey.com/publikationen/Kolumne.html
Generell: Vorgehensmodell muss zum Projekt und den Menschen passen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
66
4. Anforderungsanalyse
4.1
4.2
4.3
4.4
4.5
4.6
Stakeholder und Ziele
Klärung der Hauptfunktionalität (Use Cases)
Beschreibung typischer und alternativer Abläufe
Ableitung funktionaler Anforderungen
Nicht-funktionale Anforderungen
Lasten- und Pflichtenheft
Literatur:
• [RS] C. Rupp, SOPHIST GROUP, Requirements- Engineering und –
Management, Hanser Fachbuchverlag
• [OW] B. Oestereich, C. Weiss, C. Schröder, T. Weilkiens, A. Lenhard,
Objektorientierte Geschäftsprozessmodellierung mit der UML,
dpunkt.Verlag
Grundkurs Software-Engineering mit UML
Stephan Kleuker
67
so nicht (1/4): Beispiel-Szenario
Zur Stundenerfassung und Abrechnung werden von
den Projektmitarbeitern spezielle Excel-Tabellen
jeden Freitag ausgefüllt und am Montag vom
Projektleiter bei der Verwaltung abgegeben.
Der zuständige Sachbearbeiter überträgt dann die für
den Projektüberblick relevanten Daten manuell in ein
SAP-System. Dieses System generiert automatisch
eine Übersicht, aus der die Geschäftsführung
ablesen kann, ob die Projekte wie gewünscht laufen.
Dieser Bericht liegt meist am Freitag der Woche vor.
Die Bearbeitungszeit ist der Geschäftsführung zu
lang, deshalb soll der Arbeitsschritt automatisiert
werden.
Grundkurs Software-Engineering mit UML
Stephan Kleuker
68
so nicht (2/4): Die Projektplanung
• Es wird ein Projekt „Projektberichtsautomatisierung“
(ProAuto) beschlossen.
• Der Leiter der hausinternen IT-Abteilung wird über
die anstehende Aufgabe informiert. Er erhält eine
Beschreibung der Excel-Daten und der gewünschten
SAP-Daten.
• Der Leiter stellt fest, dass seine Abteilung das Knowhow und die Kapazität hat, das Projekt
durchzuführen und legt der Geschäftsführung einen
Projektplan mit einer Aufwandsschätzung vor.
• Die Geschäftsführung beschließt, das Projekt intern
durchführen zu lassen und kein externes Angebot
einzuholen.
Grundkurs Software-Engineering mit UML
Stephan Kleuker
69
so nicht (3/4): Die Schritte zum Projektmisserfolg
• Die IT-Abteilung analysiert
die Excel-Daten und wie die
Daten in das SAP-System
eingefügt werden können.
• Kurz nach dem geschätzten
ProAuto
Projektende liegt eine
technisch saubere Lösung
vor. Excel wurde um einen
Knopf erweitert, so dass die
Projektleiter per Knopfdruck die Daten nach SAP überspielen
können.
• Vier Wochen nach Einführung des Systems wird der Leiter der
IT-Abteilung entlassen, da die Daten zwar jeden Montag
vorliegen, sich aber herausgestellt hat, dass sie nicht nutzbar
sind und die erzürnte Geschäftsleitung falsche
Entscheidungen getroffen hat. Das Projekt wird an eine
Beratungsfirma neu vergeben.
Grundkurs Software-Engineering mit UML
Stephan Kleuker
70
so nicht (4/4): so doch, Geschäftsprozessanalyse
Grundkurs Software-Engineering mit UML
Stephan Kleuker
71
Aufgabe der Anforderungsanalyse
4.1
Bestimmung aller Anforderungen an die zu erstellende
Software bzw. an das zu erstellende DV-System,
Anforderungen müssen
–vollständig,
–notwendig ("WAS statt WIE"),
–eindeutig und
–richtig ("abgestimmt als Teil einer Zielhierarchie")
sein.
Bemerkung zur Ablauforganisation: Anforderungen
müssen nicht notwendig in einer Phase vor Beginn des
Entwurfs vollständig bestimmt werden
Grundkurs Software-Engineering mit UML
Stephan Kleuker
72
Probleme mit Anforderungen an große Systeme
• Auftraggeber, Nutzer, Betreiber etc. sind häufig verschiedene
Personen, unterschiedliche Personen haben teilweise
widersprüchliche Anforderungen
• die Effekte des angestrebten Systems sind schwer vorhersehbar
• Anforderungen ändern sich im Laufe der Entwicklungszeit
• großer Umfang der Anforderungen
• komplexe Interaktion mit anderen Systemen
• Erste Aufgabe: Ermittlung der Stakeholder
Definition: Jemand der Einfluss auf die Anforderungen hat, da er
vom System betroffen ist (Systembetroffener)
• Zweite Aufgabe: Ermittlung der Ziele des Systems
Grundkurs Software-Engineering mit UML
Stephan Kleuker
73
Checkliste zum Finden von Stakeholdern (1/3) [RS]
• Endanwender
– Die größte und wichtigste Gruppe, liefert Großteil der
fachlichen Ziele
– Durchdachtes Auswahlverfahren für die
Anwenderrepräsentanten nötig (Vertrauensbasis der
gesamten Anwendergruppe berücksichtigen!)
• Management des Auftragnehmers (wir)
– Gewährleisten die Konformität mit Unternehmenszielen und
Strategien, sowie der Unternehmensphilosophie
– Sind die Sponsoren!
• Käufer des Systems
– Wer ist für die Kaufentscheidung verantwortlich?
– Liefer-Vertrags-Zahlungskonditionen?
• Prüfer, Auditoren
– sind für Prüfung, Freigabe und Abnahme notwendig,
• Entwickler
– Entwickler nennen die technologiespezifischen Ziele
Grundkurs Software-Engineering mit UML
Stephan Kleuker
74
Checkliste zum Finden von Stakeholdern (2/3)
• Wartungs- und Servicepersonal
– Wartung und Service muss unkompliziert und zügig
durchzuführen sein
– Wichtig bei hohen Stückzahlen
• Produktbeseitiger
– Wichtig, wenn ausgeliefertes Produkt nicht nur Software
umfasst, Frage der Beseitigung (z.B. Umweltschutz), kann
enormen Einfluss auf die Zielsetzung einer
Produktentwicklung haben
• Schulungs- und Trainingspersonal
– Liefern konkrete Anforderungen zur Bedienbarkeit,
Vermittelbarkeit, Hilfesystem, Dokumentation, Erlernbarkeit,
• Marketing und Vertriebsabteilung
– Marketing und Vertrieb als interne Repräsentanten der
externen Kundenwünsche und der Marktentwicklung
Grundkurs Software-Engineering mit UML
Stephan Kleuker
75
Checkliste zum Finden von Stakeholdern (3/3)
• Systemschützer
– Stellen Anforderungen zum Schutz vor Fehlverhalten von
Stakeholdern
• Standards und Gesetze
– vorhandene und zukünftige Standards/Gesetze
berücksichtigen
• Projekt- und Produktgegner
– Die Klasse der Projekt- und Produktgegner - vor allem zu
Beginn des Projekts wenn möglich mit einbeziehen, sonst
drohen Konflikte
• Kulturkreis
– setzt Rahmenbedingungen, z.B. verwendete Symbolik,
Begriffe, …
• Meinungsführer und die öffentliche Meinung
– beeinflussen oder schreiben Ziele vor, Zielmärkte
berücksichtigen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
76
Regeln für die Definition von Zielen
Ziele müssen
– vollständig,
– korrekt,
– konsistent gegenüber anderen Zielen und in sich
konsistent,
– testbar,
– verstehbar für alle Stakeholder,
– umsetzbar — realisierbar,
– notwendig,
– eindeutig und positiv formuliert sein.
Zwei weitere Merkmale:
– Lösungsneutralität
– einschränkende Rahmenbedingungen
Hinweis: Ziele sind abstrakte Top-Level-Anforderungen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
77
Schablone zur Zielbeschreibung
Ziel
Stakeholder
Was soll erreicht werden?
Welche Stakeholder sind in das Ziel
involviert? Ein Ziel ohne Stakeholder macht
keinen Sinn.
Auswirkungen
Welche Veränderungen werden für die
auf Stakeholder Stakeholder erwartet?
RandWelche unveränderlichen Randbedingungen
bedingungen
müssen bei der Zielerreichung beachtet
werden?
Abhängigkeiten Ist die Zielverknüpfung mit anderen Zielen
unmittelbar verknüpft? Dies kann einen
positiven Effekt haben, indem die Erfüllung
von Anforderungen zur Erreichung mehrerer
Ziele beiträgt. Es ist aber auch möglich, dass
ein Kompromiss gefunden werden muss, da
Ziele unterschiedliche Schwerpunkte haben.
Sonstiges
Was muss organisatorisch beachtet werden?
Grundkurs Software-Engineering mit UML
Stephan Kleuker
78
Projektbeschreibung
Zu entwickeln ist ein individuell auf die Unternehmenswünsche
angepasstes Werkzeug zur Projektverwaltung. Dabei sind die
Arbeitspakete (wer macht wann was) und das
Projektcontrolling (wie steht das Projekt bzgl. seiner Termine
und des Budgets) zu berücksichtigen. Projekte werden zur Zeit
ausgehend von Projektstrukturplänen geplant und verwaltet.
Projekte können in Teilprojekte zerlegt werden.
Die eigentlichen Arbeiten finden in Arbeitspaketen, auch
Aufgaben genannt, statt.
Projekten werden von zusammenzustellenden Projektteams
bearbeitet, die zugehörigen Mitarbeiterdaten sind zu verwalten.
Zur Ermittlung des Projektstands tragen Mitarbeiter ihre
Arbeitszeit und den erreichten Fertigstellungsgrad in das
System ein.
Grundkurs Software-Engineering mit UML
Stephan Kleuker
79
Ziele für eine Projektmanagementsoftware (1/3)
Ziel
1. Die Software muss die Planung und Analyse aller
laufenden Projekte ermöglichen
Projektplaner, Projektleiter, Mitarbeiter, Controlling
Stakeholder
(alle als Endanwender)
Auswirkungen Projektplaner: Alle Planungsdaten fließen in das
auf Stakeholder neue Werkzeug, es gibt sofort eine Übersicht, wer an
was, von wann bis wann arbeitet.
Projektleiter: Der Projektleiter ist immer über den
Stand informiert, er weiß, wer an was arbeitet.
Mitarbeiter: Die Mitarbeiter sind verpflichtet, ihre
Arbeitsstunden und erreichten Ergebnisse in das
Werkzeug einzutragen. Sie sehen, für welche
Folgearbeiten sie wann verplant sind.
Controlling: Hat Überblick über Projektstand.
Existierende Datenbestände sollen übernommen
Randbedingungen werden. Die Randbedingungen zur Verarbeitung
personalbezogener Daten sind zu beachten.
Abhängigkeiten Es liegt eine Studie des Kunden vor, warum kein
Sonstiges
Produkt vom Markt zur Realisierung genommen wird.
Grundkurs Software-Engineering mit UML
Stephan Kleuker
80
Ziele für eine Projektmanagementsoftware (2/3)
Ziel
2. Der neue Kunde soll von der fachlichen Kompetenz unseres Unternehmens überzeugt werden.
Management, Entwickler
Stakeholder
Auswirkungen Management: Der Projekterfolg hat große
auf Stakeholder Auswirkungen auf die nächsten beiden
Jahresbilanzen.
Entwickler: Es werden hohe Anforderungen an die
Software-Qualität gestellt.
Es muss noch geprüft werden, ob langfristig eine
Randfür beide Seiten lukrative Zusammenarbeit
bedingungen
überhaupt möglich ist.
Abhängigkeiten Überschneidung mit dem Ziel 3, da eine
Konzentration auf die Wünsche des neuen Kunden
eventuell einer Verwendbarkeit für den allgemeinen
Markt widersprechen kann.
Das Verhalten des neuen Kunden bei
Sonstiges
Änderungswünschen ist unbekannt.
Grundkurs Software-Engineering mit UML
Stephan Kleuker
81
Ziele für eine Projektmanagementsoftware (3/3)
Ziel
3. Das neue Produkt soll für einen größeren Markt
einsetzbar sein.
Management, Vertrieb, Entwickler
Stakeholder
Auswirkungen Management: Es soll eine Marktposition auf dem
auf Stakeholder Marktsegment Projektmanagement-Software
aufgebaut werden.
Vertrieb: In Gesprächen mit Kunden wird das neue
Produkt und seine Integrationsmöglichkeit mit
anderen Produkten ab Projektstart beworben.
Entwickler: Die Software muss modular aufgebaut
aus Software-Komponenten mit klaren
Schnittstellen bestehen.
Randbedingungen Abhängigkeiten zu Ziel 2 (Beschreibung dort)
Eine Analyse der Konkurrenten auf dem Markt liegt
Sonstiges
vor. Es sind Möglichkeiten für neue, den Markt
interessierende Funktionalitäten aufgezeigt worden.
Grundkurs Software-Engineering mit UML
Stephan Kleuker
82
Rahmenbedingungen und weiteres Vorgehen
Traceability:
• alle Anforderungen müssen sich auf ein Ziel
zurückführen lassen
• alle Ziele benötigen einen Stakeholder (ÖkonomieCheck)
Kommunikation:
• die ausgewählten Stakeholder müssen nun
detaillierter befragt und dauerhaft in das Projekt
integriert werden
Warum der ganze Aufwand:
• Vergessene Ziele und Stakeholder führen zu
massiven Change Requests
Das eigentliche SW-Projekt kann beginnen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
83
Überblick über den Analyseprozess
4.2
1. Erfassung der Systemaufgaben mit
„Use Cases“
2. Beschreibung der Aufgaben mit
Aktivitätsdiagrammen
(optional 3. Formalisierung der Beschreibungen
in Anforderungen)
4. Aufbau eines tieferen Verständnisses durch
Klassenmodellierung und
Sequenzdiagramme (Grobdesign)
iterativer Prozess
Grundkurs Software-Engineering mit UML
Stephan Kleuker
84
Erfragung des WAS?
• Zentrale Frage:
Was sind die Hauptaufgaben des Systems?
• Wer ist an den Aufgaben beteiligt?
• Welche Schritte gehören zur Aufgabenerfüllung?
=> Aufgaben werden als Use Cases
(Anwendungsfälle) beschrieben
=> Beteiligte werden als Aktoren festgehalten
(können meist aus der Menge der
Stakeholder
entnommen werden)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
85
Use Case (Anwendungsfall)
• Use Case beschreibt in der Sprache der Stakeholder, d.h. in
natürlicher Sprache, eine konsistente und zielgerichtete
Interaktion des Benutzers mit einem System, an deren Anfang
ein fachlicher Auslöser steht und an deren Ende ein definiertes
Ergebnis von fachlichem Wert entstanden ist
• Ein Use Case beschreibt das gewünschte externe
Systemverhalten aus Sicht des Anwenders und somit
Anforderungen, die das System erfüllen soll
• eine Beschreibung was es leisten muss, aber nicht wie es dies
leisten soll
• Unterscheidung in Geschäftsanwendungsfall (business use
case) formuliert aus Geschäftssicht (z. B. Vertriebsprozess vom
Anfang) und Systemanwendungsfall (system use case)
formuliert aus Sicht der durch die neue SW zu lösenden
Aufgabe
Grundkurs Software-Engineering mit UML
Stephan Kleuker
86
Zusammenhang der Use Case Arten
• Für ein neu geplantes SW-System wird zunächst analysiert,
welche Prozesse mit der SW unterstützt werden sollen
(Geschäftsprozessmodellierung)
• Oft geht mit dieser Modellierung auch eine Optimierung einher
• Man erhält zentrale Aufgaben, die das SW-System übernehmen
soll (Business Use Case)
• Ausgehend davon werden die Aufgaben geplant, die das SWSystem unterstützen/ausführen soll, dies sind die System Use
Cases
• Häufig gehört zu einem Business Use Case ein System Use
Case, d. h. es gibt die gleiche Überschrift, aber eine
unterschiedliche Beschreibung (im System Use Case steht die
Nutzung des neues SW-Systems im Mittelpunkt)
• Es kann weitere System Use Cases geben, die z. B. die
Systemwartung oder neue Analysemöglichkeiten betreffen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
87
Wege zur Use Case-Ermittlung
•
•
•
•
•
•
moderierter Workshop zentraler Stakeholder
Beobachtung des Kunden, der Endnutzer
Fragebögen
Interviews
Kunde vor Ort im Projekt
Analyse von Altsystemen und Dokumenten des
Kunden
• Simulationsmodelle
Grundkurs Software-Engineering mit UML
Stephan Kleuker
88
Darstellungsbeispiel: Lagerverwaltungssystem
Externe Sicht des Nutzers
auf die Aufgaben des
Systems
Aktoren können Personen
oder andere Systeme sein
Use Cases können in
Teilpaketen strukturiert
werden
Grundkurs Software-Engineering mit UML
Stephan Kleuker
89
Systematische Use-Case Ermittlung (1/2)
1. Welche Basisinformationen / Objekte sind zu bearbeiten (keine
Detailmodellierung, keine Informationen, die aus anderen
berechenbar sind)?
Beispiel (Projektmanagementsystem): Projekte, Mitarbeiter
Prüfe ob neues System Basisinformationen verwaltet oder Sie
aus existierenden Systemen stammen
neues System: Use Case „Basisinformation XY verwalten“
gefunden (evtl. in „anlegen“, „bearbeiten“, „löschen“
trennen)
existierendes System: tritt als Aktor auf, wenn Daten benötigt
2. Welche Prozessinformationen sind zu verwalten, also
dynamisch entstehende Daten, Daten zur Verknüpfung von
Basisinformationen
Beispiel: Projektteams, Arbeitsstunden der Mitarbeiter
Ergänze Use Cases, die die Verknüpfung der Daten herstellen,
z. B. „Projektteams zusammenstellen“, „Arbeitsstand
aktualisieren“
Grundkurs Software-Engineering mit UML
Stephan Kleuker
90
Systematische Use-Case Ermittlung (2/2)
3. Ermittle Funktionalität, die auf Basis der Verarbeitung von
Basis- und Prozessinformationen benötigt wird
abstrakte Beispiele: Entscheidungsprozesse/
Analyseprozesse zur Auswertung (Statistiken, Übersichten)
Ergänze Use Case für jede der Prozessarten (Art bedeutet,
Zusammenfassung eng verwandter Funktionalität)
Beispiel: „Projektstand analysieren“
4. Ermittle Use Cases zur reinen Systempflege insofern es
besondere Herausforderungen gibt
abstrakte Beispiele: langfristige Datenhaltung, Systemstart,
Systemterminierung
Zeichne Use Case-Diagramm und ergänze Aktoren (z. B.
Stakeholder, genutzte Systeme, Time) und Dokumentation
Grundkurs Software-Engineering mit UML
Stephan Kleuker
91
Abgeleitetes Use Case-Diagramm
Grundkurs Software-Engineering mit UML
Stephan Kleuker
92
Use Case-Erstellung genauer
• Beschreibung eines Use Cases
– zunächst verbal
– relativ abstrakt, wird später verfeinert
• Leitfragen für die Ermittlung von Akteuren und Prozessen
– Welcher Akteur löst Use Case aus?
– Welche Akteure sind am Use Case beteiligt?
– Welche Aufgaben sind im Use Case zu erfüllen?
– Wer ist verantwortlich für Planung, Durchführung, Kontrolle
der Aufgaben?
– Welche Ereignisse starten den Use Case, treten im Use Case
auf?
– Welche Bedingungen sind zu beachten?
– Was sind die Ergebnisse des Use Cases?
– Welche Beziehungen gibt es zu welchen anderen Use Cases?
Grundkurs Software-Engineering mit UML
Stephan Kleuker
93
Verfeinerung der Use Case-Dokumentation
4.3
• Im ersten Schritt werden in den Use Cases nur die
Hauptaufgaben des Systems beschrieben
• Zur Dokumentation der Use Cases gehört zunächst
nur eine grobe kurze Beschreibung (maximal 5
Sätze) des Inhalts
• Im nächsten Schritt wird dieser Inhalt konkretisiert.
Dabei ist es sinnvoll, auf eine
Dokumentationsschablone zurück zu greifen (oder
eine für das Projekt zu entwickeln)
• Im ersten Schritt der Beschreibungsentwicklung
wird nur der typische Ablauf des Use Cases ohne
Alternativen, dann mit Alternativen beschrieben
Grundkurs Software-Engineering mit UML
Stephan Kleuker
94
Dokumentationsschablone für Use Cases (1/3)
Name des Use
Case
Nummer
1
Paket
2
Autor
1
Version
1
Kurzbeschreibung
beteiligte
Aktoren
(Stakeholder)
1
1
1
kurze prägnante Beschreibung, meist aus Verb
und Nomen
eindeutige Nummer zur Verwaltung, sollte von der
eingesetzten Entwicklungsumgebung vergeben
werden
bei sehr komplexen Systemen können Use Cases
in Teilaufgabenbereiche zusammengefasst
werden, diese Bereiche können in der UML als
Pakete dargestellt werden
wer hat den Use Case erstellt und wer
mitgearbeitet
aktuelle Versionsnummer, möglichst mit
Änderungshistorie, wer hat wann was geändert
kurze Beschreibung, was mit dem Use Case auf
welchem Weg erreicht werden soll,
welche Aktoren sind beteiligt, wer stößt den Use
Case an
Grundkurs Software-Engineering mit UML
Stephan Kleuker
95
Dokumentationsschablone für Use Cases (2/3)
Fachverantwortlicher
1
Referenzen
2
Vorbedingungen
Nachbedingungen
2
typischer
Ablauf
2
alternative
Abläufe
3
2
wer steht auf fachlicher Seite für Fragen zum Use
Case zur Verfügung und entscheidet auf
Auftraggeberseite für die Software über den Inhalt
Nennung aller Informationen, die bei der späteren
Ausimplementierung zu beachten
beziehungsweise hilfreich sind, dies können
Verweise auf Gesetze, Normen oder
Dokumentationen existierender Systeme sein
was muss erfüllt sein, damit der Use Case starten
kann
wie sieht das mögliche Ergebnis aus, im nächsten
Schritt sind auch die Ergebnisse alternativer
Abläufe zu berücksichtigen
welche einzelnen Schritte werden im Use Case
durchlaufen, dabei wird nur der gewünschte
typische Ablauf dokumentiert
welche Alternativen existieren zum typischen
Ablauf
Grundkurs Software-Engineering mit UML
Stephan Kleuker
96
Dokumentationsschablone für Use Cases (3/3)
Kritikalität
3
Verknüpfungen 3
funktionale
4
Anforderungen
nicht4
funktionale
Anforderungen
wie wichtig ist diese Funktionalität für das
Gesamtsystem
welche Zusammenhänge bestehen zu anderen
Use Cases
welche konkreten funktionalen Anforderungen
werden aus diesem Use Case abgeleitet
welche konkreten nicht-funktionalen
Anforderungen werden aus diesem Use Case
abgeleitet
• Nummer gibt Iteration an, in der das Feld gefüllt wird
• typischer und alternative Abläufe werden jetzt genauer
betrachtet
• funktionale und nicht-funktionale Anforderungen weiter
hinten in diesem Abschnitt
Grundkurs Software-Engineering mit UML
Stephan Kleuker
97
Beispielbeschreibung (1/2)
Name des Use
Case
Projektstruktur bearbeiten
Nummer
U1
Paket
-
Autor
Ali Analytiker
Version
1.0, 30.01.2013, Erstellung
Kurzbeschreibung
Mitarbeiter des Projektbüros haben die Möglichkeit,
Projekte mit Teilprojekten anzulegen und zu
bearbeiten.
beteiligte
Aktoren
(Stakeholder)
Projektbüro (startet Use Case durch Auswahl der
Funktionalität im zu erstellenden System)
Fachverantwortlicher
Lisa Leitung (zentrale Ansprechpartnerin des Kunden)
Referenzen
Handbuch zur Führung von Projekten des Kunden
Grundkurs Software-Engineering mit UML
Stephan Kleuker
98
Beispielbeschreibung (2/2)
Vorbedingungen
Die Software ist vollständig installiert und wurde
gestartet.
Nachbedingungen
Neue Projekte und Teilprojekte sowie Änderungen von
Projekten und Teilprojekten wurden vom System
übernommen.
typischer Ablauf 1. Nutzer wählt Funktionalität zur Bearbeitung von
Projektstrukturen
2. Nutzer legt Projekt mit Projektstandarddaten an
3. Nutzer ergänzt neue Teilprojekte
4. Nutzer verlässt Funktionalität
alternative
Abläufe
Nutzer kann existierendes Projekt auswählen,
Nutzer kann Daten eines Teilprojekts ändern
Kritikalität
sehr hoch, System macht ohne Funktionalität keinen
Sinn
Grundkurs Software-Engineering mit UML
Stephan Kleuker
99
Hinweise zu Use Cases (1/2)
• Verwende für den Use Case eine sinnvolle
Bezeichnung, die mindestens aus einem echten
Substantiv und einem aktiven Verb ("Antrag
erfassen") oder dem zugehörigen Gerundium
("Antragserfassung") besteht!
• Definiere zuerst den fachlichen Auslöser und das
fachliche Ergebnis, um Anfang und Ende des Use
Cases festzulegen!
• Formuliere den Use Case so abstrakt wie möglich
und so konkret wie nötig!
• Betreibe zunächst keine Zerlegung in abgeleitete,
sekundäre Use Cases!
• Standardisiere die Sprache in den Use Cases!
Grundkurs Software-Engineering mit UML
Stephan Kleuker
100
Hinweise zu Use Cases (2/2)
• Use Cases eignen sich nicht zur funktionalen
Zerlegung, d.h. ein Use Case beschreibt keine
einzelnen Schritte, Operationen oder Transaktionen
(bspw. "Vertrag drucken", "Kunden-Nr. erzeugen"
etc.), sondern relativ große Abläufe (bspw. "Neuen
Kunden aufnehmen")
• Es wird keine Ablaufreihenfolge definiert. Hierzu gibt
es andere Ausdrucksmittel, z.B. Aktivitätsdiagramme
• Use Cases belassen das Sprachmonopol beim
Stakeholder, wodurch die Use Cases angreifbarer
und besser kritisierbar werden
Grundkurs Software-Engineering mit UML
Stephan Kleuker
101
Analyse von Use-Case-Dokumentationen
• Bei der Dokumentation von Use Cases kann es
passieren, dass identische Abläufe mehrfach
beschrieben werden
• Diese (nicht trivialen) Abläufe können als eigene Use
Cases ausgegliedert werden; man sagt dann „ein
Use Case nutzt einen anderen Use Case“
• UML-Darstellung:
A
<<include>>
B
• In spitzen <<Klammern>> stehen so genannte
Steoreotypen, mit denen man UML-Elementen
zusätzliche Eigenschaften zuordnen kann
Grundkurs Software-Engineering mit UML
Stephan Kleuker
102
Beispiel zu <<include>>
Grundkurs Software-Engineering mit UML
Stephan Kleuker
103
<<extend>>
• Seltene Variation des erweiterten Use Cases
• Wird nur unter bestimmter Bedingung ausgeführt, z. B.
Sonderfall oder Fehlerbehandlung
• eigentlicher Use Case nicht durch Spezialfälle überfrachtet
Grundkurs Software-Engineering mit UML
Stephan Kleuker
104
Hinweis zu <<include>>, <<extend>> (persönlich)
• <<include>> ist ein sehr nützlicher Stereotyp, der die
Dokumentation verkürzen kann
• Gerade bei in der Modellierung unerfahrenen
Kunden sollte <<include>> zunächst verheimlicht
werden, da sonst funktionale Zerlegungen in
Bäumen das Ergebnis sind
• <<include>> wird dann bei der Dokumentation und
späteren Verfeinerung bei der Umstrukturierung der
Use Cases als Optimierung eingesetzt
• Hinweis: <<extend>> und weitere nicht erwähnte
Möglichkeiten werden hier ignoriert, da es Kunden
eher verwirrt
Grundkurs Software-Engineering mit UML
Stephan Kleuker
105
Beschreibung verschiedener Abläufe
• Bei Projekten mit enger Kundenbindung (z.B. bei
engen Beziehungen zwischen AG und IT-Abteilung
bei Inhouse-Projekten) können Use Cases (oder
Nutzer Stories) als Anforderungsdokumentation
ausreichen, wenn das Projekt in kleinen Iterationen
und der Möglichkeit eines großen Kundeneinflusses
entwickelt wird
• Oftmals ist die Beschreibung der Use Cases aber zu
ungenau, gerade bei der Darstellung typischer und
Alternativer Abläufe stellt sich die rein sprachliche
Beschreibung als recht aufwändig heraus
• Da die UML eine graphische Sprache ist, stellt sie
auch für Ablaufbeschreibungen eine grafische
Darstellungsmöglichkeit, nämlich
Aktivitätsdiagramme, zur Verfügung
Grundkurs Software-Engineering mit UML
Stephan Kleuker
106
Modellierungsrichtlinie für Aktivitätsdiagramme
Modelliere zu jedem Use Case genau ein Aktivitätsdiagramm
• Mache aus den Use Case-Schritten Aktionen.
• Zerlege die Aktionen ggfls. mit einem Aktivitätsdiagramm, so
dass sie stets genau einen fachlichen Arbeitsschritt
repräsentieren.
• Ergänze den Ablauf um alle bekannten fachlichen Ausnahmen,
fachlichen Fehler und fachlichen Ablaufvarianten, so dass das
Diagramm eine vollständige Beschreibung aller zulässigen
Ablaufmöglichkeiten darstellt.
(sinnvoll jetzt oder später) Modelliere den Objektfluss:
• Beschreibe zu jeder Aktion die vorausgesetzten (zu
verarbeitenden) und resultierenden (erzeugten oder
veränderten) Geschäftsobjekte (Produkte).
• Unterscheide, bei welchen ausgehenden Transitionen bzw.
Bedingungen welche Objekte bzw. Objektzustände resultieren.
Grundkurs Software-Engineering mit UML
Stephan Kleuker
107
Aktivitätsdiagramm mit typischen Ablauf
Use Case: Projektstruktur bearbeiten
Anmerkung: typischer Ablauf ist immer einfache Sequenz von
Aktionen, Ausnahme wie hier: einfache Schleifen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
108
Aktivitätsdiagramm um Alternativen ergänzt
Grundkurs Software-Engineering mit UML
Stephan Kleuker
109
Erinnerung: Modellierung aus Business-Sicht
Grundkurs Software-Engineering mit UML
Stephan Kleuker
110
Modellierung aus System-Sicht
Grundkurs Software-Engineering mit UML
Stephan Kleuker
111
Formulierung von Anforderungen
4.4
• Analog zu den Use Cases sind die Aktivitätsdiagramme zu
dokumentieren, dabei ist genau zu beschreiben, was unter
Nutzung welcher Hilfsmittel unter Berücksichtigung welcher
Nebenbedingungen gilt
• Die Beschreibungen können oft unvollständig oder unklar
formuliert sein, so dass es in größeren oder kritischeren
Projekten sinnvoll ist, die Texte genauer zu analysieren
• Statt einer Fließtextdokumentation von Aktivitätsdiagrammen,
kann eine Darstellung von systematisch abgeleiteten textuellen
Anforderungen sinnvoll sein
• Man benötigt einen Ansatz, Texte möglichst präzise zu
formulieren
Grundkurs Software-Engineering mit UML
Stephan Kleuker
112
Probleme mit natürlich-sprachlichen Formulierungen
• Hauptprozesse der menschlichen Modellbildung
– Tilgung
– Generalisierung
– Nominalisierung
• Problem: Anforderungen werden für Menschen mit
anderer Modellbildung (da andere Erfahrungen)
unsauber formuliert
• In Prosatexten sind Wiederholungen unerwünscht;
bei Anforderungen müssen immer die gleichen
Worte für den gleichen Sachverhalt genutzt werden
Grundkurs Software-Engineering mit UML
Stephan Kleuker
113
Definition: Tilgung
• Tilgung ist ein Prozess, durch den wir unsere
Aufmerksamkeit selektiv bestimmten Dimensionen
unserer Erfahrungen zuwenden und andere
ausschließen. (Bandler/Grinder)
• Beispiel: Die Fähigkeit des Menschen, In einem
Raum voller sprechender Menschen alle anderen
Geräusche auszuschließen oder auszufiltern, um der
Stimme einer bestimmten Person zuzuhören.
• Anforderungen: implizite Annahmen, unvollständige
Vergleiche
Grundkurs Software-Engineering mit UML
Stephan Kleuker
114
Beispiele für Tilgungen (1/2)
• Grundstruktur: Manche Prozessworte (Verben und
Prädikate) implizieren zwei oder mehr
Substantivargumente
• Sprachliche Vertreter
– Eingeben: Wer? Was? Wie? Wo? Wann?
– Anzeigen: Was? Wo? In welcher Weise? Wann?
– Übertragen: Wer? Was? Von wo? Wohin? Wann?
– „Die Auszahlungsmöglichkeit soll überprüft und
die Auszahlung verbucht werden“
– Überprüfen: Wer überprüft? Was wird überprüft?
Nach welchen Regeln wird überprüft? Wann wird
überprüft? Wie?
– Verbuchen: Wer verbucht? Was wird verbucht?
Wann wird es verbucht? Wie?
Grundkurs Software-Engineering mit UML
Stephan Kleuker
115
Beispiele für Tilgungen (2/2)
• Grundstruktur: Der Bezugspunkt. die Messbarkeit und die
Messgenauigkeit für einen Komparativ oder Superlativ fehlt.
• Sprachliche Vertreter: Adjektiv + Endung "-er/en", "-ste" oder
"more", "less", "least", oder "weniger", "mehr"
• In beiden Sprachen: Adjektive wie leicht, easy, schwer,
complicated, ...
• Für durchschnittlich große Menschen soll das Display im
normalen Bedienabstand gut lesbar sein.
• Die Eingabe des angeforderten Geldbetrages soll vom System
durch eine intuitive Benutzerführung so unterstützt werden,
dass Fehleingaben minimiert werden.
– Kann man den Sachverhalt überhaupt messen?
– Ist der Bezugspunkt des Vergleiches angegeben?
– Mit welcher Messgenauigkeit wird gemessen?
Grundkurs Software-Engineering mit UML
Stephan Kleuker
116
Definition: Generalisierung
• Generalisierung ist der Prozess, durch den Elemente
oder Teile eines persönlichen Modells von der
ursprünglichen Erfahrung abgelöst werden, um dann
die gesamte Kategorie, von der diese Erfahrung ein
Beispiel darstellt, zu verkörpern. (Bendler/Grindler)
• Beispiel: Ein Kind verbrennt sich an einer heißen
Herdplatte die Hand. Es sollte für sich die richtige
Generalisierung aufstellen, dass es schmerzhaft ist
auf heiße Herdplatten zu fassen.
• Anforderungen: Universalquantoren, unvollständige
Bedingungen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
117
Generalisierung durch Universalquantoren
Universalquantoren
• Grundstruktur: Menge an Objekten wird
zusammengefasst
• Sprachliche Vertreter:
– Im Deutschen: nie, immer, kein, jeder, alle, ...
– Im Englischen: never, ever, not, each, always, ...
• Frage:
– Wirklich alle/jede, immer/nie? Gibt es keine
Ausnahme?
– Achtung! Auch Sätze ohne Universalquantoren
überprüfen, die keine Angaben über die Häufigkeit
enthalten!
Grundkurs Software-Engineering mit UML
Stephan Kleuker
118
Beispiele für Generalisierungen
• Jede Auszahlung soll für die Rückverfolgbarkeit
zusätzlich mit einem Zeitstempel etikettiert werden.
– Wirklich jede Auszahlung?
• Das System soll eine Sicherung von aufgezeichneten
Auszahlungsdaten auf ein externes Speichermedium
ermöglichen.
– Durch jede Person? Immer? Aller
Auszahlungsdaten?
Grundkurs Software-Engineering mit UML
Stephan Kleuker
119
Definition: Verzerrung
• Verzerrung ist der Prozess, etwas mittels
Überlegungen, Fantasie oder Wünschen, so
umzugestalten, dass ein neuer Inhalt oder eine neue
Bedeutung entsteht. (Dörrenbacher)
• Beispiel: Behauptung, dass auf A dann B folgt oder
Gedankenlesen
– Da jemand zu spät ist, ist das Projekt gefährdet
– Ich denke, der mag mich nicht
– Er wollte wissen, wie ich mich jetzt fühle
Grundkurs Software-Engineering mit UML
Stephan Kleuker
120
Verzerrung: Beispiele und Analyse
• Der Nutzer muss zunächst sein Login und dann sein
Passwort eingeben.
• Dem Nutzer muss am Anfang immer die
Übersichtsseite gezeigt werden.
• Der Nutzer muss eingeloggt sein, um die Übersicht
zu sehen.
• Was führt zur Annahme, dass diese Reihenfolgen
notwendig sind?
• Was würde sich bei einer anderen Reihenfolge oder
Verlassen einer Einschränkung ändern?
Grundkurs Software-Engineering mit UML
Stephan Kleuker
121
Verzerrung durch Nominalisierung
• Grundstruktur: Ein Prozesswort (Verb oder Prädikat) wird zu
einem Ereigniswort (Substantiv oder Argument) umgeformt.
• Dadurch wird ein Vorgang zu einem Ereignis und viele
vorgangsrelevante Informationen gehen verloren.
• Es ist möglich, dass sich die Bedeutung der Aussage dadurch
ändert.
– Die Berechtigung für die Administration des Geldautomaten
– Die Auszahlung wird nach der Buchung durchgeführt
– Wer? zahlt wann? Wem? Was? Unter Einhaltung welcher
Regeln? Mit welcher Zuverlässigkeit? Mit welcher
Verfügbarkeit?
– Wer? bucht wann? Was? Wohin? Unter Einhaltung welcher
Regeln? Mit welcher Zuverlässigkeit? Mit welcher
Verfügbarkeit?
Grundkurs Software-Engineering mit UML
Stephan Kleuker
122
Erkennen von Nominalisierungen
Fragen/Vorgehen:
• Intuition, Sprachgefühl
• Suche nach ähnlichem Prozesswort
• Sprachtest durch Einsetzen in "ein(e) andauernde(r) …".
Wahre Substantive passen nicht in diese Aussage
Beispiele:
• Bei der Auswahl der Auszahlungsfunktion soll die …
• der Anzeige, Benutzerführung, Bestätigung, ....
• die Eingabe, Erfassung, ....
• das Ereignis, die Meldung, ...
• die Buchung, Ausgabe, Prüfung, ....
Anmerkung: Nominalisierung wird oft auch als Tilgung angesehen
http://nlpportal.org/nlpedia/wiki/Metamodell
Grundkurs Software-Engineering mit UML
Stephan Kleuker
123
Entwicklung strukturierter Anforderungen
• ein Ansatz zu qualitativ hochwertigen
Anforderungen: erste Version erstellen und dann
Textqualität schrittweise verbessern
• Alternative: „von Anfang an“ hochwertige
Anforderungen zu schreiben
• Dieser Ansatz kann durch Anforderungsschablonen
unterstützt werden, die den Satzbau von
Anforderungen vorgeben (vorgestellter Ansatz folgt
[RS])
• Man beachte, bereits erwähnte Ausdrucksprobleme
auch in diesem Ansatz noch relevant
Grundkurs Software-Engineering mit UML
Stephan Kleuker
124
Charakterisierung von Systemaktivitäten
• Selbständige Systemaktivität:
Das System führt den Prozess selbständig durch.
• Benutzerinteraktion:
Das System stellt dem Nutzer die
Prozessfunktionalität zur Verfügung.
• Schnittstellenanforderung:
Das System führt einen Prozess in Abhängigkeit von
einem Dritten (zum Beispiel einem Fremdsystem)
aus, ist an sich passiv und wartet auf ein externes
Ereignis.
• Für jede dieser Systemaktivitäten gibt es eine
Schablone.
• Frage: Werden Systemaktivitäten so in disjunkte
Klassen aufgeteilt?
Grundkurs Software-Engineering mit UML
Stephan Kleuker
125
Visualisierung der Systemaktivitäten
T yp 2 A n fo rd e ru n g e n :
F u n k tio n a litä t z u r
V e rfü g u n g s te lle n
T yp 1 A n fo rd e ru n g e n :
S ys te m fü h rt P ro z e s s
aus
s tö ß t a n
N u tz e r
ru ft a u f
S ch n ittste lle
e xte rn e r
P ro z e s s
s tö ß t
an
zu e n tw icke ln d e s S yste m
S ys te m -K e rn
m acht
E in g a b e n
T yp 3 A n fo rd e ru n g e n :
S ys te m fä h ig , e xte rn e
A n fra g e z u b e a rb e ite n
Grundkurs Software-Engineering mit UML
Stephan Kleuker
126
Anforderungsformulierung (Rupp-Schablone)
-
muss
<Wann?>
<Randbedingung>
soll
Typ 1
Typ 2
das
System
<wem?> die
Möglichkeit
bieten
<Objekt mit
Randbedingung>
<Prozesswort>
wird
fähig sein Typ 3
Typ 1: Selbständige Systemaktivität, System führt Prozess
selbständig durch, z. B. Berechnung des bisherigen Aufwandes
eines Projekts durch Abfrage aller Teilprojekte und Ergebnisanzeige
Typ 2: Benutzerinteraktion, System stellt Nutzer die
Prozessfunktionalität zur Verfügung, z: B. Verfügbarkeit eines
Eingabefeldes, um den Projektdaten einzugeben
Typ 3: Schnittstellenanforderung, d. h. das System führt einen
Prozess in Abhängigkeit von einem Dritten (zum Beispiel einem
Fremdsystem) aus, ist an sich passiv und wartet auf ein externes
Ereignis, z. B. Anfrage einer anderen Bürosoftware nach einer
Übersicht über die laufenden Projekte annehmen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
127
Typ 1: Selbständige Systemaktivität
-
muss
<Wann?>
<Randbedingung>
soll
Typ 1
Typ 2
das
System
<wem?> die
Möglichkeit
bieten
<Objekt mit
Randbedingung>
<Prozesswort>
wird
fähig sein Typ 3
Nach Abschluss der Eingabe (mit „Return“-Taste oder
Bestätigungsknopf) bei der Bearbeitung von Daten muss das
System neu eingegebene Daten in seine permanente Datenhaltung
übernehmen. [„Daten“ muss konkretisiert werden]
Nach der Eingabe eines neuen Teilprojekts oder einer neuen
Projektaufgabe und nach der Aktualisierung des Aufwandes eines
Teilprojekts oder einer neuen Projektaufgabe muss das System
die Aufwandsangaben auf Plausibilität prüfen.
Grundkurs Software-Engineering mit UML
Stephan Kleuker
128
Typ 2: Benutzerinteraktion
-
muss
<Wann?>
<Randbedingung>
soll
Typ 1
Typ 2
das
System
<wem?> die
Möglichkeit
bieten
<Objekt mit
Randbedingung>
<Prozesswort>
wird
fähig sein Typ 3
In der Projektbearbeitung muss das System dem Nutzer die
Möglichkeit bieten, ein neues Projekt mit Projektausgangsdaten
anzulegen.
In der Projektbearbeitung muss das System dem Nutzer die
Möglichkeit bieten, jedes Projekt auszuwählen.
Nach der Projektauswahl muss das System dem Nutzer die
Möglichkeit bieten, für existierende Projekte neue Teilprojekte
anzulegen.
Grundkurs Software-Engineering mit UML
Stephan Kleuker
129
Typ 3: Schnittstellenanforderung
-
muss
<Wann?>
<Randbedingung>
soll
Typ 1
Typ 2
das
System
<wem?> die
Möglichkeit
bieten
<Objekt mit
Randbedingung>
<Prozesswort>
wird
fähig sein Typ 3
Nach der Kontaktaufnahme durch die Software „Globalview“ muss
das System fähig sein, Anfragen nach den Projektnamen, deren
Gesamtaufwänden und Fertigstellungsgraden anzunehmen.
(folgt Typ2: Nach der Annahme der Anfrage … )
Grundkurs Software-Engineering mit UML
Stephan Kleuker
130
Vom Aktivitätsdiagramm zur textuellen Anforderung
• Jede Aktion wird mit einer Anforderung oder
mehreren Anforderungen beschrieben
• Jede Transition und Entscheidung wird mit einer
Anforderung oder mehreren Anforderungen
beschrieben
• Aus dem Ablauf der zur Aktion, Transition oder
Entscheidung führt, wird der erste Teil der jeweiligen
Anforderung („Wann?“) erzeugt.
• Hinweis: Anforderungen zum Beispiel stehen im
folgenden Kapitel
Grundkurs Software-Engineering mit UML
Stephan Kleuker
131
Beispielübersetzung
Grundkurs Software-Engineering mit UML
Stephan Kleuker
132
Nicht-funktionale Anforderungen (1/2) [sehr kurz]
4.5
• Bisher lag der Schwerpunkt auf funktionalen Anforderungen
„was muss das System machen“
• SW unterliegt unterschiedlichen nicht-funktionalen
Anforderungen, die maßgeblich für den Projekterfolg sein
können
Hier wird eine Charakterisierung vorgestellt:
• technische Anforderungen: Hardwareanforderungen,
Architekturanforderungen, Anforderungen an die
Programmiersprachen
• Anforderungen an die Benutzungsschnittstelle: Form und
Funktion von Ein- und Ausgabe-Geräten
• Anforderungen an die Dienstqualität: DIN EN ISO 66272
unterteilt die Dienstgüte in die fünf Merkmale Zuverlässigkeit,
Benutzbarkeit, Effizienz, Änderbarkeit und Übertragbarkeit
Grundkurs Software-Engineering mit UML
Stephan Kleuker
133
Nicht-Funktionale Anforderungen (2/2)
• Anforderungen an sonstige Lieferbestandteile: Selten besteht
das System nur aus einem Stück kompilierten Programmcodes,
es werden Zusatzlieferungen, wie Systemhandbücher und
Installationshandbücher gefordert
• Anforderungen an die Durchführung der Entwicklung und
Einführung: z. B. Anforderungen an die Vorgehensweise
(Software-Erstellung, Software-Prüfung), anzuwendende
Standards, Hilfsmittel (Tools), die Durchführung von
Besprechungen, von Abnahmetests (fachliche Abnahme,
betriebliche Abnahme) und die Festlegung von Terminen
• rechtlich-vertraglichen Anforderungen: z. B. Angaben zu
Zahlungsmeilensteinen, Vertragsstrafen, dem Umgang mit
Änderungen der Anforderungen, Eskalationspfade
Grundkurs Software-Engineering mit UML
Stephan Kleuker
134
Lastenheft / Pflichtenheft
4.6 •
Lastenheft wird vom Auftraggeber (Kunden)
geschrieben
– welche Funktionalität ist gewünscht
– welche Randbedingungen (SW/ HW) gibt es
• Pflichtenheft wird vom Auftragnehmer (SoftwareEntwicklung) geschrieben
– welche Funktionalität wird realisiert
– auf welcher Hardware läuft das System
– welche SW-Schnittstellen (Versionen)
berücksichtigt
• Variante: Kunde beauftragt Auftragnehmer direkt in
Zusammenarbeit Pflichtenheft zu erstellen
– ein gemeinsames Heft ist sinnvoll
– Pflichtenheft ist meist (branchenabhängig) zu
bezahlen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
135
Lastenheft / Pflichtenheft: möglicher Aufbau
0. Administrative Daten: von wem, wann genehmigt, ...
1. Zielbestimmung und Zielgruppen
In welcher Umgebung soll System eingesetzt werden?
Ziele des Systems, welche Stakeholder betroffen?
2. Funktionale Anforderungen
Produktfunktionen (Use Cases, Aktivitätsd.,
Anforderungen)
Produktschnittstellen (a.GUI-Konzept b. andere SW)
3. Nichtfunktionale Anforderungen
Qualitätsanforderungen
weitere technische Anforderungen
4. Lieferumfang
5. Abnahmekriterien
6. Anhänge (insbesondere Glossar)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
136
5. Grobdesign
5.1
5.2
5.3
5.4
5.5
Systemarchitektur
Ableitung von grundlegenden Klassen
Ableitung von Methoden und Kontrollklassen
Validierung mit Sequenzdiagrammen
Überlegungen zur Oberflächenentwicklung
Grundkurs Software-Engineering mit UML
Stephan Kleuker
137
Systemarchitektur
5.1
Festlegen der Randbedingungen bzgl. Hardware, Betriebssystem,
verwendeter Software, zu integrierender Systeme
• Vorgabe der Hardware, die Software muss z. B. auf einer
Spezialhardware funktionieren
• Vorgabe des Betriebssystems, die Software muss eventuell mit
anderer Software auf Systemebene zusammenarbeiten
• Vorgabe der Middleware, die Software wird häufig auf
verschiedene Prozesse verteilt, die miteinander kommunizieren
müssen
• Vorgaben zu Schnittstellen und eingesetzten
Programmiersprachen, die Software soll mit anderer Software
kommunizieren und muss dabei deren Schnittstellen
berücksichtigen
• Vorgaben zum „Persistenzframework“, die Daten der zu
erstellenden Software müssen typischerweise langfristig
gespeichert werden
Grundkurs Software-Engineering mit UML
Stephan Kleuker
138
Beispiel: Projektstrukturplan
5.2
P ro je k t
P e rp e tu u m
(T e il-)P ro je k t
A u fg a b e
P ro je k tle itu n g
P . P a la v e r (3 0 % )
Q u a litä ts s ic h e ru n g
P ro je k tin fra s tru k tu r
Q S -L e itu n g
G . G e n a u (3 0 % )
A d m in s tra tio n
S . S u p e r (2 0 % )
T e s te r
P . P e n ib e l (1 0 0 % )
In s ta lla tio n
P . P rö k e l (5 0 % )
E n tw ic k lu n g
E n tw ic k lu n g s le itu n g
P . P a la v e r (7 0 % )
S ic h e ru n g
S . S a fe (2 0 % )
O b e rflä c h e n e n tw ic k lu n g
P ro g ra m m ie ru n g
W . W id g e t (1 0 0 % )
B u s in e s s m o d e ll
D a te n b a n k a n b in d u n g
A n a ly s e
S . S c h la u b i (1 0 0 % )
P ro g ra m m ie ru n g
E . E n titä t (1 0 0 % )
P ro g ra m m ie ru n g
M . M u s te r (1 0 0 % )
P ro g ra m m ie ru n g
H . H a c k (1 0 0 % )
Grundkurs Software-Engineering mit UML
Stephan Kleuker
139
Erste Iteration: Klassen finden
• Aktivitätsdiagramme werden durch Anforderungen
konkretisiert
• Text der Anforderungen ist Grundlage zum Finden
erster Klassen
• Im Text werden Objekte identifiziert; sind Individuen,
die durch Eigenschaften (Exemplarvariablen) und
angebotene Funktionalität charakterisiert werden
• grober Ansatz: Nomen in Anforderungen und
Glossar ansehen; können Objekte oder
Eigenschaften sein
• Adjektive können auf Eigenschaften hindeuten
• Informationen in Klassen gesammelt; Klassen
beschreiben Struktur, die jedes Objekt hat
Grundkurs Software-Engineering mit UML
Stephan Kleuker
140
Analyse der Anforderungen (1/5)
A1.1: In der Projektbearbeitung muss das System dem Nutzer die
Möglichkeit bieten, ein neues Projekt mit Projektausgangsdaten
anzulegen.
• Glossar Projektausgangsdaten: automatisch vergebene
eindeutige Projektnummer, Projektname, geplanter Start- und
Endtermin, geplanter Aufwand.
• gefunden: Klasse Projekt mit Exemplarvariablen
Projektnummer, Projektname, geplanter Starttermin, geplanter
Endtermin, geplanter Aufwand
A1.2: Nach Abschluss der Eingabe (mit „Return“-Taste oder
Bestätigungsknopf) bei der Bearbeitung von Daten muss das
System neu eingegebene Daten in seine permanente
Datenhaltung übernehmen.
A1.3: In der Projektbearbeitung muss das System dem Nutzer die
Möglichkeit bieten, jedes Projekt auszuwählen.
• gefunden: keine Klassen oder Exemplarvariablen
(Funktionalität später)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
141
Analyse der Anforderungen (2/5)
A1.4: Nach der Projektauswahl muss das System dem Nutzer die
Möglichkeit bieten, für existierende Projekte neue Teilprojekte
anzulegen.
gefunden: Exemplarvariable Teilprojekte für Projekt, (eventuell)
neue Klasse Teilprojekt
A1.5: Bei der Projektdatenbearbeitung muss das System
Teilprojekte wie Projekte behandeln und dem Nutzer die
gleichen Möglichkeiten zur Bearbeitung bieten.
• Teilprojekt und Projekt sind für die Software Synonyme,
deshalb keine eigene Klasse
• generell auf Synonyme (verschiedene Wörter mit gleicher
Bedeutung) und Homonyme (Wörter mit verschiedenen
möglichen Bedeutungen achten)
A1.6: Nach der Projektauswahl muss das System dem Nutzer die
Möglichkeit bieten, den realen Starttermin, das aktuell
kalkulierte Fertigstellungsdatum, den geplanten Aufwand und
den Projektkommentar zu bearbeiten.
• Exemplarvariablen für Projekt: realer Starttermin, aktuelles
Fertigstellungsdatum, Kommentar
Grundkurs Software-Engineering mit UML
Stephan Kleuker
142
Analyse der Anforderungen (3/5)
A1.7: Nach der Projektauswahl muss das System dem Nutzer die
Möglichkeit bieten, neue Teilaufgaben mit dem
Aufgabennamen, dem geplanten Start- und Endtermin, dem
Arbeitsanteil des Mitarbeiters und dem geplanten Aufwand zu
definieren.
• Glossar Projektaufgabe: Teilaufgabe in einem Projekt, die einen
Namen und einen eindeutigen Bearbeiter hat, der zu einem
gewissen Prozentsatz der Aufgabe zugeordnet ist, die einen
geplanten und realen Aufwand, geplante und reale Start- und
Endtermine und einen Fertigstellungsgrad hat und die nicht
weiter verfeinert wird.
• Glossar Fertigstellungsgrad: Für Projektaufgaben geben die
jeweiligen Bearbeiter den Fertigstellungsgrad in % an. Die
Bearbeiter sind angewiesen, dass bei einer Bearbeitung ohne
besondere Probleme dieser Wert möglichst linear wächst. Der
Fertigstellungsgrad von Projekten wird aus den
Fertigstellungsgraden der Teilprojekte und Aufgaben,
gewichtet nach dem geplanten Aufwand berechnet.
Grundkurs Software-Engineering mit UML
Stephan Kleuker
143
Analyse der Anforderungen (4/5)
• Glossar Aufwand: Für Projektaufgaben gibt der jeweilige
Bearbeiter an, wie viele Stunden er bereits mit seiner Aufgabe
verbracht hat. Der Aufwand von Projekten berechnet sich aus
den Aufwänden der jeweiligen Teilprojekte und
Projektaufgaben.
• gefunden: Exemplarvariable Aufgaben für Projekt
neue Klasse Projektaufgabe mit Exemplarvariablen Namen,
Bearbeiter, Arbeitsanteil, geplanter Aufwand, realer Aufwand,
geplanter und realer Starttermin, geplanter und realer
Endtermin, Fertigstellungsgrad
Projekt hat auch Exemplarvariablen Fertigstellungsgrad und
realer Aufwand, die allerdings vollständig aus anderen Werten
berechnet werden können. Man spricht dabei von einer
abhängigen Exemplarvariable.
Grundkurs Software-Engineering mit UML
Stephan Kleuker
144
Analyse der Anforderungen (5/5)
A1.8: Nach der Projektauswahl muss das System dem Nutzer die
Möglichkeit bieten, Projektaufgaben zu selektieren.
A1.9: Nach der Projektaufgabenauswahl muss das System dem
Nutzer die Möglichkeit bieten, sämtliche Eigenschaften der
Projektaufgabe zu bearbeiten.
A1.10: Nach der Projektauswahl muss das System dem Nutzer die
Möglichkeit bieten, (Teil-)Projekte anzugeben, von deren
Fertigstellung das Projekt abhängig ist.
• gefunden: (in A1.8 und A1.9) nichts, in A1.10 Exemplarvariable
Vorgänger für Projekt
• (weitere Anforderungen nur für zweite Iteration relevant)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
145
Erstes Klassendiagramm
• Klassenname,
• Exemplarvariable:Typ
• Sichtbarkeit (-) kein Zugriff von Außen (+) Zugriff von außen (für
Exemplarvariable unerwünscht)
• Schreibweise Menge() unüblich, / für abgeleitet
Grundkurs Software-Engineering mit UML
Stephan Kleuker
146
UML-Notation
• Assoziationen: Beziehung zwischen Klassen
• Rollenname am Ende entspricht Exemplarvariablennamen
• Multiplizitäten „von..bis“, * für beliebig, alternativ 0..* statt *
Grundkurs Software-Engineering mit UML
Stephan Kleuker
147
Zusammenhang Klasse und Objekt
•
•
•
•
Objekte lassen sich auch in der UML darstellen
Kasten mit unterstrichenem „:<Klassenname>“
vor Doppelpunkt kann Objektname stehen
Objekte werden nicht im Klassendiagramm dargestellt
Grundkurs Software-Engineering mit UML
Stephan Kleuker
148
UML unterstützt iteratives Vorgehen
• UML-Teile weggelassen bzw. ausblenden, abhängig von
notwendigen bzw. vorhandenen Teilinformationen
• Je implementierungsnäher desto detaillierter
Grundkurs Software-Engineering mit UML
Stephan Kleuker
149
Zweite Iteration: Methoden suchen
5.3
• Methoden stehen für Funktionalität, die ein Objekt anbietet;
typisch: Zustand (d. h.) Exemplarvariable ändern, Ergebnis
basierend auf Exemplarvariablen berechnen
• Ansatz 1: Analysiere Verben im Text
• Ansatz 2: Aus Use Cases lässt sich häufig eine
Steuerungsklasse (Koordinationsklasse) ableiten
• folgende Anforderungen an die Klassenformulierung müssen
beachtet werden:
– Klassen übernehmen jeweils eine Aufgabe und besitzen
genau die zur Durchführung benötigten Methoden und die
für die Methoden benötigten Exemplarvariablen
– Klassen sollen möglichst wenig andere Klassen kennen,
wodurch die Schnittstellenanzahl gering gehalten wird
• (Hinweis: unser Beispiel ist datenlastig, deshalb wenige
Methoden)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
150
zweite Analyse der Anforderungen (1/5)
• get- und set-Methoden werden gerne im Modell weggelassen,
für Exemplarvariable x:Typ in Java
public Typ getX() {return x;}
public void setX(Typ x){this.x=x;}
A1.1: In der Projektbearbeitung muss das System dem Nutzer die
Möglichkeit bieten, ein neues Projekt mit Projektausgangsdaten
anzulegen.
• Konstruktoren werden nur genannt, wenn besondere Arten
gefordert werden. Wird kein Konstruktor explizit genannt, wird
davon ausgegangen, dass ein Default-Konstruktor ohne
Parameter zur Verfügung steht.
hier: Projekt(String, Datum, Datum, int)
A1.2: Nach Abschluss der Eingabe (mit „Return“-Taste oder
Bestätigungsknopf) bei der Bearbeitung von Daten muss das
System neu eingegebene Daten in seine permanente
Datenhaltung übernehmen.
• Hier steckt nur eine verstecke Anforderung an die Benutzung
dahinter, als Funktionalität wird nur set... gefordert.
Datenhaltung wird später geklärt.
Grundkurs Software-Engineering mit UML
Stephan Kleuker
151
zweite Analyse der Anforderungen (2/5)
A1.3: In der Projektbearbeitung muss das System die Möglichkeit
bieten, jedes Projekt auszuwählen.
• Steuerungsklasse Projektverwaltung
• Exemplarvariablen: alle Projekte und selektiertes Projekt
• Projektauswahl ist set-Methode
A1.4: Nach der Projektauswahl muss das System dem Nutzer die
Möglichkeit bieten, für existierende Projekte neue Teilprojekte
anzulegen.
• Wie bei Mengen von Werten üblich, wird meistens eine addund eine delete-Methode gefordert. In diesem Fall nur
teilprojektHinzufuegen(Projekt): void
A1.7: Nach der Projektauswahl muss das System dem Nutzer die
Möglichkeit bieten, neue Projektaufgaben mit dem
Aufgabennamen, dem geplanten Start- und Endtermin, dem
Arbeitsanteil des Mitarbeiters und dem geplanten Aufwand zu
definieren.
• Projekt hat Methode aufgabeHinzufuegen(Projektaufgabe): void
• Konstruktor Aufgabe(String, Datum, Datum, int, int)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
152
zweite Analyse der Anforderungen (3/5)
Glossar Aufwand: ... Der Aufwand von Projekten berechnet sich
aus den Aufwänden der jeweiligen Teilprojekte und
Projektaufgaben.
• hier „versteckt“ sich die Funktionalität, dass für Projekte der
aktuelle Aufwand berechnet werden soll:
realenAufwandBerechnen(): int
• analog: fertigstellungsgradBerechnen(): double
A1.8: Nach der Projektauswahl muss das System dem Nutzer die
Möglichkeit bieten, Projektaufgaben zu selektieren.
• Projekt hat Exemplarvariable selektierteAufgabe [erster Ansatz,
wichtig nur vollständiges Modell]
A1.10: Nach der Projektauswahl muss das System dem Nutzer die
Möglichkeit bieten, (Teil-)Projekte anzugeben, von deren
Fertigstellung das Projekt abhängig ist.
• Projekt hat vorgaengerHinzufuegen(Projekt): void
Grundkurs Software-Engineering mit UML
Stephan Kleuker
153
zweite Analyse der Anforderungen (4/5)
A1.11: Nach der Eingabe eines neuen Teilprojekts oder einer
neuen Projektaufgabe und nach der Aktualisierung des
Aufwandes eines Teilprojekts oder einer neuen Projektaufgabe
überprüft das System die Aufwandsangaben auf Plausibilität.
• folgt, dass Teilprojekt die Möglichkeit haben muss,
festzustellen, zu welchem (Teil-)Projekt es gehört.
• eine Lösung: in angegebener Assoziation, mit der Teilprojekte
festgehalten werden, ist diese Information bereits in der
Multiplizität 0..1 enthalten, es wird Rollenname zur
Veranschaulichung ergänzt.
• (Ansatz: Durch die Angabe von Rollennamen wird ersichtlich,
in welche Richtung Assoziationen navigierbar sein müssen)
• Projekt: aufwandsaenderungPruefen(neuerAufwand: int): bool
• Projektaufwand: zugeordneter Aufwand (geplanter Aufwand)
minus verteilter Aufwand, also: verteilterAufwand():int
• Für Projekte auch:
aufwandsaenderungPruefen(Projektaufgabe, int): bool
Grundkurs Software-Engineering mit UML
Stephan Kleuker
154
zweite Analyse der Anforderungen (5/5)
A1.12: Bei der Überprüfung der Aufwandsangaben auf Plausibilität
muss das System prüfen, ob die Summe der geplanten
Teilprojekte und Aufgaben eines Projekts kleiner-gleich der
geplanten Summe des Projekts ist.
• beschreibt nur detailliert, wie die vorher gefundene Methode zu
realisieren ist
A1.13: Nach einer gescheiterten Aufwandsplausibilitätsprüfung
muss das System den Nutzer über das Problem informieren
und darf den Aufwandswert nicht verändern.
• Projektverwaltung bekommt die Möglichkeit, auf das gefundene
Problem hinzuweisen ( zu GUI-Funktionalität später mehr)
inkonsisteneAktualisierungAnzeigen(grund:String):void
Grundkurs Software-Engineering mit UML
Stephan Kleuker
155
Klassendiagramm
Grundkurs Software-Engineering mit UML
Stephan Kleuker
156
Vererbung
• Analysemodell wird auf erste Optimierungen geprüft
• Wenn Objekte verschiedener Klassen große Gemeinsamkeiten
haben, kann Vererbung genutzt werden
• Variante 1: Abstrakte Klasse mit möglichen Exemplarvariablen,
einigen implementierten und mindestens einer nichtimplementierten Methode
• Variante 2: Interface ausschließlich mit abstrakten Methoden
(haben später noch Bedeutung)
• Vererbung reduziert den Codierungsaufwand
• Vererbung erschwert Wiederverwendung
• Liskovsches Prinzip für überschreibende Methoden der
erbenden Klassen berücksichtigen:
– Vorbedingung gleich oder abschwächen
– Nachbedingungen gleich oder verstärken
Grundkurs Software-Engineering mit UML
Stephan Kleuker
157
Beispiel: Vererbung
nächster Schritt: Prüfen, wo statt Projekt und Projektaufgabe Projektkomponente
stehen kann (Abstrahierung)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
158
Aufzählungen
• Häufiger gibt es Exemplarvariablen, die bestimmte Werte, z. B.
{rot,gelb,grün} annehmen können
• Aufzählungstypen werden in der UML
wie rechts gezeigt beschrieben
• Der Stereotyp <<enumeration>> gibt an, dass es sich um eine
Klasse mit bestimmten Eigenschaften handelt
• Die UML hat einige Stereotypen vorgegeben; weitere können
beliebig vereinbart werden.
• Wie bei allen UML-Sprachelementen gilt, dass man vor dem
Modellierungsstart festlegen muss, welches Diagramm und
welche Notation wann eingesetzt werden soll
Grundkurs Software-Engineering mit UML
Stephan Kleuker
159
Validierung mit Sequenzdiagrammen
5.4
• Mit Hilfe des erreichten
Modells kann man mit
Sequenzdiagrammen
validieren, ob die im
Aktivitätsdiagramm
beschriebenen Abläufe
möglich sind
• rechte Seite zeigt
verschiedene
Darstellungsmöglichkeiten
eines Methodenaufrufs
• Rückgabewerte werden
häufig weggelassen, wenn
nur Ablauf wichtig
• (Stellen auch Testfälle dar)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
160
Zusammenhang: Programm und Sequenzdiagramm
public class A {
extern
:A
b:B
private B b= new B();
private C c;
mach(42)
tues(42)
public char mach(int x){
int t= b.tues(x);
42
c= new C(t,t+1);
return b.yeah(c);
new C(42,43)
}
c:C
}
yeah(c)
public class B {
sach(A)
public int tues(int x){
return x%255;
'U'
}
'V'
public char yeah(C c){
'V'
char e=c.sachA();
return (char) (e+1);
}
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
161
Iterative Entwicklung und Validierung
Beispielablauf
• Ableitung von Methodennamen
• Zeichnen eines kleinen Sequenzdiagramms mit
dieser Methode; feststellen, ob weitere Methoden
benötigt
• Ergänzung von Methodenparametern
• Ergänzung des Sequenzdiagramms um Parameter;
feststellen, ob weitere Methoden benötigt
• Falls kein Sequenzdiagramm herleitbar, auf
Ursachenforschung gehen (Modellfehler?)
• Optimales Ziel: Mögliche Durchläufe durch
Aktivitätsdiagramme werden abgedeckt
Grundkurs Software-Engineering mit UML
Stephan Kleuker
162
Zusammenhang zwischen Aktivitäts- und
Sequenzdiagrammen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
163
Iterative Entwicklung eines Sequenzdiagramms
:A
• generell: zunächst unterspezifiziert,
• dann Parameter verfeinern
• abstrakter Ablauf (x) oder konkreter
Beispielablauf (mit Werten)
• Ergänzung interner Berechnungen,
z. B. in A z= this.oh();
• interne Collections meist nicht
dargestellt
• Darstellung aber möglich, in B:
public void hinzu(C c){
l.add(c);
}
Grundkurs Software-Engineering mit UML
b:B
tues()
l:Set
tues(x)
tues(42)
z=oh()
hinzu(c)
hinzu(c)
Stephan Kleuker
add(c)
164
Sequenzdiagramm und Kommunikationsdiagramm
• gleiches Ausdrucksvermögen wie einfache
Sequenzdiagramme
• Zusammenspiel der Objekte wird deutlicher
• interne Berechnung 2.1, 2.2 (ggfls. 2.1.1, 2.1.1.1)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
165
Highlevel-Sequenzdiagramme
Grundkurs Software-Engineering mit UML
Stephan Kleuker
166
Beispiel: Initialisierung
• Anmerkung: Typischerweise „befruchten“ sich die
Entwicklung von Klassendiagrammen und
Sequenzdiagrammmen (Optimierung in einem iterativen
Prozess)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
167
Beispiel: Anstoß der Funktionalität
• häufig werden Teilsysteme spezifiziert, deren Nutzung von
außen angestoßen wird
• dann im Sequenzdiagramm „außen“ als „Extern“ modellieren
Grundkurs Software-Engineering mit UML
Stephan Kleuker
168
Beispiel: Fertigstellungsgrad berechnen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
169
Beispiel: Prüfung Projektaufwand aktualisierbar (1/2)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
170
Beispiel: Prüfung Projektaufwand aktualisierbar (2/2)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
171
Beispiel: Projektaufgabenaufwand aktualisierbar?
Grundkurs Software-Engineering mit UML
Stephan Kleuker
172
GUI-Modellierung
5.5
• fachlich hängt Oberfläche (GUI, Graphical User
Interface) eng mit unterliegendem
Geschäftsklassenmodell (bisher behandelt)
zusammen
• möglicher Ansatz: „Mache alle Modellanteile an der
Oberfläche sichtbar, die ein Nutzer än-dern oder für
dessen Inhalte er sich interessieren kann.“
• Variante: mache ersten GUI-Prototyp und halte bei
Ein- und Ausgaben fest, welche Modellinformationen
sichtbar sein sollen
• GUI-Prototyp gut mit Kunden dieskutierbar
• Hinweis: Thema Softwareergonomie später
Grundkurs Software-Engineering mit UML
Stephan Kleuker
173
Erweiterung mit Boundary-Klassen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
174
Sequenzdiagramm mit Nutzungsdialog
Grundkurs Software-Engineering mit UML
Stephan Kleuker
175
Anforderungsverfolgung
Typische Fragen:
• Werden alle Anforderungen umgesetzt?
• Wo werden Anforderungen umgesetzt?
• Gibt es Spezifikationsanteile, die nicht aus
Anforderungen abgeleitet sind?
• Woher kommt eine Klasse, eine Methode, ein
Parameter?
• Was passiert, wenn ich eine Anforderung oder eine
Klasse ändere?
• Generell werden die Fragen wesentlich komplexer zu
beantworten, wenn Software später umgebaut oder
erweitert wird
Grundkurs Software-Engineering mit UML
Stephan Kleuker
176
Anforderungsverfolgung - Beispielzusammenhänge
Grundkurs Software-Engineering mit UML
Stephan Kleuker
177
6. Vom Klassendiagramm
zum Programm
6.1
6.2
6.3
6.4
6.5
6.6
CASE-Werkzeuge
Übersetzung einzelner Klassen
Übersetzung von Assoziationen
Spezielle Arten der Objektzugehörigkeit
Aufbau einer Software-Architektur
Weitere Schritte zum lauffähigen Programm
Grundkurs Software-Engineering mit UML
Stephan Kleuker
178
Analyse des Ist-Standes
• bekannter Weg: Kundenwünsche,
Anforderungsformulierung, Analyse-Modell
• Analysemodell kann realisiert werden, aber:
– Klassen kaum für Wiederverwendung geeignet
– Programme meist nur aufwändig erweiterbar
– viele unterschiedliche Lösungen zu gleichartigen
Problemen
• deshalb: fortgeschrittene Designtechniken studieren
• aber: um fortgeschrittenes Design zu verstehen,
muss man die Umsetzung von Klassendiagrammen
in Programme kennen (dieses Kapitel)
• aber: um fortgeschrittenes Design zu verstehen,
muss man einige OO-Programme geschrieben haben
Grundkurs Software-Engineering mit UML
Stephan Kleuker
179
UML-Toolsuiten / CASE-Werkzeuge
6.1
Theorie:
• UML-Werkzeuge unterstützen die automatische Umsetzung von
Klassendiagrammen in Programmgerüste (Skelette)
• Entwickler müssen die Gerüste mit Code füllen
• viele Werkzeuge unterstützen Roundtrip-Engineering, d.h.
Änderungen im Code werden auch zurück in das Designmodell
übernommen (wenn man Randbedingungen beachtet)
• Roundtrip beinhaltet auch Reverse-Engineering
Praxis:
• sehr gute kommerzielle Werkzeuge (z. B. IBM Rational, Borland
Together); allerdings muss man für Effizienz Suite von
Werkzeugen nutzen; d. h. auf deren Entwicklungsweg einlassen
• ordentliche nicht kommerzielle Ansätze für Teilgebiete;
allerdings Verknüpfung von Werkzeugen wird aufwändig
Grundkurs Software-Engineering mit UML
Stephan Kleuker
180
Übersetzung einfacher Diagramme (1/3)
6.2
Anmerkung: auch
bei Realisierung
kann vereinbart
werden, dass getund set-Methoden
in Übersichten
weggelassen (und
damit als gegeben
angenommen)
werden
Klassenmethoden
sind unterstrichen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
181
Übersetzung einfacher Diagramme (2/3)
public class Mitarbeiter {
/**
* @uml.property name="minr"
*/
private int minr;
/**
* Getter of the property <tt>minr</tt>
* @return Returns the minr.
* @uml.property name="minr"
*/
public int getMinr() {
return minr;
}
/**
* Setter of the property <tt>minr</tt>
* @param minr The minr to set.
* @uml.property name="minr"
*/
public void setMinr(int minr) {
this.minr = minr;
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
182
Übersetzung einfacher Diagramme (3/3)
private String vorname = "";
public String getVorname() { return vorname;}
public void setVorname(String vorname) {
this.vorname = vorname;
}
private String nachname = "";
public String getNachname() {return nachname;}
public void setNachname(String nachname) {
this.nachname = nachname;
private static int mitarbeiterzaehler;
public static int getMitarbeiterzaehler() {
return mitarbeiterzaehler;
}
public static void setMitarbeiterzaehler
(int mitarbeiterzaehler) {
Mitarbeiter.mitarbeiterzaehler = mitarbeiterzaehler;
}
}
= evtl. notwendige Korrekturen, bei CASE-Werkzeug
Grundkurs Software-Engineering mit UML
Stephan Kleuker
183
Notwendige Code-Ergänzung durch Entwickler
public Mitarbeiter(String vorname, String nachname){
this.vorname=vorname;
this.nachname=nachname;
this.minr=Mitarbeiter.mitarbeiterzaehler++;
}
@Override
public String toString() {
return minr+": "+vorname+" "+nachname;
}
= vom Entwickler ergänzt
Grundkurs Software-Engineering mit UML
Stephan Kleuker
184
Umgang mit Assoziationen im Design
6.3
• Assoziationen zunächst nur Strich mit Namen (und
Multiplizitäten)
• für Implementierung jede Assoziation konkretisieren (Richtung
der Navigierbarkeit, Multiplizitäten sind Pflicht)
public class Projektaufgabe {
/** werkzeugspezifische Kommentare weggelassen
*/
private Mitarbeiter bearbeiter;
public Mitarbeiter getBearbeiter() {
return bearbeiter;
}
public void setBearbeiter(Mitarbeiter bearbeiter) {
this.bearbeiter = bearbeiter;
}
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
185
Multiplizität 1
• Objekreferenz darf nie null sein
private Mitarbeiter bearbeiter = new Mitarbeiter();
• oder im Konstruktor setzen
• man sieht, default-Konstruktoren sind auch hier
hilfreich; deshalb, wenn irgendwie möglich
definieren
• Gleiche Problematik mit der Werte-Existenz, bei
Multiplizität 1..n
Grundkurs Software-Engineering mit UML
Stephan Kleuker
186
Multiplizität n (1/2)
• Umsetzung als Collection (Sammlung, Container)
• Umsetzung hängt von Art der Collection ab
– sollen Daten geordnet sein
– sind doppelte erlaubt
– gibt es spezielle Zuordnung key -> value
• Entwickler muss zur Typwahl spätere Nutzung kennen
• eine Umsetzung für 1..*
import java.util.List;
import java.util.ArrayList;
public class Projektaufgabe {
private List<Mitarbeiter> bearbeiter =
new ArrayList<Mitarbeiter>();
• bitte, bitte in Java nicht alles mit ArrayList realisieren (!!!)
• Multiplizität 0..7 als Array umsetzbar
Grundkurs Software-Engineering mit UML
Stephan Kleuker
187
Multiplizität n (2/2)
• Zum Codefragment der letzten Zeile passt besser folgendes
Klassendiagramm
*
• Hinweis: Standardhilfsklassen z. B. aus der JavaKlassenbibliothek oder der C++-STL werden typischerweise in
Klassendiagrammen nicht aufgeführt
• Anmerkung: man sieht die UML-Notation für generische (oder
parametrisierte) Klassen
• UML-Werkzeuge unterscheiden sich bei der Generierung und
beim Reverse-Engineering beim Umgang mit Collections
Grundkurs Software-Engineering mit UML
Stephan Kleuker
188
Arten der Zugehörigkeit (Aggregation 1/2)
6.4
• nicht exklusiver Teil eines Objekts (Mitarbeiter kann bei
mehreren Projektaufgaben Bearbeiter sein)
• in C++: Mitarbeiter *bearbeiter;
Mitarbeiter* Projektaufgabe::getBearbeiter(){
return bearbeiter;}
oder Mitarbeiter bearbeiter;
Mitarbeiter& Projektaufgabe::getBearbeiter(){
return bearbeiter;}
• Realisierungsproblem: Projektaufgabe kann Namen des
Bearbeiters ändern bearbeiter->setNachname("Meier");
• Kann als Verstoß gegen Kapselung (Geheimnisprinzip)
angesehen werden
• Designansatz: Klasse erhält Interface, die Methoden enthält, die
bestimmte andere Klassen nutzen können
Grundkurs Software-Engineering mit UML
Stephan Kleuker
189
Arten der Zugehörigkeit (Aggregation 2/2)
• Designansatz: Verhindern unerwünschten Zugriffs durch
Interface (generell gute Idee !)
Kurzdarstellung
Interfacerealisierer:
Grundkurs Software-Engineering mit UML
Stephan Kleuker
190
Arten der Zugehörigkeit (Komposition 1/2)
• Konkretisierung der Zugehörigkeit: existenzabhängiges Teil,
Exemplarvariable gehört ausschließlich zum Objekt (Mitarbeiter
kann [unrealistisch] nur exakt eine Projektaufgabe bearbeiten;
niemand anderes nutzt dieses Objekt)
• Realisierung in C++
Mitarbeiter bearbeiter;
Mitarbeiter Projektaufgabe::getBearbeiter (){
return bearbeiter;
}
• Bei Rückgabe wird Kopie des Objekts erstellt und zurück
gegeben
Grundkurs Software-Engineering mit UML
Stephan Kleuker
191
Arten der Zugehörigkeit (Komposition 2/2)
• Java arbeitet nur mit Zeigern (unschöne Ausnahme sind
Elementartypen), wie realisiert man
@Override // in Mitarbeiter.java
public Mitarbeiter clone(){ // echte Kopie
Mitarbeiter ergebnis= new Mitarbeiter();
ergebnis.minr=minr;
ergebnis.nachname=nachname; //Strings sind
ergebnis.vorname=vorname;
//Konstanten
return ergebnis;
}
// in Projektaufgabe
public Mitarbeiter getBearbeiter() {
return bearbeiter.clone();
}
• Variante: bei Realisierung überall doll aufpassen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
192
Kurzzeitige Klassennutzungen
• Klassen nutzen andere Klassen nicht nur für Exemplar- (und
Klassen-) Variablen
• Klassen erzeugen Objekte anderer Klassen lokal in Methoden,
um diese weiter zu reichen
public class Projektverwaltung {
private Projekt selektiertesProjekt;
public void projektaufgabeErgaenzen(String name){
Projektaufgabe pa= new Projektaufgabe(name);
selektiertesProjekt.aufgabeHinzufuegen(pa);
}
• Klassen nutzen Klassenmethoden anderer Klassen
• In der UML gibt es hierfür den „Nutzt“-Pfeil
• (Omondo: <<include>>)
• Wenn zu viele Pfeile im Diagramm, dann mehrere Diagramme mit
gleichen Klassen zu unterschiedlichen Themen
• UML-Werkzeuge unterstützen Analyse von Abhängigkeiten
Grundkurs Software-Engineering mit UML
Stephan Kleuker
193
Erstellen einer Softwarearchitektur
6.5
• Ziel des Design ist ein Modell, welches das Analysemodell
vollständig unter Berücksichtigung
implementierungsspezifischer Randbedingungen umsetzt
• allgemeine Randbedingungen: Es gibt ingenieurmäßige
Erfahrungen zum gutem Aufbau eines Klassensystems; dieses
wird auch SW-Architektur genannt
• Ziele für die Architektur
– Performance
– Wartbarkeit
– Erweiterbarkeit
– Verständlichkeit
– schnell realisierbar
– Minimierung von Risiken
Grundkurs Software-Engineering mit UML
Stephan Kleuker
194
Systematische Entwicklung komplexer Systeme
• Für große Systeme entstehen viele Klassen; bei guten Entwurf:
• Klassen die eng zusammenhängen (gemeinsame
Aufgabengebiete)
• Klassen, die nicht oder nur schwach zusammenhängen
(Verknüpfung von Aufgabengebieten)
• Strukturierung durch SW-Pakete; Pakete können wieder Pakete
enthalten
Grundkurs Software-Engineering mit UML
Stephan Kleuker
195
Typische 3-Schichten-SW-Architektur
• Ziel: Klassen eines oberen Pakets
greifen nur auf Klassen eines
unteren Paketes zu (UML-“nutzt“Pfeil)
• Änderungen der oberen Schicht
beeinflussen untere Schichten
nicht
• Analysemodell liefert
typischerweise nur Fachklassen
• Datenhaltung steht für Persistenz
• typisch Varianten von 2 bis 5
Schichten
• Klassen in Schicht sollten
gleichen Abstraktionsgrad haben
• Schicht in englisch „tier“
• obere und untere Schichten
können stark von speziellen
Anforderungen abhängen (später)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
196
Beispiel: grobe Paketierung (eine Variante)
• Anmerkung: Datenverwaltung noch nicht konzipiert
Grundkurs Software-Engineering mit UML
Stephan Kleuker
197
Beispiel: grobe Paketierung (zweite Variante)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
198
Forderung: azyklische Abhängigkeitsstruktur
Grundkurs Software-Engineering mit UML
Stephan Kleuker
199
Umsetzung von Paketen in Java und C++
package fachklassen.projektdaten;
import fachklassen.projektmitarbeiter.Mitarbeiter;
public class Projektaufgabe {
private Mitarbeiter bearbeiter;
/* ... */
}
#include "Mitarbeiter.h" //evtl. mit Dateibaum
using namespace Fachklassen::Mitarbeiterdaten;
namespace Fachklassen{
namespace Projektdaten{
class Projektaufgabe{
private:
Mitarbeiter *bearbeiter; // ...
};
}
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
200
Paketabhängigkeiten optimieren
• Ziel ist es, dass Klassen sehr eng
zusammenhängen; es weniger Klassen gibt, die eng
zusammenhängen und viele Klassen und Pakete, die
nur lose gekoppelt sind
• Möglichst bidirektionale oder zyklische
Abhängigkeiten vermeiden
• Bei Paketen können Zyklen teilweise durch die
Verschiebung von Klassen aufgelöst werden
• Wenig globale Pakete (sinnvoll für projektspezifische
Typen (z. B. Enumerations) und Ausnahmen)
• Es gibt viele Designansätze, Abhängigkeiten zu
verringern bzw. ihre Richtung zu ändern
Grundkurs Software-Engineering mit UML
Stephan Kleuker
201
Trick: Abhängigkeit umdrehen
• generell können Interfaces häufiger in anderen Paketen liegen,
als ihre Implementierer
• Java-Klassenbibliothek Swing fordert häufig die InterfaceImplementierung bei der Ereignisbehandlung
Grundkurs Software-Engineering mit UML
Stephan Kleuker
202
Architektursichten
6.6
• Paket- und Klassendiagramme geben einen guten
Überblick über die Ergebnisse des statischen SWEntwurfs
• Es gibt aber mehr Sichten (Betrachtungsweisen), die
für eine vollständige SW-Architektur relevant sind
• z. B. wurde die HW des zu entwickelnden Systems
noch nicht berücksichtigt
• Diese Sichten müssen zu einem System führen;
deshalb müssen sich Sichten überlappen
• z. B. eigenes Diagramm mit Übersicht über
eingesetzte Hardware und Vernetzung; dazu
Information, welche SW wo laufen soll
Grundkurs Software-Engineering mit UML
Stephan Kleuker
203
4+1 Sichten
Logische Sicht
- funktionale Analyseergebnisse
- Klassenmodell
Implementierungssicht
- Subsysteme
- Schnittstellen
Szenarien
Ablaufsicht
- Prozesse
- Nebenläufigkeit
- Synchronisation
Grundkurs Software-Engineering mit UML
Physische Sicht
- Zielhardware
- Netzwerke
Stephan Kleuker
204
4+1 Sichten mit (Teilen der) UML
Logische Sicht
- Klassendiagramme
- Paketdiagramme
Implementierungssicht
- Komponentendiagramme
Szenarien
-Use Case-Diagramme
- Aktivitätsdiagramme
Ablaufsicht
- Sequenzdiagramme
Physische Sicht
- Kommunikations- Deploymentdiagramme
- Zustandsdiagramme
diagramme
Grundkurs Software-Engineering mit UML
Stephan Kleuker
205
Ablaufsicht
• wichtig für verteilte Systeme; bzw. Systeme, die
verteilt (auch auf einem Rechner) laufen
• Festlegen der Prozesse
• Festlegen etwaiger Threads
• so genannte aktive Klassen; werden Objekte dieser
Klassen gestartet, so starten sie als eigenständige
Prozesse/Threads
AktiveKlasse
aktivesObjekt:
AktiveKlasse
• Prozessverhalten u. a. durch Sequenzdiagramme
beschreibbar
• (übernächste VL etwas mehr; gibt eigenes Modul
dazu)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
206
Implementierungssicht
• Das Designmodell muss physikalisch realisiert
werden; es muss eine (ausführbare) Datei entstehen
• Pakete fassen als Komponenten realisiert Klassen
zusammen
• häufig werden weitere Dateien benötigt: Bilder,
Skripte zur Anbindung weiterer Software,
Installationsdateien
• Komponenten sind austauschbare Bausteine eines
Systems mit Schnittstellen für andere Komponenten
• Typisch ist, dass eine Komponente die Übersetzung
einer Datei ist
• Typisch ist, dass eine Komponente die Übersetzung
eines Pakets ist; in Java .jar-Datei
Grundkurs Software-Engineering mit UML
Stephan Kleuker
207
Komponentendiagramm
• Bilder zeigen zwei alternative
Darstellungen
• Komponenten bieten
Schnittstellen(realisierungen) (Kreis) und
benötigen Schnittstellen(realisierungen)
(Halbkreis)
• Komponenten können über Schnittstellen
in Diagrammen verknüpft werden
• in die Komponenten können die
zugehörigen Klassen eingezeichnet
werden
• Ports erlauben den Zugriff auf bestimmten
Teil der Klassen und Interfaces (nicht im
Diagramm)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
208
Physische Sicht: vorgegebene HW mit Vernetzung
• Einsatz- und Verteilungsdiagramm (deployment diagram)
• Knoten steht für physisch vorhandene Einheit, die über
Rechenleistung oder/und Speicher verfügt
• <<executable>> (ausführbare Datei) und <<artifact>> (Datei)
müssen zur HW-Beschreibung nicht angegeben werden
Grundkurs Software-Engineering mit UML
Stephan Kleuker
209
7. Konkretisierungen im
Feindesign
7.1 Zustandsdiagramme
7.2 Object Constraint Language
Grundkurs Software-Engineering mit UML
Stephan Kleuker
210
Verfeinerte Modellierung
• Durch die verschiedenen Sichten der Systemarchitektur wird
der Weg vom Anforderungsmodell zur Implementierung
beschrieben
• Es bleiben offene Themen:
– Wie bekomme ich ein gutes Klassendesign (nächstes
Kapitel)?
– Wie kann man das komplexe Verhalten von Objekten noch
beschreiben (Klassendiagramme sind statisch,
Sequenzdiagramme exemplarisch)?
Antwort: Zustandsdiagramme
– Wie kann man bei der Klassenmodellierung
Randbedingungen formulieren, was in Klassendiagrammen
(Bedingungen in geschweiften Klammern) nur bedingt
möglich ist?
Antwort: Object Constraint Language
Grundkurs Software-Engineering mit UML
Stephan Kleuker
211
Zustandsdiagramme
7.1
• generell wird der Zustand eines Objekts durch die Werte seiner
Exemplar- und Klassenvariablen beschrieben
• Häufig wird der Begriff Zustand auch für eine spezielle
Exemplarvariable genutzt, die z. B. über eine Enumeration
realisierbar ist
• z. B. : Ampel: rot, rotgelb, gelb, grün
• z. B. : Projekt: vorbereitet, grob geplant, Mitarbeiter zugeordnet,
verschoben, in Bearbeitung, in Endabnahme, in
Gewährleistung, beendet
• Die Übergänge zwischen den Zuständen werden durch
Ereignisse, zumeist Methodenaufrufe, veranlasst
• Die Übergänge lassen sich durch ein Zustandsdiagramm
(ursprünglich Statechart nach D. Harel) spezifizieren
• Zustandsautomaten spielen auch in der theoretischen und
technischen Informatik eine zentrale Rolle
Grundkurs Software-Engineering mit UML
Stephan Kleuker
212
Struktur von Zustandsdiagrammen
• Zustandsdiagramm gehört zu einem Objekt einer Klasse
• alle Angaben für Zustände und Transitionen sind Optional
• Transition wird ausgeführt, wenn Ereignis eintritt und
Bedingung erfüllt ist
• ohne Ereignis und Bedingung wird Transition dann ausgeführt,
wenn Entry, Do, und Exit durchlaufen
• Einfacher Automat muss deterministisch sein
Grundkurs Software-Engineering mit UML
Stephan Kleuker
213
Beispiel: Zustandsdiagramm eines Projekts
• man erkennt: nach Planung keine Planungsänderung
Grundkurs Software-Engineering mit UML
Stephan Kleuker
214
Hierarchische Zustände
Grundkurs Software-Engineering mit UML
Stephan Kleuker
215
Parallele Unterzustände
• unabhängige Teilzustände
können in parallelen
Zuständen bearbeitet
werden
• ohne Parallelität müsste
Kreuzprodukt der
Zustände der parallelen
Automaten betrachtet
werden
Grundkurs Software-Engineering mit UML
Stephan Kleuker
216
Beispiel: Uhr
Grundkurs Software-Engineering mit UML
Stephan Kleuker
217
Zustandsmodellierung und Realzeitsysteme
• in klassischen OOProgrammen gibt es
meist wenige zentrale
Klassen, für die sich
eine
Zustandsmodellierung
anbietet
• In Systemen mit Zeit
kann
Zustandsmodellierung
Zeitbedingungen
beinhalten
• auch warte(5 sek)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
218
Event [Condition] / Action
• Transitionsbeschriftung Ereignis[Bedingung]/Aktion
• Was ist Ereignis? Hängt von Applikation ab
– Methodenaufruf
– Ereignis im Programm (Variable wechselt Wert)
– technische Systeme: Signale
typisches Beispiel: Steuersysteme
• erhalten Signale (->Ereignisse) von Sensoren wenn
etwas passiert (z. B. ein-/ausgeschaltet)
• lesen Werte anderer Sensoren, Teilsysteme
(-> Bedingung), die Entscheidungen
beeinflussen
• senden Signale (-> Aktion) an andere Systeme
Grundkurs Software-Engineering mit UML
Stephan Kleuker
219
Microsteps und Macrosteps (1/2)
• Actions eines Teilautomaten können Events eines
anderen Teilautomaten sein
• Microstep: einzelne Schritte betrachten
Start -> K(A1,B1) –p-> K(A2,B1) –x-> K(A2,B2) –q->
K(A3,B2) –y-> K(A3,B3) –z-> K(A3,B1) –r-> K(A1,B1)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
220
Microsteps und Macrosteps (2/2)
• Macrostep: nur Zustände nach vollständiger
Bearbeitung betrachten (Ausnahme: Livelock)
Start -> K(A1/B1) –p-> K(A3/B3) –z-> K(A1/B1)
• typischerweise nur an Macrosteps interessiert
Grundkurs Software-Engineering mit UML
Stephan Kleuker
221
Beispiel: Start-Stopp-Automatik (1/3)
• zentrale Aufgabe: Start-Stopp-Automatik stellt den
Motor immer dann selbstständig aus, wenn dieser
nicht mehr benötigt wird (z. B. Halt an Ampel)
• Randbedingung: keine Abschaltung bis maximal 3
Grad und ab minimal 30 Grad
• Ablauf:
– Zündschlüssel einstecken, Motorstartknopf
drücken, dann startet Automatik
– Motorein- und Abschaltung wird anhand der
Kupplung erkannt
– Automatik kann auch wieder gestoppt werden
• [Frage: was fehlt alles zur Realität]
Grundkurs Software-Engineering mit UML
Stephan Kleuker
222
Beispiel: Start-Stopp-Automatik (2/3)
• Klärung, von welche Sensoren werden Signale
empfangen:
– Zündschloss: start und ende
– Kupplung: leerlauf und druecken
– Automatiksteuerung: an und aus
• Klärung, welchen Sensoren können abgefragt werden:
– Temperaturwert temp in lokaler Variablen
• Klärung an welche Sensoren Signale geschickt
werden
– Motorsteuerung: motor_an und motor_aus
Grundkurs Software-Engineering mit UML
Stephan Kleuker
223
Beispiel: Start-Stopp-Automatik (3/3)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
224
GUI als Zustandsdiagramm
Grundkurs Software-Engineering mit UML
Stephan Kleuker
225
Android als Zustandsdiagramm
Grundkurs Software-Engineering mit UML
Stephan Kleuker
226
Umsetzung von Zustandsdiagrammem
• Abhängig davon, wie formal die Zustände und Transitionen
spezifiziert sind, kann aus Zustandsdiagrammen
Programmcode erzeugt werden
• Typisch: Iteratives Vorgehen: informelle Beschreibungen
werden schrittweise durch formalere ersetzt
• Ereignisse können für folgendes stehen
– Methodenaufrufe
– externe Ereignisse des GUI (-> Methodenaufruf)
– Teilsituation, die bei der Abarbeitung einer Methode
auftreten kann
• Automat wird zunächst zu komplexer Methode, die z. B. anhand
der Zustände in Teilmethoden refaktoriert werden kann
Grundkurs Software-Engineering mit UML
Stephan Kleuker
227
Klassendiagramm und versteckte Randbedingungen
7.2
• Welche Randbedingungen vermuten Sie?
Grundkurs Software-Engineering mit UML
Stephan Kleuker
228
Grundidee von Object Constraint Language (OCL)
• Rahmenbedingungen (Constraints) definieren, die
von Objekten bzw. Objektmengen eingehalten
werden können
• Constraints sind prüfbar
• möglichst einfach formulierbar (ursprünglich zur
Formulierung von Geschäftsregeln für
Versicherungsanwendungen, [Syntropy, IBM])
• Angepasst an Objektorientierung:
– Zugriff auf Exemplarvariablen
– Zugriff auf Methoden, die keine
Objektveränderungen vornehmen
– Vererbung wird beachtet
• typisiert, Collections wichtiger Typ
Grundkurs Software-Engineering mit UML
Stephan Kleuker
229
Einfache Bedingungen für Objekte (Invarianten)
• Die Matrikelnummer ist mindestens 10000
context Studi inv hoheMatrikelnummern:
self.matnr>=10000
• eine Variante:
context s:Studi inv:
s.matnr>=10000
• context gibt eindeutig an, um welche Klasse es
geht
• Strukturierung durch Nutzung der Paketstruktur
package com::meineFirma::meineSW
context Studi inv: ...
context Studi inv: ...
endpackage
Grundkurs Software-Engineering mit UML
Stephan Kleuker
230
Vor- und Nachbedingungen für Methoden
• Wenn Studi da, dann hört er Veranstaltungen
context Studi::belegteVeranstaltungen():Integer
pre studiIstDa: self.freisemester=false
post hoertVeranstaltungen: result>0
• Man kann auf Parameter der Methoden zugreifen
• result ist vordefiniert (vom Rückgabetyp)
• Erhöhung der Anzahl der belegten Veranstaltungen:
context Studi::veranstaltungEintragen(v:
Veranstaltung)
pre: nichtBelegt(v)
post: self.belegteVeranstaltungen()@pre=
self.belegteVeranstaltungen()-1
• self.belegteVeranstaltungen()@pre, für Ergebnis vor der
Methodenausführung
Grundkurs Software-Engineering mit UML
Stephan Kleuker
231
Einschub: Basistypen und Operationen
• Jeder OCL-Ausdruck hat einen Typ
• Verknüpfe Ausdrücke müssen vom Typ her passen
• Geringe Typanpassungen möglich
Typ
Beispielwerte
Boolean
true, false
Integer
1, -5, 42, 4242424242
Real
3.14, 42.42, -99.999
String
'Hallo Again', 'Heidi', ''
Typ
Beispieloperationen
Boolean and,or,xor,not,implies,if then else endif
Integer *, +, -, /, abs()
Real
*, +, -, /, floor()
String
concat(), size(), substring()
Grundkurs Software-Engineering mit UML
Stephan Kleuker
232
Zugriff auf Assoziationen
• Zugriff auf verbundene Elemente möglich,
Kardinalitäten beachten (einfach oder Menge)
• wenn Relation benannt, dann dieser Name
sonst über Name der verbundenen Klasse (klein)
• Profs laufender Veranstaltungen sind nicht im
Ausland
context Veranstaltung inv:
self.status = Veranstaltungsstatus::laeuft
implies
not self.prof.imAusland
• Man sieht auch Zugriff auf eine Enumeration
Grundkurs Software-Engineering mit UML
Stephan Kleuker
233
Assoziationsklassen
• Ausgehend von Assoziationsklassen kann mit
Punktnotation auf beteiligte Klassen (deren Objekte)
mit deren Rollennamen zugegriffen werden
• Prüfungsnoten nur für abgeschlossene
Veranstaltungen
context Pruefung inv:
self.studienfach.status =
Veranstaltungsstatus::abgeschlossen
implies
(self.note>=1.0 and self.note<=5.0)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
234
Beispiele: Mengenoperationen (1/2)
• bei der Betrachtung zugehöriger Objekte ist das Ergebnis meist
eine Collection von Objekten
• in OCL auch: Set, OrderedSet, Sequence, Bag
• auf Collections existieren verschiedene Methoden, genereller
Aufruf
collection -> methode(<parameter>)
• Ergebnis kann wieder eine Collection oder ein Wert eines
anderen Typs sein
• Studi macht höchstens 12 Veranstaltungen
context Studi inv:
studi.studienfach
-> select (s | s.status =
Veranstaltungsstatus::laeuft)
-> size() <= 12
Grundkurs Software-Engineering mit UML
Stephan Kleuker
235
Beispiele: Mengenoperationen (2/2)
• Korrektheit von hatTheorieBestanden
context Studi::hatTheorieBestanden():Boolean
post: result = self.pruefung
-> exists( p | p.note<=4.0
and p.studienfach.titel='Theorie'))
• Korrektheit für bestandeneVeranstaltungen
context Studi::
bestandeneVeranstaltungen():Collection
post: result=self.pruefung
->select( p | p.note<=4.0)
->iterate(p:Pruefung;
erg:Collection=Collection{}|
erg->including(p.studienfach))
Grundkurs Software-Engineering mit UML
Stephan Kleuker
236
8. Optimierung des
Designmodells
8.1
8.2
8.3
8.4
Design im Kleinen
Model View Controller
Vorstellung einiger GoF-Pattern
Abschlussbemerkungen zu Pattern
Grundkurs Software-Engineering mit UML
Stephan Kleuker
237
Zentrale Aufgabe: von Analyse zum Design (1/2)
• Analyse der Klassen:
– haben sie klar definierte Aufgabe
– können Klassen vereinigt werden
– sollten Klassen aufgeteilt werden
– welche Optimierungen sind aus Design-Sicht
möglich? (zentrale Frage, untersuchen wir weiter)
• Exemplar- und Klassenvariablen müssen Typen
haben
• Variablen und Methoden brauchen Sichtbarkeiten
• Methoden brauchen Rückgabe- und Parametertypen
(Signaturen); in Java und C++ spielen Ausnahmen
eine Rolle
Grundkurs Software-Engineering mit UML
Stephan Kleuker
238
Zentrale Aufgabe: von Analyse zum Design (2/2)
• für Assoziationen
– Multiplizitäten beachten
– über mögliche Richtungen nachdenken
– Art der Zugehörigkeit klären
• GUI-Klassen und persistente Datenhaltung einbauen
• Anmerkung 1: Übergang von Analyse zu Design ist
durch Iterationen (Verfeinerungen) fließend
• Anmerkung 2: Die vorgestellten Regeln sind häufig
90-10 Regeln (in 90% müssen sie angewandt werden,
bei Verstößen muss man argumentieren können,
warum)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
239
Einfache Basisregeln
8.1
• KISS = Keep It Simple Stupid, man soll die einfachst
mögliche Realisierung wählen, die das Problem
vollständig löst und gut nachvollziehbar ist (kein
„Quick and Dirty“, sondern eine klare Entscheidung
für einen einfachen Entwicklungsstil)
• YAGNI = You Ain’t Gonna Need It, keine
Verallgemeinerungen entwickeln, die das Design für
theoretisch in der Zukunft vielleicht gewünschte
Erweiterungen vereinfachen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
240
Keine allwissenden Klassen
ändere Fertigstellungsgrad einer Projektaufgabe
besser:
Grundkurs Software-Engineering mit UML
Stephan Kleuker
241
Korrekte Methodenplatzierung
• Objekte sollen genau die Aufgaben übernehmen, für die sie
Kenntnisse haben
• falscher Ansatz: allwissende Objekte saugen alles Wissen aus
Exemplarvariablen und verarbeiten es
• Beispiel: Klasse Dominostein mit Exemplarvariablen links und
rechts (Steine können nicht gedreht werden)
• Klasse Spiel mit Exemplarvariable mitte, einem Stein, an dem
angelegt werden soll
• Spiel benötigt Methode, die für einen zweiten Stein prüft, ob
dieser angelegt werden kann
• schlecht:
bool Spiel::ablegbar(Dominostein d){
return d.getLinks()==mitte.getRechts
|| d.getRechts()==mitte.getLinks();
}
• gut:
bool Dominostein::anlegbar(Dominostein d){
return links==d.rechts || rechts==d.links;
} // in Spiel dann mit mitte.anlegbar(d) prüfen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
242
„Verpacken“ von Exemplarvariablen (Aggregation)
• Generell kann man für Exemplarvariablen vom Typ X statt einer
get-Methode alle Methoden von X anbieten, die man an die
Exemplarvariable weiterleiten will.
• Ansatz auch für Collections geeignet
• XNutzer: Aufrufe an x weiterleiten (Methoden
müssen nicht gleich heißen)
public int getA(){
return x.getA();
}
public void setA(int a){
x.setA(a);
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
243
Erinnerung: Bedeutung von Schnittstellen
• Schnittstellen sind zentrales Element des Design by Contract
• vorgegebene Aufgabe: Implementiere mir folgende
Funktionalität ... beschrieben durch
– Vorbedingung
– Signatur <Sichtbarkeit> <Methodenname>(<Parameter>)...
– Nachbedingung
• Entwickler realisiert OO-Programm (Details sind frei)
• Entwickler garantiert, dass Schnittstelle (oder Fassade)
gewünschte Funktionalität liefert
• generell sollte man bei Vererbungen und Implementierungen
die am wenigsten spezielle benötigte Klasse nutzen; deshalb
List<Projektaufgaben> aufgaben
und nicht
ArrayList<Projektaufgaben> aufgaben im Code
Grundkurs Software-Engineering mit UML
Stephan Kleuker
244
Design by Contract
Grundkurs Software-Engineering mit UML
Stephan Kleuker
245
Dependency Injection
woher kommen Objekte für Exemplarvariablen?
• Variante 1: Werte werden als Parameter übergeben,
aus denen Objekte gebaut werden
• Variante 2: Objekte werden als Referenzen
übergeben
– Optimierung: Typen der Objektvariablen sind
Interfaces; so konkrete Objekte leicht
austauschbar
• Variante 2 heißt Dependency Injection mit get- und
set-Methoden oder über Konstruktoren
Grundkurs Software-Engineering mit UML
Stephan Kleuker
246
Dependency Injection - Beispiel
Inter1
Inter2
Inter3
Nutzer
inter1
inter2
inter3
nutzer
=
=
=
=
new
new
new
new
Grundkurs Software-Engineering mit UML
Inter1RealA(42);
Inter2RealC(43);
Inter3RealD("Hallo");
Nutzer(inter1, inter2, inter3);
Stephan Kleuker
247
Erinnerung: Bedeutung von Polymorphie (1/2)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
248
Erinnerung: Bedeutung von Polymorphie (2/2)
8Rechteck:
273
#include <iostream>
5Kreis:
201.062
8Rechteck:
56
#include <typeinfo>
5Kreis:
50.2655
#include "Rahmen.h"
6RahmenI8RechteckS0_E:
217
#include "Rechteck.h"
6RahmenI8Rechteck5KreisE: 222.735
#include "Kreis.h"
6RahmenI5Kreis8RechteckE: 145.062
6RahmenI5KreisS0_E: 150.796
int main(void){
Rechteck re1(Punkt(6,16),Punkt(27,3));
Kreis k1(Punkt(15,9),8);
Rechteck re2(Punkt(12,13),Punkt(19,5));
Kreis k2(Punkt(15,9),4);
Rahmen<Rechteck,Rechteck> r1(re1,re2);
Rahmen<Rechteck,Kreis> r2(re1,k2);
Rahmen<Kreis,Rechteck> r3(k1,re2);
Rahmen<Kreis,Kreis> r4(k1,k2);
GeoObjekt *g[8]={&re1,&k1,&re2,&k2,&r1,&r2,&r3,&r4};
for(int i=0;i<8;i++)
std::cout<<typeid(*g[i]).name()<<":\t„
<<g[i]->flaeche()<<"\n";
return 0;
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
249
Umgang mit Collections
• Collections sollen als Rückgabeparameter vermieden werden,
damit nicht alle Collection-Methoden nutzbar sind
• Ansatz: Iteratoren auf Listen zurück geben
• Java: Interface Iterable implementieren
public interface Iterable<T>
Implementing this interface allows an object to be the target of the "foreach" statement.
Method Summary
Iterator<T> iterator() Returns an iterator over a set of elements of type T.
• Methode gibt dann (schon implementierten) Iterator der
Collection zurück
• Iterator leicht selbst zu implementieren, mit Methoden
boolean hasNext() Returns true if the iteration has more elements.
E next() Returns the next element in the iteration.
void remove() Removes from the underlying collection the last
element returned by the iterator (optional operation).
Grundkurs Software-Engineering mit UML
Stephan Kleuker
250
Method Chaining (1/3)
• immer sinnvolle Rückgabe nutzen; wenn wählbar
wird statt void Objekt selbst zurück gegeben (this)
• verstößt klar gegen Command-Query Separation
• Beispiel Integer-Menge
public class Main {
public static void main(String[] args) {
IntMenge tmp = new IntMenge();
tmp = tmp.hinzu(new int[]{1,21,11,41,31,1})
.kleinerAls(41).groesserAls(11);
System.out.println(tmp);
}
}
[21, 31]
Grundkurs Software-Engineering mit UML
Dr. Stephan Kleuker
251
Method Chaining (2/3)
public class IntMenge {
private Set<Integer> menge = new HashSet<>();
public IntMenge(){ }
public IntMenge hinzu(int... wert){
for(int w:wert){
this.menge.add(w);
}
return this; // hier sieht man Chaining
}
public IntMenge kleinerAls(int grenze){
IntMenge ergebnis = new IntMenge();
for(int w:this.menge){
if(w < grenze){
ergebnis.hinzu(w);
}
}
return ergebnis;
}
Grundkurs Software-Engineering mit UML
Dr. Stephan Kleuker
252
Method Chaining (3/3)
public IntMenge groesserAls(int grenze){
IntMenge ergebnis = new IntMenge();
for(int w:this.menge){
if(w > grenze){
ergebnis.hinzu(w);
}
}
return ergebnis;
}
public boolean beinhaltet(int wert){
return this.menge.contains(wert);
}
@Override
public String toString(){
return this.menge.toString();
}
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
253
Grundidee von Design-Pattern
8.2
Damit nicht alle Klassen eng miteinander gekoppelt sind, gibt es
Ansätze:
• die Aufgaben einer Klasse von der Verwaltung der Klassen, die
Informationen dieser Klasse benötigen, zu trennen
• die Erzeugung von Objekten möglichst flexibel zu gestalten
• Interfaces zur Trennung von Implementierung und
angebotenen Methoden einzusetzen
• Hierzu werden so genannte Design-Pattern eingesetzt, die für
einen bestimmten Aufgabentyp eine flexible Lösung
vorschlagen
• oft zitiert: E. Gamma, R. Helm, R. Johnson, J. Vlissides,
Entwurfsmuster, Addison-Wesley, 2004 (Gang of Four [GoF]Buch, hier neuere Auflage)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
254
Model-View-Controller
• Typisch für graphische Oberflächen ist, dass es Objekte zur
Eingabe gibt, die zur Bearbeitung der eigentlichen
Inhaltsklasse führen, die dann eventuell zu Änderung der
Anzeige führen
• Die Aufteilung in die drei genannten Aufgaben führt zum ModelView-Controller (MVC)-Ansatz
• MVC wurde zuerst in Smalltalk Ende der 80'er des vorigen
Jahrhunderts eingesetzt:
– Model: Zustandsinformation der Komponente
(Inhaltsklasse)
– View: Beobachter des Zustands, um diesen darzustellen; es
kann viele Views geben
– Controller: Legt das Verhalten der Komponente auf
Benutzereingaben fest
• Idee: Controller steuert Änderungen des Modells, Modell teilt
allen Views mit, dass eine Änderung aufgetreten ist
• Hinweis: Spezielle Form des Beobachter-Musters (Observer)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
255
Java-Beispiel zum MVC (1/6)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
256
Java-Beispiel zum MVC (2/6)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
257
Java-Beispiel zum MVC (3/6)
import java.util.*;
public class XModel{
private ArrayList<XModelListener> listener =
new ArrayList<XModelListener> ();
private int modellwert = 42;
//Verwaltung der Listener des Modells
public void addXModelListener(XModelListener x){
this.listener.add(x);
}
private void fireXModelChanged(){
for(XModelListener x:this.listener)
x.xModelChanged();
}
//Auslesen der Modellinhalte
public int getWert(){
return this.modellwert;
}
//Veränderung des Modells
public void changeValue(int delta){
this.modellwert += delta;
fireXModelChanged();
}
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
258
Java-Beispiel zum MVC (4/6)
import javax.swing.*;
public class XView extends JFrame implements XModelListener{
private XModel xmodel;
private JLabel jlabel = new JLabel("Modellwert:
");
public XView(XModel x){
super("Ich bin der View");
this.xmodel = x;
this.xmodel.addXModelListener(this);
//Rest Swing für Anzeige
getContentPane().add(this.jlabel);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setSize(250,60);
setLocation(0,0);
setVisible(true);
}
}
public void xModelChanged() {
this.jlabel.setText("Modellwert: "
+ this.xmodel.getWert());
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
259
Java-Beispiel zum MVC (5/6)
import java.awt.FlowLayout;
import java.awt.event.*;
import javax.swing.*;
public class XController extends JFrame{
private XModel xmodel;
public XController(XModel x){
super("Ich bin der Controller");
this.xmodel = x;
getContentPane().setLayout(new FlowLayout());
JButton plus = new JButton("plus");
getContentPane().add(plus);
plus.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
this.xmodel.changeValue(1);
}});
JButton minus = new JButton("minus");
getContentPane().add(minus);
minus.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
this.xmodel.changeValue(-1);
}});
setDefaultCloseOperation(EXIT_ON_CLOSE);
setSize(250,60); setLocation(0,90);´setVisible(true);
}
Grundkurs Software-Engineering mit UML
}
Stephan Kleuker
260
Java-Beispiel zum MVC (6/6)
public interface XModelListener {
public void xModelChanged();
/* Anmerkung: alternativ kann man auch geänderte
Werte als Parameter übertragen */
}
public class XStarter {
public static void main(String[] args) {
XModel x = new XModel();
new XView(x);
new XController(x);
}
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
261
Pattern-Varianten
Pattern schlagen eine mögliche Lösung vor; kann in
Projekten variiert werden
• Interface weglassen, wenn nur eine View-Art
• Aufteilung auch sinnvoll, wenn nur ein View existiert
(klare Aufgabentrennung)
• wenn Controller und View eng verknüpft, können sie
vereinigt werden, z. B. GUI-Elemente in Java-Swing
• Listenerverwaltung kann vom Model in Controller
verlegt werden
• auch ohne Listen ist MVC-Aufteilung sinnvoll
4: neue Darstellung
View
Controller
1: Nutzereingabe
Grundkurs Software-Engineering mit UML
2: Eigenschaften aktualisieren
3: Aktualisierung
Stephan Kleuker
Model
262
Ansatz Observer-Observable
8.3
• Es gibt Subjekte für deren Zustand sich viele
interessieren (z. B. Nachrichtenkanäle)
• Die Subjekte bieten die Möglichkeit, dass sich
Interessenten anmelden (z. B. Kanal abonnieren)
• Bei jeder Subjektzustandsänderung werden
Interessenten informiert (neue Nachrichten)
• Interessent muss sich bei Subjekt anmelden
• Damit obiges Objekt weiß, wie Interessent
angesprochen werden soll, muss Interessent
Schnittstelle realisieren
• Hinweis: Enge Verwandtschaft zu Model-ViewController
Grundkurs Software-Engineering mit UML
Stephan Kleuker
263
Beobachter (Observer – Observable)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
264
Pattern und Varianten
• Für fast jeden Pattern gibt es Varianten, die abhängig
von Randbedingungen sinnvoller sein können
Bsp.: Wertänderung mit aktualisieren übertragen
Bsp.: Java hat keine Mehrfachvererbung
• Subjekt wird Interface
• Listenverwaltung in
Hilfsklasse
• Konkretes Subjekt
delegiert Listenaufgaben an Objekt
der Hilfsklasse
Grundkurs Software-Engineering mit UML
Stephan Kleuker
265
Adapter - Problem
Szenario:
• Klasse IchBrauchB benötigt ein Objekt der Klasse B, genauer
spezielle Funktionalität (Methode) der Klasse B
• Wir haben bereits eine Klasse C, die die von IchBrauchB von B
geforderte Funktionalität anbietet
• C bietet die gewünschte Funktionalität unter dem falschen
Methodennamen an, da C Teil einer komplexen
Klassenstruktur ist, kann C nicht verändert werden
Lösung:
• Schreibe Adapterklasse, die sich wie B verhält (von B erbt bzw.
Interface B implementiert) und Objekt der Klasse C aggregiert
• Adapter leitet Aufruf der von IchBrauchB gewünschten
Funktionalität an C weiter
Grundkurs Software-Engineering mit UML
Stephan Kleuker
266
Adapter - Lösung
public class Adapter implements B{
private C c = null;
...
public Adapter(){
c = new C();
}
...
@Override
public void machWasTolles(){
return c.kannWasWasAuchBKoennenSoll();
}
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
267
Fassade nach außen
• Generell sollen Klassen eng zusammenhängend sein, z. B. Methoden können nicht
auf mehrere Klassen verteilt werden.
• anderen Nutzern möchte man nur eine
einfache externe Sicht bieten, deshalb
liefern zusammenhängende Klassen
häufiger eine Fassadenklasse
(„davorgeklatscht“) nach außen.
Grundkurs Software-Engineering mit UML
Stephan Kleuker
268
Beispielanwendung: Abstract Factory Pattern
Grundkurs Software-Engineering mit UML
Stephan Kleuker
269
Ausschnitt aus möglichem Code
public class Verpackung{
private Spielefabrik fabrik=null;
private Spielbrett brett=null; //
private Spielfigur figur=null;
public Verpackung(Spielefabrik sf){
fabrik=sf;
brett=fabrik.getSpielbrett();
figur=fabrik.getSpielfigur();
}
...
public int berechneVolumen(){
return
brett.getFlaeche()*figur.getHoehe();
}
...
}
Vorteil: Leichte Ergänzung neuer Spiele, mit Spielbrettern und
Spielfiguren
Nachteil: Aufwändig neue Objektart, z. B. Spielanleitung, zu
ergänzen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
270
Einsatzmöglichkeiten von Sichtbarkeiten
• Standard-OO-Programmierung: Exemplarvariablen private
[oder protected], Exemplarmethoden public (analog für
Klassenvariablen und –methoden)
• In Spezialfällen können Sichtbarkeiten geändert werden,
Beispiel:
– Im gesamten System gibt es ein Objekt, mit dem die
Verbindung zu anderen Systemen aufgebaut wird
– Wird das Objekt das erste Mal benötigt, wird es erzeugt, bei
weiteren Anfragen werden Referenzen auf dieses identische
Objekt zurück gegeben
• Objekt muss in Klassenvariable gespeichert werden
• Nutzer dürfen keine Konstruktoren aufrufen, da es sonst
verschiedene Objekte gibt (Konstruktoren werden
private)
• Zugriff auf das Objekt über Klassenmethoden
Grundkurs Software-Engineering mit UML
Stephan Kleuker
271
Singleton (1/3)
public class Singleton {
private int x = 0;
private int y = 0;
private static Singleton pkt = null; // einziges
//Exemplar
private Singleton(int x, int y){
this.x = x;
this.y = y;
}
public static Singleton getPunkt(){
if (pkt==null) // ein einziges Mal erzeugen
pkt= new Singleton(6,42);
return pkt;
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
272
Singleton (2/3)
@Override
public Singleton clone(){
//echtes Kopieren verhindern
return this;
}
public void ausgeben(){
System.out.print("["+this.x+","+this.y+"]");
}
public void verschieben(int dx, int dy){
this.x += dx;
this.y += dy;
}
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
273
Singleton (3/3)
public class Main {
public static void main(String[] s){
Singleton p1=Singleton.getPunkt();
Singleton p2=Singleton.getPunkt();
// Singleton sing= new Singleton();
//constructor not visible
p1.ausgeben();
p2.ausgeben();
if(p1==p2)
System.out.println("\n identisch");
p1.verschieben(3,5);
[6,42][6,42]
p1.ausgeben();
identisch
p2.ausgeben();
[9,47][9,47]
Singleton p3=p1.clone();
identisch
if(p2==p3)
System.out.println("\n identisch");
}
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
274
Proxy
• Beim Proxy (oder Stellvertreter)-Pattern wird der Zugriff auf
eine „wertvolle“ Ressource durch eine vorgeschaltete Klasse
gesteuert
• Nutzer des Proxys nutzen diesen wie die eigentliche Klasse
Grundkurs Software-Engineering mit UML
Stephan Kleuker
275
Proxy – Implementierungsmöglichkeit (1/2)
public interface KlasseMitWertvollemInhalt {
public int anfrage(String details);
}
public class RealeKlasse implements
KlasseMitWertvollemInhalt {
private Verbindung verbindung;
public RealeKlasse(String verbindungsdaten){
verbindung=new Verbindung(verbindungsdaten);
}
public int anfrage(String details) {
return verbindung.befragen(details);
}
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
276
Proxy – Implementierungsmöglichkeit (2/2)
public class Proxy implements KlasseMitWertvollemInhalt {
//Variante mit Singleton (gibt Alternativen)
private static RealeKlasse realesObjekt;
public Proxy(){
if(realesObjekt==null)
realesObjekt= new RealeKlasse("Spezialinfos");
}
public int anfrage(String details) {
return realesObjekt.anfrage(details);
}
}
public class Nutzer {
public int proxyNutzen(String anfrage){
KlasseMitWertvollemInhalt k=new Proxy();
return k.anfrage(anfrage);
}
public static void main(String[] s){
//etwas sinnlos, zu Testzwecken
Nutzer n= new Nutzer();
System.out.println(n.proxyNutzen("gib41"));
}
Grundkurs Software-Engineering mit UML
}
Stephan Kleuker
277
Strategy - Problem
• Für eine Methode gibt es verschiedene
Möglichkeiten sie zu implementieren
• Die Wahl der Implementierungsart soll leicht
verändert werden können
Einsatzszenarien
• Prototypische Implementierung soll später leicht
ausgetauscht werden können
• Wahl der effizientesten Methode hängt von weiteren
Randbedingungen ab (z. B. suchen / sortieren)
• Ausführungsart der Methode soll zur Laufzeit
geändert werden können (Kunde zahlt für einen
Dienst und bekommt statt WerbeDetailinformationen)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
278
Strategy - Lösungsbeispiel
Grundkurs Software-Engineering mit UML
Stephan Kleuker
279
State-Pattern (eigene Variante)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
280
State-Pattern – Implementierungsauszug (1/2)
public abstract class Zustand {
protected int x;
public abstract Zustand setX(int x);
public abstract String status();
protected Zustand(int x){
this.x=x;
}
}
public class ZustandOK extends Zustand{
public ZustandOK(int x) {
super(x);
}
@Override
public Zustand setX(int x) {
this.x=x;
if(x>=42) return new ZustandKritisch(x);
return this;
}
@Override
public String status() {return "alles ok";}
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
281
State-Pattern – Implementierungsauszug (2/2)
public class Messstation {
private String standort = "City";
private Zustand z= new ZustandOK(0);
public void zustandAendern(int wert){
z=z.setX(wert);
}
public void ausgeben(){
System.out.println(standort
+" Zustand: "+z.status());
}
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
282
Command-Pattern
• Problem: unterschiedliche Aktionen werden zentral
ausgeführt und verwaltet
• Ansatz: Stecke detaillierte Ausführung in ein
(Command-)Objekt; diese haben gemeinsames
Interface
• Command-Objekte kennen Details der Ausführung
• Steuerung dann einfach änder- und erweiterbar
• Beispiel: Kleiner Taschenrechner mit + und – und
einem Zwischenspeicher für einen Wert, der dann
aufaddiert werden kann
Grundkurs Software-Engineering mit UML
Stephan Kleuker
283
Beispiel 1/12 : Rechner 1/2
package business;
public class Rechner {
private int anzeige;
private int speicher;
public int getAnzeige() {
return anzeige;
}
public void setAnzeige(int anzeige) {
this.anzeige = anzeige;
}
public int getSpeicher() {
return speicher;
}
public void setSpeicher(int speicher) {
this.speicher = speicher;
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
284
Beispiel 2/12 : Rechner 2/2
public void addieren(int wert) {
this.anzeige += wert;
}
public void subtrahieren(int wert) {
this.anzeige -= wert;
}
public void speichern(){
this.speicher = this.anzeige;
}
public void speicherAddieren(){
this.anzeige += this.speicher;
}
public void speicherSubtrahieren(){
this.anzeige -= this.speicher;
}
@Override
public String toString(){
return "Speicher: "+ this.speicher +"
+ this.anzeige;
}
Grundkurs Software-Engineering mit UML
}
Stephan Kleuker
Wert: "
285
Beispiel 3/12 : Klassischer Dialog 1/2
package io;
import business.Rechner;
public class Dialog {
private Rechner rechner = new Rechner();
public void dialog() {
EinUndAusgabe ea = new EinUndAusgabe();
int eingabe = -1;
while (eingabe != 0) {
System.out.println("(0) Programm beenden\n"
+ "(1) addieren\n"
+ "(2) subtrahieren\n"
+ "(3) Anzeige in Speicher\n"
+ "(4) Speicher addieren\n"
+ "(5) Speicher subtrahieren");
eingabe = ea.leseInteger();
switch (eingabe) {
case 1: {
System.out.print("Wert eingeben: ");
this.rechner.addieren(ea.leseInteger());
break;
}
Grundkurs Software-Engineering
mit UML
Stephan Kleuker
286
Beispiel 4/12 : Klassischer Dialog 2/2
case 2: {
System.out.print("Wert eingeben: ");
this.rechner.subtrahieren(ea.leseInteger());
break;
}
case 3: {
this.rechner.speichern();
break;
}
case 4: {
this.rechner.speicherAddieren();
break;
}
case 5: {
this.rechner.speicherSubtrahieren();
break;
}
}
System.out.println(this.rechner);
}
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
287
Beispiel 5/12 : Funktioniert immerhin
(0) Programm beenden
(1) addieren
(2) subtrahieren
(3) Anzeige in Speicher
(4) Speicher addieren
(5) Speicher subtrahieren
1
Wert eingeben: 43
Speicher: 0 Wert: 43
(2) subtrahieren
2
Wert eingeben: 1
Speicher: 0 Wert: 42
(3) Anzeige in Speicher
3
Speicher: 42 Wert: 42
Grundkurs Software-Engineering mit UML
(4) Speicher addieren
4
Speicher: 42 Wert: 84
(5) Speicher subtrahieren
5
Speicher: 42 Wert: 42
(0) Programm beenden
0
Speicher: 42 Wert: 42
Stephan Kleuker
288
Beispiel 6/12 : Ansatz 1: Steuerungsklassen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
289
Beispiel 7/12 : Umsetzung 1/3
package io.commands;
public interface Command {
public void execute();
}
package io.commands;
import main.EinUndAusgabe;
import business.Rechner;
public class Addieren implements Command {
private Rechner rechner;
typischerweise werden
Zusatzinformationen
public Addieren(Rechner rechner){
this.rechner = rechner;
benötigt
}
eigentliche
@Override
Ausführung
public void execute() {
System.out.print("Wert eingeben: ");
this.rechner.addieren(new EinUndAusgabe().leseInt());
}
@Override
public String toString(){return "addieren";}
} Grundkurs Software-Engineering mit UML
Stephan Kleuker
290
Beispiel 8/12 : Umsetzung 2/3 (Varianten -> Praktikum)
package main;
import java.util.HashMap;
import java.util.Map;
import business.Rechner;
public class Dialog {
private Rechner rechner = new Rechner();
private Map<Integer,Command> aktionen = new HashMap<>();
public Dialog(){
this.aktionen.put(1, new Addieren(this.rechner));
this.aktionen.put(2, new Subtrahieren(this.rechner));
this.aktionen.put(3
, new AnzeigeSpeichern(this.rechner));
this.aktionen.put(4
, new SpeicherAddieren(this.rechner));
this.aktionen.put(5
, new SpeicherSubtrahieren(this.rechner));
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
291
Beispiel 9/12 : Umsetzung 3/3
public void dialog() {
EinUndAusgabe ea = new EinUndAusgabe();
int eingabe = -1;
while (eingabe != 0) {
System.out.println("(0) Programm beenden");
for(int tmp:this.aktionen.keySet()){
System.out.println("("+tmp+") "
+ this.aktionen.get(tmp));
}
eingabe = ea.leseInteger();
Command com = this.aktionen.get(eingabe);
if(com !=null){
com.execute();
}
System.out.println(this.rechner);
}
Grundkurs
Stephan Kleuker
292
} Software-Engineering mit UML
Beispiel 10/12 : Undo
• Command-Pattern eignet sich sehr gut, Aktionen
wieder rückgängig zu machen
• es müssen alle Änderungen der Aktion bekannt und
reversibel sein
• gibt verschiedene Varianten
– Ansatz 1: jedes Command-Objekt hat undoMethode und wird gespeichert
– Ansatz 2: es gibt eigenes Undo-Command-Objekt
als Ergebnis von execute()
– Ansatz 3: Undo- und Command-Objekte haben
keine gemeinsame Klasse / Interface
–…
Grundkurs Software-Engineering mit UML
Stephan Kleuker
293
Beispiel 11/12 : Variante Undo-Methode
Grundkurs Software-Engineering mit UML
Stephan Kleuker
294
Beispiel 12/12 : Variante Undo-Objekte (Skizze)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
295
Fazit Command-Pattern
• generell oft bei Steuerungen einsetzbar
• oft gut für Undo- und Redo geeignet
• meist individuelle Varianten des Patterns sinnvoll
• (in UML-Diagrammen oft zusätzliche Klasse, die auf
Command zugreifen kann)
• Command-Klassen müssen einfach an benötigte
Informationen kommen können; wird dies
kompliziert, ist der Patter-Einsatz nicht sinnvoll
Grundkurs Software-Engineering mit UML
Stephan Kleuker
296
Beschreibung des Pattern
8.4
Name: Abstract Factory
Patterngruppe: Objekterzeugung
Kurzbeschreibung: Client kann mit einer AbstractFactory zu einer
abstrakten Klasse passende Exemplare aus einem Satz konkreter
Implementierungen für bestimmtes Produkt erzeugen, kennt den
konkreten Typ des erzeugten Exemplars nicht
Kontext: viele verschiedene gleichartige, aber unterscheidbare
Objekte sollen verwaltet werden
Problem: Klasse soll verschiedene Objekte bearbeiten, benötigt
aber nur deren gemeinsame Eigenschaften
Lösung: Einführung von zwei abstrakten Klassen, die zum Einen
Objekterzeugung, zum Anderen Objektzugriff erlauben, Client
muss nur diese Klassen kennen
Einsatzgebiete: ...
Varianten: ...
Grundkurs Software-Engineering mit UML
Struktur: s.o.
Stephan Kleuker
Beispiele:
297
Gruppen von Pattern (Beispiele)
• Strukturpattern befassen
sich mit der Komposition
von Klassen und Objekten,
um größere Strukturen zu
bilden
Zielsetzungen:
– Anpassung von
Schnittstellen (Adapter)
– Trennung von
Abstraktion und
Implementierung
(Brücke)
– Zusammensetzung von
Objekten (Kompositum)
– Erzeugen von
Stellvertreterobjekten
(Proxy)
Grundkurs Software-Engineering mit UML
• Erzeugungspattern sollen
das Wissen um das System
und die konkreten Klassen
des Systems vor dem
Benutzer verstecken
Zielsetzungen:
– Systeme leichter
konfigurierbar zu machen
– Änderungen im Entwurf
vorherzusehen
• Verhaltenspattern ...
Stephan Kleuker
298
GoF-Pattern Übersicht (nicht auswendig lernen)
Objekt
Einsatzbereich
Klasse
Aufgabenbereich
Erzeugung
Struktur
Verhalten
Factory
Adapter
Interpreter
Template
Abstract
Factory
Adapter
Command
Builder
Bridge
Observer
Prototype
Decorator
Visitor
Singleton
Facade
Memento
Composite
Strategy
Proxy
Mediator
Flyweight
State
Chain of
Responsibility
Grundkurs Software-Engineering mit UML
Stephan Kleuker
299
Pattern in der UML
Pattern-Name im gestrichelten Kreis, verbunden mit eingekreisten
Klassen, verbunden mit Pattern und Bennenung der Rollen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
300
Kritische Betrachtung von Pattern
• Pattern für Anfänger wenig geeignet, man
muss erste Erfahrungen haben, um von
Erfahrungen anderer zu profitieren
• überlagernde Pattern schwer pflegbar, später
in Implementierungen teilweise schwer
erkennbar
• ?? Wer mit Pattern umgehen kann, sollte in
kritischeren Bereichen einer Firma eingesetzt
werden ??
• Pattern finden Einzug in Bibliotheken, Beispiel:
Event-Handling in Java ist „Observer-Pattern“
• Generell sind Pattern ein wichtiger Teilschritt
zum ingenieurmäßigen SW-Engineering
• Gute Programmier-Aufgabe: Entwickeln Sie
kleine Beispiele zu allen GoF-Pattern !!!
Grundkurs Software-Engineering mit UML
Stephan Kleuker
301
9. Implementierungsaspekte
9.1 Einfluss nicht-funktionaler Anforderungen
9.2 Verteilte Systeme
9.3 Grundideen von XML
Hinweis: Hier nur Skizze
9.4 Programmbibliotheken
interessanter Konzepte,
9.5 Komponenten
die Schwerpunkte weiterer
9.6 Frameworks
Veranstaltungen sind
9.7 Persistente Datenhaltung
9.8 Annotationen
9.9 Domain Specific Languages
9.10 Model Driven Architecture
9.11 Refactoring
Grundkurs Software-Engineering mit UML
Stephan Kleuker
302
Randbedingungen für erfolgreiches Design
Nach Analysemodell und vor Design stehen wichtige
Entscheidungen
bisher:
• wir kennen die generelle Entwicklung einer SW-Architektur
(Pakete)
• wir entwickeln klassische SW für einen Rechner, Objekte
können theoretisch Methoden beliebiger anderer Objekte
aufrufen
aber vor Beginn der Designphase spielt auch die
Berücksichtigung weiterer Randbedingungen zentrale Rolle:
• muss existierende SW eingebunden werden?
• muss für eine spezielle HW entwickelt werden?
• welche Anforderungen gibt es an die Verteilung von SW auf
unterschiedliche Rechner?
• welche Rolle spielen nichtfunktionale Anforderungen (Safety,
Security, Performance, Oberflächendesign)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
303
Beispiel: Rahmenbedingungen für SW-Architektur
9.1
• Berücksichtigung von speziellen SW-Schnittstellen
nicht objektorientiert entwickelter Systeme, z. B. von
Application Programming Interfaces (API) fremder
SW
• Berücksichtigung/Benutzung existierender
Datenhaltungssysteme, z. B. Vorgabe des
Datenbankmanagementsystems (DBMS)
• Berücksichtigung bestimmter Design-Prinzipien, z.
B. Gesamtsteuerung mit Enterprise Java Beans
(EJB) oder .NET für die Realisierung
• Alt-Software (z. B. in COBOL), so genannte LegacySysteme müssen eingebunden werden; Einsatz einer
Middleware (z. B. Common Object Request Broker
Architecture, CORBA)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
304
Einfluss nichtfunktionaler Anforderungen
Beispiel: Sicherheit (Security)
• Alle Nachrichten müssen über den speziellen
Krypto-Server laufen; dieser hat bestimmte
Bandbreite (Bottle-neck); SW muss auf allen Seiten
möglichst viel ohne Verbindung arbeiten können
(Redundanz wird erlaubt)
Beispiel: Sicherheit (Safety)
• Berechnungen zur Steuerung müssen redundant auf
drei Rechnern mit unterschiedlichen Verfahren
durchgeführt werden
Beispiel: Performance
• Die rechenintensiven 3D-Berechnungen müssen
sehr schnell sein; dies kann zum Einsatz von C mit
langen komplexen Funktionen führen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
305
Rahmenbedingung: verteilte Systeme
9.2
• in der klassischen OO-Programmierung gibt es einen
Programmablauf (Prozess) und man nutzt synchrone Aufrufe:
Objekt O1 ruft Methode von Objekt O2 auf; O2 übernimmt die
Programmausführung und antwortet dann O1
• bei verteilten Systemen laufen viele Prozesse parallel ab, die
Informationen austauschen können
• synchroner Aufruf ist möglich, bedeutet aber, dass Verbindung
aufgebaut werden muss und Sender bzw. Empfänger auf
Bereitschaft warten müssen
• asynchroner Aufruf bedeutet, dass Sender Aufruf abschickt und
danach weiterarbeitet; später prüft, ob ein Ergebnis vorliegt
• asnychrone Aufrufe sind schneller (nur abschicken); Prozesse
sind aber schwer zu synchronisieren
• die Herausforderung effizienter verteilter Systeme hat nicht die
eine Lösung und wird Sie Ihr Informatik-Leben-lang verfolgen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
306
Probleme der Aufrufmechanismen
synchroner Aufruf
Problem: Deadlock
Prozess A Prozess B Prozess C
warten auf
Antwort
warten auf
Antwort
asynchroner Aufruf
Problem: B denkt, x hat
vor y stattgefunden
Problem: C denkt, x hat
vor y stattgefunden, A
denkt, y hat vor x
stattgefunden
Grundkurs Software-Engineering mit UML
Stephan Kleuker
307
Typische Probleme verteilter Systeme
• Deadlocks: kein Prozess/Thread kann voran schreiten
• partielle Deadlocks: einige Prozesse im Deadlock, andere nicht
• Livelocks: System versucht, sich zyklisch zu synchronisieren,
ohne dass das System voran schreitet
• (starke) Fairness : kommen Prozesse, die immer mal wieder
darauf warten, in den kritischen Bereich zu kommen, auch dran
• (schwache) Fairness: kommen Prozesse, die immer darauf
warten, in den kritischen Bereich zu kommen, auch dran
• synchronized() in Java (Methode wird garantiert ohne
Parallelnutzung des aufgerufenen Objekts genutzt) hat starken
negativen Einfluss auf die Laufzeit
• Erinnerung/Ausblick: Notwendige Transaktionssteuerung bei
Datenbankmanagementsystemen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
308
Beispiel: Varianten von Client-Server-Systemen
• Thin Client: Hier nur
Datenannahme,
Weiterleitung, Darstellung,
keine komplexen
Berechnungen
• Beispiele: Web-Browser, DBClients
Client
Netzwerk
• Fat Client: Client führt
eigene komplexe
Berechnungen aus; nutzt
Server nur zur Verwaltung
zentraler Informationen und
zum Nachrichtenaustausch
• Beispiel: vernetzbare Standalone-Spiele (Autorennen)
Client
Netzwerk
Server
Server
Grundkurs Software-Engineering mit UML
Stephan Kleuker
309
Beispiel: 3-Tier-Architektur
Client
Präsentationsschicht
Server für Anwendung
eigentliche Anwendungs-SW
Datenbank-Server
persistente Datenhaltung
Grundkurs Software-Engineering mit UML
Verteilung:
• Nur Darstellung (GUI) beim
Client
• eigener Server für Anwendung
• eigene Datenspeicherung
Vorteile:
• benötigte DB-Verbindungen
können angepasst werden
(Kosten)
• Datenbank nicht direkt für
Client zugreifbar (Sicherheit)
• Änderungen einer Schicht
müssen andere Schichten
nicht beeinflussen
Stephan Kleuker
310
Erinnerung: XML
9.3
• eXtensible Markup Language
• strukturierte maschinen- und ansatzweise menschenlesbare
Informationsbeschreibung
• Applikationen müssen Daten vor der Programmbeendung
speichern, sollten diese mit anderen Programmen austauschen
können (-> Definition eines gemeinsamen XML-Formats)
• Neben reiner Syntax kann auch die erlaubte inhaltliche Struktur
spezifiziert werden (DTD: Document Type Definition), XMLSchema
• Viele gute Werkzeuge und Bibliotheken zur XML-Verarbeitung
• zentrale Inhalte werden mit Elementen und Attributen
beschrieben
• Strukturierung durch Namensräume
Grundkurs Software-Engineering mit UML
Stephan Kleuker
311
Elemente
• Elemente beschreiben zentrale Inhalte von XMLDokumenten
• Namen der Elemente können vom Autor frei
vergeben werden (soll Dokument mit verschiedenen
Applikationen bearbeitet werden, muss man sich auf
das Vokabular einigen -> später)
• Typische Form
<projektname> XML-DB </projektname>
• Element heißt projektname, der Inhalt ist vom
sogenannten Start- und End-Tag umgeben
• Abkürzungsmöglichkeit bei leerem Inhalt:
<projektname/>
• Leerzeichen führen meist zu Fehlern, hier z. B. drei
<■bla > <■/■bla >
Grundkurs Software-Engineering mit UML
Stephan Kleuker
312
Hierarchischer Aufbau
• Elemente können ineinander geschachtelt werden
• Ausgehend vom obersten Element ergibt sich ein Baum
<team>
<mitarbeiter>
<minr>42</minr>
team
<name>Aische Meier</name>
<anteil>40</anteil>
mitarbeiter
mitarbeiter
</mitarbeiter>
<mitarbeiter>
minr name anteil
minr name anteil
<minr>46</minr>
<name>Nabil Ibn</name>
<anteil>50</anteil>
</mitarbeiter>
</team>
Grundkurs Software-Engineering mit UML
Stephan Kleuker
313
Attribute
• Jedes Element kann eine beliebige Anzahl an
Attributen haben
• Attribute stehen in Anführungsstrichen (" oder ')
<projekt abteilung="Entwicklung"
vertrag="Festpreis">
<projektname>Speichermodul</projektname>
<kunde blz="65566445" knr="35674534" />
<projektleiter kosten="1000">
<minr>49</minr>
<name>Ute Rose</name>
<anteil>50</anteil>
</projektleiter>
</projekt>
Grundkurs Software-Engineering mit UML
Stephan Kleuker
314
Attribute oder Elemente
• Attribute beschreiben Eigenschaften von Elementen
• Eigentlicher Inhalt steht zwischen den Tags
• Aus theoretischer Sicht vertauschbar
<projekt abteilung="Entwicklung"
vertrag="Festpreis"/>
• alternativ
<projekt>
<abteilung> Entwicklung </abteilung>
<vertrag> Festpreis </vertrag>
</projekt>
• Aus Sicht der Verarbeitung leichte Unterschiede,
Tendenz zu Attributen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
315
Kommentare und Namensregeln
• Grundsätzlich existieren nur kommentierte Produkte
• XML Kommentar in <!-- und --> eingeschlossen
<!-- Isch bin ähn Gommenta -->
• Im Kommentartext kein -- erlaubt, auch keine Schachtelung
• Kommentare in Elementen nicht erlaubt
• XML unterscheidet Groß- und Kleinschreibung, Elemente und
Attribute meist klein (keine sehr feste Regel)
• Bezeichner müssen mit Buchstaben oder _ oder : beginnen
• In Bezeichnern beliebige Zeichen erlaubt
• Grundregeln für eigene Elementnamen:
– selbsterklärend
– nicht mit _ oder : beginnen (für Spezialfälle, : generell nicht)
– auf Umlaute verzichten
Grundkurs Software-Engineering mit UML
Stephan Kleuker
316
Genereller Aufbau eines XML-Dokuments
• Dokument beginnt mit XML-Deklaration gefolgt von Element
• folgt: jedes XML-Dokument als Baum mit Wurzel betrachtbar
(mit root element oder document element)
<?xml version="1.0" encoding="utf-8"?>
<!-- angeblich generiert aus Spro -->
<projekt abteilung="Entwicklung"
vertrag="Eigenentwicklung">
<projektname>Speicher </projektname>
</projekt>
• version (bleibt vielleicht immer) 1.0 oder 1.1
• encoding gibt verwendeten Zeichensatz an, hier klein oder
Großschreibung möglich, typisch sind
UTF-8
8 Bit Zeichenbereite (Standard)
UTF-16
16 Bit Zeichenbreite (bel. Sprachen)
ISO-8859-1
Westeuropäische Sprachen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
317
Nutzung von Programmbibliotheken
9.4
• Programmbibliotheken stellen Standardlösungen für häufig
wiederkehrende Probleme dar
• typische Nutzung: Nutzer erzeugt und ruft Objekte (Klassen)
der Bibliothek auf
• Bibliotheken sind geprüft (hoffentlich) und für Laufzeiten
optimiert
• Dokumentation von Bibliotheken wichtig zum effizienten
Einsatz (was rufe ich wann auf)
• Je größer der Verbreitungsgrad, desto einfacher die
Weiterverwendung von Ergebnissen (großer Vorteil der JavaKlassenbibliothek)
• Grundregel für erfahrene Entwickler: Erfinde das Rad niemals
zweimal, weiß aber, wo viele Blaupausen für viele verschiedene
Räder sind
• Grundregel für Informatikanfänger: Lerne zu verstehen, wie
man das erste Rad baut, baue das erste Rad und lerne warum
man wie die Blaupause variieren kann
Grundkurs Software-Engineering mit UML
Stephan Kleuker
318
Idee von Komponenten
9.5
• Komponenten sind komplexe in sich abgeschlossene „binäre“
SW-Bausteine, die größere Aufgaben übernehmen können
• Ansatz: SW statt aus kleinen Programmzeilen aus großen
Komponenten (+ Klebe-SW) zusammen bauen
• Komponenten werden konfiguriert, dazu gibt es get-/setMethoden (Schnittstelle) oder/und Konfigurationsdateien
• Beispiel Swing-Klassen, wie JButton haben (u. a.)
Komponenteneigenschaft; man kann u. a. einstellen:
– Farben (Hintergrund, Vordergrund)
– Schrifttypen
– Form der Ecken
– dargestelltes Bild
• Komponenten sind themenorientiert und können
unterschiedliche Aufgaben erfüllen (z. B. Daten filtern, Werte
überwachen)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
319
GUI-Builder (1/2)
• Die Programmierung von Oberflächen in Java ist
zwar recht strukturiert möglich, viele Arbeitsschritte
wiederholen sich aber monoton
• GUI-Builder stellen einen anderen Ansatz zur
Entwicklung von Oberflächen vor, Oberflächen
werden per Drag-and-Drop zusammengestellt
• Die weitere Programmierung findet durch den
Entwickler „unterhalb“ der GUI-Elemente statt, jeder
Code muss einer Komponente zugeordnet werden
• GUI-Builder eignen sich damit sehr gut, schnell
einen GUI-Prototypen zu erstellen, um mit den
späteren Nutzern das Look-and-Feel zu diskutieren
Grundkurs Software-Engineering mit UML
Stephan Kleuker
320
GUI-Builder (2/2)
• GUI-Builder haben aber auch Nachteile:
– Software ist häufig nicht GUI-gesteuert entwickelbar, je
komplexer das „Innenleben“ ist, desto weniger steht das GUI
in der Entwicklung im Mittelpunkt
– wer nicht weiß, wie ein GUI funktioniert, programmiert nur
Fragmente und kennt das Zusammenspiel des Systems nicht
– oftmals können ohne GUI-Builder entwickelte Oberflächen
nicht mit dem GUI-Builder weiter bearbeitet werden
– GUI-Builder geben die Struktur des Codes vor, d.h. man
muss sich auf die Programmiereigenheiten des GUI-Builders
zu 100% einlassen
– die Unterstützung von Pattern (guten Designideen, wie MVC)
ist nicht immer gegeben
• Fazit: Der Einsatz eines GUI-Builders sollte nur in Betracht
gezogen werden, wenn man die Grundsätze zur GUI-Entwicklung
in der jeweiligen Programmiersprache verstanden hat, danach
muss getestet werden, ob man mit dem resultierenden Code
leben kann
Grundkurs Software-Engineering mit UML
Stephan Kleuker
321
Zentrale Eigenschaften von Komponenten
Grundkurs Software-Engineering mit UML
Stephan Kleuker
322
Idee der Framework-Technologie
9.6
• statt vollständiger SW werden Rahmen
programmiert, die um Methodenimplementierungen
ergänzt werden müssen
• Frameworks (Rahmenwerke) können die Steuerung
gleichartiger Aufgaben übernehmen
• typische Nutzung: Nutzer instanziiert FrameworkKomponenten, d. h. übergibt seine Objekte zur
Bearbeitung durch das Framework; typischer
Arbeitsschritt: Framework steuert, d. h. ruft Methode
der Nutzerobjekte auf
• eventuelles Problem: schwieriger Wechsel zu
anderem Framework oder bei Ablösung des
Frameworks
Grundkurs Software-Engineering mit UML
Stephan Kleuker
323
Framework-Technologie in Swing
Framework-Technologie „im Kleinen“:
• auch Java-Klassenbibliothek [kritischer Name] bietet es an,
dass einfache Klassen zu Komponenten des Model-DelegateAnsatzes der Swing-Komponenten werden
• Beispiele: JTree (oder JTable)
• Forderung: Eine darzustellende Klasse muss das zugehörige
Interface TreeModel implementieren
• Konstruktor JTree(TreeModel tm)
• Eigenschaften eines JTree, z. B. wie Inhalte dargestellt werden,
können über Methoden gesteuert werden (JTree wird als
normales Element der Klassenbibliothek genutzt)
• JTree steuert die Darstellung, ruft dazu Methoden des
TreeModel auf
Grundkurs Software-Engineering mit UML
Stephan Kleuker
324
TreeModel
Ausschnitt: angebotene Methoden (s. Java-Dokumentation)
void addTreeModelListener(TreeModelListener l)
Adds a listener for the TreeModelEvent posted after the tree changes.
Object getChild(Object parent, int index)
Returns the child of parent at index index in the parent's child array.
int getChildCount(Object parent)
Returns the number of children of parent.
int getIndexOfChild(Object parent, Object child)
Returns the index of child in parent.
Object getRoot()
Returns the root of the tree.
boolean isLeaf(Object node)
Returns true if node is a leaf.
void removeTreeModelListener(TreeModelListener l)
Removes a listener previously added with addTreeModelListener.
void valueForPathChanged(TreePath path, Object newValue)
Messaged when the user has altered the value for the item identified
by path to newValue.
Grundkurs Software-Engineering mit UML
Stephan Kleuker
325
Skizze einer Beispielimplementierung (1/5)
Knoteninformation dient dazu, für den jeweiligen Knoten die
darstellungsrelevanten Informationen zu liefern
Grundkurs Software-Engineering mit UML
Stephan Kleuker
326
Skizze einer Beispielimplementierung (2/5)
ProjektTreeModel ptm =
new ProjektTreeModel();
JTree baum = new JTree(ptm);
JScrollPane scroller =
new JScrollPane(baum);
add(scroller,BorderLayout.CENTER);
Grundkurs Software-Engineering mit UML
Stephan Kleuker
327
Skizze einer Beispielimplementierung (3/5)
public class ProjektTreeModel implements TreeModel {
private Projektverwaltung projektverwaltung;
private List<TreeModelListener> listener =
new ArrayList<TreeModelListener>();
public ProjektTreeModel() {
this.projektverwaltung = new Projektverwaltung();
}
public Object getRoot() {
return this.projektverwaltung;
}
public Object getChild(Object arg0, int i) {
return ((Knoteninformation)arg0).itesElement(i);
}
public int getChildCount(Object arg0) {
return ((Knoteninformation)arg0).anzahlElemente();
}
public void addTreeModelListener(TreeModelListener arg0){
this.listener.add(arg0);
}
} // nur Ausschnitt
Grundkurs Software-Engineering mit UML
Stephan Kleuker
328
Skizze einer Beispielimplementierung (4/5)
public class Projektverwaltung implements Knoteninformation{
private List<Projekt> projekte = new ArrayList<Projekt>();
public int anzahlElemente() {
return this.projekte.size();
}
public Knoteninformation itesElement(int i) {
return this.projekte.get(i);
}
public boolean istBlatt() {
return false;
}
public String titel() {
return "Projektverwaltung";
}
@Override
public String toString(){
return titel();
}
} // nur Ausschnitt
Grundkurs Software-Engineering mit UML
Stephan Kleuker
329
Skizze einer Beispielimplementierung (5/5)
public class Projekt implements Knoteninformation{
private Eigenschaft[] eigenschaften = new Eigenschaft[8];
private BaumListe<Projekt> teilprojekte =
new BaumListe<Projekt>("Teilprojekte");
private BaumListe<Projekt> vorgaenger =
new BaumListe<Projekt>("Vorgaenger");
private BaumListe<Aufgabe> aufgaben =
new BaumListe<Aufgabe>("Aufgaben");
public int anzahlElemente() {
return this.eigenschaften.length+3;
}
public Knoteninformation itesElement(int i) {
switch(i){
case 0: case 1: case 2: case 3: case 4: case 5: case 6:
case 7: return eigenschaften[i];
case 8: return vorgaenger;
case 9: return teilprojekte;
case 10:return aufgaben;
}
return null;
}
} Grundkurs
// nur
Ausschnitt
Software-Engineering mit UML
Stephan Kleuker
330
Ziele komplexere Framework-Ansätze
neben Spezialaufgaben werden hauptsächlich folgende
Aufgaben gelöst
• sorgenfreies Lesen und Speichern von Objekten in
Datenbanken (Persistenz)
• sorgenfreie konsistente Verteilung von
Informationen (Prozesskommunikation)
• sorgenfreie Steuerung verteilter Abläufe mit
Überwachung von Transaktionen
• Beispiele sind Enterprise Java Beans, Microsoft DotNet-Technologie, Spring, Hibernate, viel im Bereich
AJAX
Grundkurs Software-Engineering mit UML
Stephan Kleuker
331
Persistente Datenhaltung
9.7
Typische Java-Möglichkeiten
• Anschluss an klassische relationale DB über JDBC
(typisch bei Anbindung an existierende DB)
• Nahtlose Integration der Datenhaltung in die
Entwicklung (Ansatz: statt Objekt zu erzeugen
Methode holeObjekt(), später sichere Objekt),
typisch für Hibernate (häufig genutzt, bei kleinen
Spezialanwendungen, z. B. Handy, Organizer)
• relativ nahtlose Integration durch zusätzliche
Software, die objekt-relationales Mapping übernimmt
• Nutzung eines Frameworks, das Persistenz und
Transaktionssteuerung übernimmt, Enterprise Java
Beans
Grundkurs Software-Engineering mit UML
Stephan Kleuker
332
Beispiel: JavaBeans (kleiner Ausschnitt)
• Java unterstützt Reflektion, damit kann ein Objekt nach seiner
Klasse, seinen Exemplarvariablen und Exemplarmethoden
befragt werden
• Hält man sich an folgende einfache Regel für eine Klasse
– sie implementiert Serializable (geht nur, wenn alle
verwendeten Typen Serializable)
– für alle Exemplarvariablen gibt es die Standard get- und setVariablen
– es gibt einen leeren Default-Konstruktor
dann sind einige Framework-Ansätze nutzbar
– Objekte speichern und lesen in XML
– Nutzung als JavaBeans (sinnvoll weitere Standardmethoden)
– Objekte speichern in einer Datenbank mit JDO, als Entity
– Objekte im Binärformat lesen und schreiben (reicht
Serializable)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
333
XMLEncoder und XMLDecoder (Ausschnitt)
private void speichern(String datei){
try {
XMLEncoder out= new XMLEncoder(
new BufferedOutputStream(new
FileOutputStream(datei)));
out.writeObject(table.getModel());
out.close();
} catch (FileNotFoundException e) {} //wegschauen
}
private void laden(String datei){
try {
XMLDecoder in= new XMLDecoder(
new BufferedInputStream(new
FileInputStream(datei)));
table.setModel((DefaultTableModel)in.readObject());
in.close();
} catch (FileNotFoundException e) {} //wegschauen
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
334
Annotationen
9.8
• klassische imperative Programmierung (=prozedural,
objektorientiert): man beschreibt welche Schritte
gemacht werden sollen
• Annotationen: man schreibt was man haben will;
eigentliche Realisierung wird vom Framework
übernommen
• verwandt mit aspektorientierter Programmierung
Grundkurs Software-Engineering mit UML
Stephan Kleuker
335
Beispiel JPA (1/2)
@Entity soll persistiert werden
public class Mitarbeiter implements Serializable {
private static final long serialVersionUID Schlüssel
= 1L;
Exemplarvariable ist Schlüssel
automatisch
@Id
generiert
@GeneratedValue(strategy = GenerationType.AUTO)
private int minr;
private String name;
1:N-Beziehung
@OneToMany(mappedBy="bearbeiter",
cascade={CascadeType.PERSIST,
CascadeType.MERGE})
private Set<Projektauftrag> auftraege =
new
HashSet<Projektauftrag>();
...
public void auftragHinzu(Projektauftrag pa){
auftraege.add(pa);
} Software-Engineering
// getund set- für Stephan
Exemplarvariablen
Grundkurs
mit UML
Kleuker
336
Beispiel JPA (2/2) – nur Überblick
private EntityManagerFactory emf =
Persistence.createEntityManagerFactory("JPAKonfigD
atei");
private EntityManager em =
emf.createEntityManager();
public void mitarbeiterBeispieldaten(){
Mitarbeiter m[]= {new Mitarbeiter("Egon"),
new Mitarbeiter("Aische"), new
Mitarbeiter("Urs")};
em.getTransaction().begin();
for (int i=0; i<m.length; i++)
em.persist(m[i]);
em.getTransaction().commit();
}
public void datenZeigen() {
for (Mitarbeiter m : em.createQuery(
"SELECT m FROM Mitarbeiter
Grundkurs
Software-Engineering mit UML
Stephan Kleuker
m",Mitarbeiter.class)
337
In Erprobung/Entwicklung: : Domain Specific Languages
9.9
• Problem: General Purpose Sprachen sind sehr
mächtig, aber für spezifische Entwicklungsbereiche
geht sehr viel Energie in für den Bereich gleichartige
Programmierung
• Spezielle Entwicklungssprache für individuellen
Bereich, spezielle komplexe Hochsprachelemente
anbietet
• Neue Sprache z. B. mit XML (Syntax mit XMLSchema) darstellbar; Umwandlung in Programm mit
Übersetzung (z. B. XSLT) ; hilfreich ist
Visualisierungsmöglichkeit der DSL
• Hinweis: UML (evtl. mit konkreter Ausprägung) kann
mit MDA-Transformationen auch als spezieller DSLAnsatz angesehen werden
Grundkurs Software-Engineering mit UML
Stephan Kleuker
338
DSL Prozesse
Grundkurs Software-Engineering mit UML
Stephan Kleuker
339
In Erprobung/Entwicklung: Model Driven Architecture
9.10
• Ansatz: Häufig benötigt man die gleichen Ideen (z. B.
Sortierverfahren) in sehr unterschiedlichen Sprachen; warum
nicht in einer Sprache modellieren und dann in andere
Sprachen transformieren?
• Da Sprachen extrem unterschiedlich, soll Modellumwandlung
schrittweise passieren
• Zur Modellbeschreibung wird eigene Sprache mit eigener
Semantik benötigt (Metamodell und Metametamodell)
• Ansatz: Umwandlung des CIM mit Transformationsregeln in ein
PIM und dann ein PSM
CIM: Computer Independent Model
PIM: Platform Independent Model
PSM: Platform Specific Model
• z. B. UML-Modell, dann Realisierungssprache wählen, dann
HW-Plattform mit Kommunikationsprotokollen wählen (zwei
parametrisierte Transformationen)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
340
Prozess der MDA (Theorie)
• Realität: häufig nur
eine konkrete Ebene
• viele manuelle
Einstellungen für die
Transformation
• Generieren gibt es
schon lange (YACC,
Dateien zur
Beschreibung von
Fenstern, von UML
zum Programmskelett)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
341
Formaler Hintergrund der MDA
Semantik definiert durch
Abarbeitungsreihenfolge
konkretes
Modell1
konkrete Menge von
Regeln mit konkreten
Parametern
Instanz von
Instanz von
Transformationsregeln
Modellart1
konkretes
Modell2
Instanz von
Modellart2
Transformationsmodel
Meta Object Faciliy (MOF)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
342
Refactoring
9.11
• Komplexe Methoden sollen grundsätzlich vermieden werden
• Lösungsansatz: Refactoring, d. h. ein Programmblock wird in
einer Methode mit selbsterklärendem Namen ausgegliedert
• Wann ist Ausgliederung möglich?
– Im Block darf nur eine lokale Variable auf der linken Seite
einer Zuweisung stehen
• Wie funktioniert Refactoring?
– Bestimme alle lokalen Variablen, die im Block lesend
genutzt werden; diese werden zu Parametern
– Falls eine lokale Variable links in einer Zuweisung
vorkommt, bestimmt sie den Rückgabetypen (sonst void)
• Exemplarvariablen spielen keine Rolle, da auf sie in allen
Methoden der Klasse zugegriffen werden darf
• Probleme bei mehr als einer zu verändernden lokalen Variablen
oder bei enthaltenen Rücksprüngen (aufwändig regelbar)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
343
Refactoring – Positives Beispiel
public int ref(int x, int y, int z){
int a=0;
public int ref(int x, int y, int z){
if(x>0){
int a=0;
a=x;
if(x>0){
x++;
a = mach(x, y, z);
--y;
}
a=a+y+z;
return a;
}
}
return a;
private int mach(int x, int y, int z){
}
int a;
a=x;
x++;
--y;
a=a+y+z;
return a;
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
344
Refactoring – nicht einfaches Beispiel
public int ref2(int x){
int a=0;
int b=0;
int c=0;
if(x>0){
a=x;
b=x;
c=x;
}
return a+b+c;
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
345
Refactoring – (nicht) einfaches Beispiel in C++
int Rechnung::ref2(int x){
int a=0;
int b=0;
int c=0;
if(x>0){
abcAnpassen(a,b,c,x);
}
return a+b+c;
}
void Rechnung::abcAnpassen(int& a, int& b, int& c,
int x){
a=x;
b=x;
c=x;
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
346
10. Oberflächengestaltung
10.1 Hintergründe der Oberflächengestaltung
10.2 Konkretisierung des Nutzbarkeitsbegriffs
10.3 Berücksichtigung der Ergonomie im
Software-Entwicklungsprozess
10.4 Prüfung der Nutzbarkeit
http://usability.is.uni-sb.de/index.php (Arbeitsbereich Usability
Engineering )
http://usability.gov/guidelines/index.html (U.S. Department of Health
and Human Services)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
347
Begriff: Ergonomie
10.1
• Der Begriff "Ergonomie" setzt sich aus den griechischen
Wörtern
ergon = Arbeit, Werk und
nomos = Gesetz, Regel zusammen.
Nach Auffassung der International Ergonomics Association
wird unter Ergonomie die Lehre von der menschlichen Arbeit
und die Erkenntnis ihrer Gesetzmäßigkeiten verstanden.
• Laut der offiziellen Definition der internationalen ISO-Norm
verwendet Ergonomie wissenschaftliche Erkenntnisse, um
Arbeitsaufgaben, Arbeitsumgebungen und Produkte an die
physischen und mentalen Fähigkeiten und Grenzen von
Menschen anzupassen. Hierbei soll Gesundheit, Sicherheit,
Wohlbefinden und Leistungsvermögen verbessert werden.
Grundkurs Software-Engineering mit UML
Stephan Kleuker
348
Ergonomie als Schnittstelle der Forschung
• Psychologie: In der Gestaltungspsychologie wird u. a.
untersucht, welche Wirkungen Farben und Formen haben.
Dabei ist zu beachten, dass Fragen im Kontext betrachtet
werden müssen.
• Arbeitswissenschaft: Ein Teil der Arbeitswissenschaften
beschäftigt sich mit der ergonomischen Gestaltung von
Arbeitsplätzen. Dabei ist eine zentrale Forderung, dass die
Arbeitsumgebung und die Arbeitsmittel zur Aufgabe passen.
Software ist dabei in vielen Berufen ein zentrales Arbeitsmittel
von vielen Personen, die sich nicht mit der SoftwareEntwicklung beschäftigen. Für diese Personen muss der
Zugang zur IT aus ihrer Sicht intuitiv sein.
• Software-Ergonomie: In der Software-Ergonomie als InformatikDisziplin beschäftigt man sich mit der Umsetzung der Ideen der
vorher genannten Arbeitsgebiete in der Software. Dabei muss
als besondere Randbedingung die Realisierbarkeit von
gestalterischen Ideen berücksichtigt werden.
Grundkurs Software-Engineering mit UML
Stephan Kleuker
349
Psychologie: Beispiel Farbwahl
Farbe
Assoziation
weiß
Reinheit, Unschuld (Asien: Trauer)
schwarz
Tod, Trauer, Eleganz, Schwere, Ernst
grau
Neutral, spannungslos
blau
Geist, Kosmos, Ewigkeit, wirkt kühl, steigert in
Kombination die Wirkung warmer Farbtöne
rot
Dynamik, Aktivität, Wärme, Warnfarbe
gelb
Anregend, heiter, dynamisch, kalte Farben wirken durch
Zusatz von gelb kälter, warme Farben wärmer
orange
Hohes Maß an Aktivität und Dynamik, erregt
Aufmerksamkeit, Warnfarbe
violett
Ernst, feierlich, je nach Blauanteil kühl oder warm
grün
Natur, Wachstum, beruhigend (langweilig)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
350
Zusammenhang der Normen ISO 9241
10.2
IS O 9 2 4 1
Teil 17
Form ulardialoge
Teil 16
D irekte M anipulation
Teil 14
M en üdialoge
Teil 15
K om m andodialoge
T e il 1 1 0 D ia lo g p r in z ip ie n
T e il 1 3 B e n u tz e r fü h r u n g
T e il 1 2 In fo r m a tio n s d a r s te llu n g
T e il 1 1 A n fo r d e r u n g e n a n d ie G e b r a u c h s ta u g lic h k e it
Grundkurs Software-Engineering mit UML
Stephan Kleuker
351
Leitlinien aus ISO 9241-110
Software-ergonomische Grundsätze der
Dialoggestaltung
•
•
•
•
•
•
•
Lernförderlichkeit
Fehlertoleranz
Erwartungskonformität
Aufgabenangemessenheit
Selbstbeschreibungsfähigkeit
Steuerbarkeit
Individualisierbarkeit
Grundkurs Software-Engineering mit UML
Stephan Kleuker
352
Lernförderlichkeit
• Ein Dialog ist lernförderlich, wenn er den Benutzer
beim Erlernen des Dialogsystems unterstützt und
anleitet.
• Praktische Anforderungen:
– Kann der Benutzer sich ohne Hindernisse in die
Nutzung des Systems einarbeiten?
– Kann der Benutzer das System ausprobieren,
ohne dafür „bestraft“ zu werden?
– Begriffe sinnfällig wählen
– Gleicher Aufbau von Grundstrukturen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
353
Fehlertoleranz
• Ein System ist fehlertolerant, wenn das
beabsichtigte Arbeitsergebnis trotz erkennbar
fehlerhafter Eingaben entweder mit keinem oder mit
minimalem Korrekturaufwand durch den Benutzer
erreicht werden kann.
• Praktische Anforderungen:
– Ist die Software gegen Fehleingaben robust?
– Kann der Benutzer Fehlersituationen leicht
korrigieren? Werden Vorschläge generiert?
– Warnung vor folgenschweren Fehlern
– Keine Werturteile („Unsinnige Eingabe!“)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
354
Erwartungskonformität
• Ein Dialog ist erwartungskonform, wenn er konsistent ist und
den Merkmalen des Benutzers entspricht, z.B. den Kenntnissen
aus dem Arbeitsgebiet, der Ausbildung und der Erfahrung
sowie allgemein anerkannten Konventionen.
• Praktische Anforderungen:
– Reagiert das System so, wie der Benutzer es erwartet?
– Entsprechen in Menüfolgen die suggerierten Abläufe dem
typischen Arbeitsablauf?
– Kann der Benutzer das Systemverhalten voraussagen?
– Konsistenz – anwendungsintern und
anwendungsübergreifend:
Platzierung, wiederkehrende Ablaufschemata, einheitliche
Funktionstastenbelegung, Sprache, Screen und Print
Grundkurs Software-Engineering mit UML
Stephan Kleuker
355
Aufgabenangemessenheit
• Ein System ist aufgabenangemessen, wenn es den
Benutzer unterstützt, seine Aufgabe effektiv und
effizient zu erledigen.
• Praktische Anforderungen:
– Muss der Benutzer unnötige Dialogschritte
durchführen?
– Sind überflüssige / ablenkende Informationen
vorhanden, die mit der Aufgabe nichts zu tun
haben?
– Erhält der Benutzer alle gewünschten
Ergebnisse?
– Vorgaben von Standardwerten, wenn sinnvoll
Grundkurs Software-Engineering mit UML
Stephan Kleuker
356
Selbstbeschreibungsfähigkeit
• Ein Dialog ist selbstbeschreibungsfähig, wenn jeder
einzelne Dialogschritt durch Rückmeldung des
Systems unmittelbar verständlich ist oder auf
Anfrage erklärt wird.
• Praktische Anforderungen:
– Sind alle für einen Arbeitsschritt benötigten
Informationen übersichtlich am Bildschirm
vorhanden?
– Weiß der Benutzer, was er als nächstes tun kann?
– Präzise, unmissverständliche und einfache
Systemmeldungen
– weiß der Nutzer, was das System macht?
Grundkurs Software-Engineering mit UML
Stephan Kleuker
357
Steuerbarkeit
• Ein Dialog ist steuerbar, wenn der Benutzer in der Lage ist, den
Dialogablauf zu starten sowie seine Richtung und
Geschwindigkeit zu beeinflussen, bis das Ziel erreicht ist.
• Praktische Anforderungen:
– Kann der Benutzer seine Arbeitsschritte so steuern, wie es
von seiner Aufgabe her notwendig ist?
– Reihenfolge der Arbeitsschritte wählbar bei variablen oder
dynamischen Aufgaben
– Kann der Benutzer Arbeitsschritte unterbrechen oder
abbrechen, wenn dies erforderlich ist?
– Kann der Nutzer mit Maus und Tastatur manövrieren?
Grundkurs Software-Engineering mit UML
Stephan Kleuker
358
Individualisierbarkeit
• Ein Dialog ist individualisierbar, wenn das System
Anpassungen an die Erfordernisse der Aufgabe,
individuelle Vorlieben und Fähigkeiten des
Benutzers zulässt.
• Praktische Anforderungen:
– Kann der Benutzer Layout und Funktion des
Systems an seine individuellen Anforderungen
anpassen?
– Können eigene Funktionen (z. B. Macros) definiert
werden?
Grundkurs Software-Engineering mit UML
Stephan Kleuker
359
Anforderungsanalyse aus Usability-Sicht
10.3
• SOLL-Prozesse müssen mit dem Kunden und den
Endanwendern geklärt werden
• Vokabular der Kundenprozesse muss definiert sein
• potenzielle alternative Prozessabläufe müssen bekannt sein
• Technische Randbedingungen müssen definiert sein
Usability (insbesondere Web-Seiten):
• Welche gewünschten Nutzer haben welche Erfahrungen
(Computererfahrung /Alter)?
• Welche Technologie wird zur Implementierung eingesetzt
(Browser, Javascript, ASP, ActiveX, Applets)? [je mehr
heterogene Nutzer desto weniger Technik erlaubt]
• Wie werden erwünschte Nutzer verbunden? [Privat-Nutzer
häufiger noch über analoge Modems]
Grundkurs Software-Engineering mit UML
Stephan Kleuker
360
Design aus Usability-Sicht
• Typischerweise wird SW in Paketen und Schichten
entwickelt, meist wird die graphische Oberfläche als
eine Schicht in getrennten Paketen entwickelt
• Ansatz garantiert, dass Darstellung und Inhalt
konsequent getrennt werden, einheitliche
Darstellung wird erleichtert
• Ansatz hat Problem, dass die Schnittstelle sehr breit
wird, muss frühzeitig abgesprochen werden
• Entwicklung unterschiedlicher Oberflächenmasken
orientiert sich an gewünschten Prozessabläufen
(ähnlich zu einem Storyboard im Trickfilm)
• Gute Oberflächengestaltung ist Designern zu
überlassen (die Prozesse verstehen müssen)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
361
Integration der Oberflächenentwicklung
Grundkurs Software-Engineering mit UML
Stephan Kleuker
362
Überblick über Usability-Testmethoden
10.4
• Expertenzentrierte Methoden
– heuristische Evaluation
– Guidelines und Checklisten
• Nutzerzentrierte Methoden
– Befragung
– Task-based Testing / Discount Usability Testing
– Thinking-Aloud-Tests
• Kombinationen der genannten Verfahren
Grundkurs Software-Engineering mit UML
Stephan Kleuker
363
Heuristische Evaluation
= eine Gruppe von externen Gutachtern untersucht
eine Website und überprüft, inwieweit diese mit
grundlegenden Prinzipien der Usability (sog.
Heuristiken) übereinstimmt.
• Die individuellen Einschätzungen werden zuerst
schriftlich fixiert und danach von der
Gutachtergruppe bewertet bzw. eingestuft.
• Vorteile:
– konkrete Benennung der einzelnen Defizite
– Empfehlungen zur Behebung derselben
• Nachteile:
– zeitintensiver Einsatz von teuren Experten
– passende Experten müssen gefunden werden
Grundkurs Software-Engineering mit UML
Stephan Kleuker
364
Guidelines und Checklisten
= eine Gruppe von (externen oder internen) Gutachtern
untersucht eine SW anhand von Guidelines und
Checklisten, in denen Usability-Kriterien
zusammengestellt sind.
• Antwortvorgaben resultieren in Zahlenwerten /
Noten.
• Besonders geeignet für ähnliche Websites.
• Vorteile:
– schnell und computergestützt realisierbar
– Ergebnisse erlauben unterschiedlichste
Auswertungen (Abhängigkeiten)
• Nachteile:
– stark formalisierte Ergebnisse (Gewichtungen?)
– Anpassungsbedarf für Einsatzbereich der Seite
Grundkurs Software-Engineering mit UML
Stephan Kleuker
365
Nutzerbefragung
• = mündlich, schriftlich (in Seite integriert, e-mail, online-Chat,
...); anhand von standardisierten Fragebögen oder als
qualitative Interviews;
• Zielgruppen sind (potenzielle) Benutzer
• mögliche Erkenntnisziele:
– Erwartungen einer Zielgruppe
– Nutzungsformen und Gründe dafür
– Vorkenntnisse und Nutzungsverhalten
– subjektive Erfahrungen von Versuchspersonen
• Vorteile:
– viele Einschätzungen einholbar
– unmittelbarer Kontakt mit Endnutzern
• Nachteile:
– Subjektivität der Ergebnisse (wer antwortet warum)
– mögliche Heterogenität der Ergebnisse
Grundkurs Software-Engineering mit UML
Stephan Kleuker
366
Task-based Testing / Discount Usability Testing
= typische Anfragen bzw. Aufgaben werden von für die
Zielgruppe typischen Nutzern bearbeitet
• Die Probanden werden dabei beobachtet, ihre
Reaktionen notiert und später evaluiert
• Vorteile:
– geringe Anzahl von Testpersonen erbringt schon
aussagekräftige Ergebnisse
– man sieht, wie Ergebnis von anderen genutzt wird
• Nachteile:
– Vorkenntnisse und Voreinstellungen der Tester
können die Analyse verzerren
– teilweise schwierige Findung typischer Anfragen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
367
Thinking-Aloud-Tests (1/2)
= Personen aus der gewünschten Nutzergruppe
bearbeiten ein zumeist vorgegebenes
Aufgabenszenario. Während der Bearbeitung sollen
sie ihre diesbezüglichen Gedanken und ihr Handeln
laut aussprechen bzw. kommentieren.
• Während des Tests werden in einem sog. UsabilityLabor Ton und Bild von der Versuchsperson sowie
Kopien des Bildschirminhalts aufgezeichnet.
• Ergänzend werden mit einem Screenrecorder die
Bewegungen auf dem Bildschirm aufgezeichnet.
• Anschließend werden die Daten zur Bewertung in
eine analysierbare Form gebracht.
Grundkurs Software-Engineering mit UML
Stephan Kleuker
368
Thinking-Aloud-Tests (2/2)
• Vorteile:
– genaue Daten aus unterschiedlicher Perspektive
– wenige Probanden ergeben gute Einsichten
• Nachteile:
– aufwändige und teure Grundausstattung incl.
geschultem Personal nötig
– Fähigkeit der Testpersonen zur Verbalisierung
ihres Handelns und Denkens ist unterschiedlich
– ggf. ist Spontanität “ausgebremst”
(Laborsituation)
– Vorkenntnisse und Voreinstellungen der Tester
können die Analyse verzerren
Grundkurs Software-Engineering mit UML
Stephan Kleuker
369
Notwendige Anzahl von Testnutzern
Grundkurs Software-Engineering mit UML
Stephan Kleuker
370
11. Qualitätssicherung
11.1 Formale Korrektheit
11.2 Zusicherungen
11.3 Unit-Tests
11.4 Testbarkeit von Systemen herstellen
11.5 Äquivalenzklassentests
11.6 Kontrollflussbezogene Testverfahren
11.7 Testarten und Testumfeld
11.8 Metriken
11.9 Konstruktive Qualitätssicherung
11.10 Manuelle Prüfverfahren
Grundkurs Software-Engineering mit UML
Stephan Kleuker
371
Korrektheit
11.1
• Korrekt bedeutet: Unter folgenden Vorbedingungen sollen die
Ergebnisse des Programms folgende Nachbedingungen
erfüllen
• Wunsch alles zu testen meist nicht erfüllbar
public static boolean impliziert(boolean a,
boolean b){
return !a || b;
}
public static void main(String[] args) { // Tests
boolean werte[]={true,false};
for(boolean a:werte)
for(boolean b:werte)
System.out.println("a="+a+" b="+b
+" liefert "+impliziert(a,b));
}
• Tests sollen möglichst viele möglichst kritische Fehler finden
können
Grundkurs Software-Engineering mit UML
Stephan Kleuker
372
Ansatz: Model Checking
• Idee: Gegeben ist ein Modell (oder Spezifikation) und
eine Anforderung, dann überprüft der ModelChecking-Algorithmus, ob das Modell die
Anforderung erfüllt oder nicht. Falls das Modell die
Anforderung nicht erfüllt, sollte der Algorithmus ein
Gegenbeispiel liefern
• Theoretisches Ergebnis: Generell gibt es so ein
Verfahren nicht (unentscheidbar), man muss
Modellierungssprache und Anforderungslogik
einschränken
• Ansatz: Berechne alle erreichbaren Zustände und
analysiere sie
• Beispiel: SPIN entwickelt von Gerard Holzmann,
zunächst als Simulator, dann Verifikationswerkzeug
(www.spinroot.com)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
373
Assertions in JDK ab Version 1.4
11.2
•
Sprachänderung
– neues Keyword assert
•
Erweiterung des java.lang-Pakets
java.lang.AssertionError
•
Neue Dokumentation
– unter Guide to Features
– unter Assertion Facility
– unter javadoc
doc/guide/lang/assert.html
• Compiler-Option –source 1.4
javac –source 1.4 Klasse.java
damit javac assert akzeptiert
• Interpreter-Option –ea
java –ea Klasse
Grundkurs Software-Engineering mit UML
Stephan Kleuker
374
Syntax und Semantik von assert
assert überprüft zur Laufzeit eine Zusicherung, ist diese nicht
erfüllt, wird ein AssertionError ausgelöst
public void (int a, int b){
assert a>b && exemplar>5;
...
}
Syntax:
assert <Boolescher_Ausdruck>
assert <Boolescher_Ausdruck>:<bel_Objekt>
<bel_Objekt> ist meist ein String, der bei der Fehlermeldung
mit angezeigt wird
Grundkurs Software-Engineering mit UML
Stephan Kleuker
375
Kostenregel
• Zusicherungen sollen nichts kosten, wenn sie ausgeschaltet
sind [nicht immer zu 100% möglich].
• Falsch:
private static double EPS=0.000001;
public static double sqrt(double par) {
double res = Math.sqrt( par );
boolean test = Math.abs(par -res *res) < EPS;
assert test;
return res;
}
• Richtig:
assert Math.abs( par - res * res ) < EPS;
Grundkurs Software-Engineering mit UML
Stephan Kleuker
376
Vorbedingungsregel
• nur interne Vorbedingungen mit assert prüfen, die bei
korrekter Software erfüllt sein müssten
• kein Ersatz für Ausnahmen
Beispiel:
public double sqrt(double param) {
if ( param < 0 ) throw
new IllegalArgumentException("Negativer
Parameter");
return Math.sqrt( param );
}
• Nicht als zweite Zeile:
assert param >= 0;
• deswegen AssertionError und nicht AssertionException
• Assertions dürfen nur in der Entwicklung zu Fehlern führen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
377
Nachbedingungsregel
• Nachbedingungen lassen sich immer mit assert
beschreiben
• Typisch stehen Nachbedingungen unmittelbar vor
jedem return-Statement oder der abschließenden
geschweiften Klammer
• Beispiel
private static double EPS=0.000001;
public static double sqrt(double par) {
double res = Math.sqrt( par );
assert Math.abs( par - res * res ) < EPS;
return res;
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
378
Invariantenregel
• Invarianten von Objekten werden nach außen nie verletzt (bei
internen Berechnungen erlaubt)
• Ansatz: Invariante wird als eigenständige Methode
implementiert
private boolean invariant(...){
boolean erg = <Invariantenberechnung>;
return erg;
}
• Überprüfung der Invariante assert invariant(...); am
– Ende eines jeden Konstruktors
– am Anfang jeder public-Methode
– am Ende jeder public-Methode
Grundkurs Software-Engineering mit UML
Stephan Kleuker
379
Fehlermöglichkeiten mit assert
while (iter.hasNext()) {
assert iter.next() != null;
do_something( iter.next() );
}
public class Stack {
int size = 0;
...
public int length() {
assert this.length() >= 0;
return size;
} // length
} // Stack
Grundkurs Software-Engineering mit UML
Stephan Kleuker
380
JUnit
11.3
• Framework, um den Unit-Test eines JavaProgramms zu automatisieren
• einfacher Aufbau
• leicht erlernbar
• geht auf SUnit
(Smalltalk) zurück
• mittlerweile für
viele Sprachen
verfügbar
Grundkurs Software-Engineering mit UML
Stephan Kleuker
381
Konstruktiver Ansatz
• Testfälle werden in Java programmiert, keine
spezielle Skriptsprache notwendig
• Idee ist inkrementeller Aufbau der Testfälle parallel
zur Entwicklung
– Pro Klasse wird mindestens eine Test-Klasse
implementiert
• JUnit ist in Entwicklungsumgebungen integriert,
sonst muss das Paket junit.jar zu CLASSPATH
hinzugefügt werden
Grundkurs Software-Engineering mit UML
Stephan Kleuker
382
Testen mit JUnit
• Tests werden mit Methoden durchgeführt, die mit
Annotation @Test markiert sind
• Testmethoden haben typischerweise keinen
Rückgabewert (nicht verboten)
• Tests stehen typischerweise in eigener Klasse; für
Klasse X eine Testklasse XTest (können auch in zu
testender Klasse stehen)
• Mit Klassenmethoden der Klasse Assert werden
gewünschte Eigenschaften geprüft
Assert.assertTrue("korrekter Vorname"
,m.getVorname().equals("Ute"));
• JUnit steuert Testausführung, Verstöße bei
Prüfungen werden protokolliert
Grundkurs Software-Engineering mit UML
Stephan Kleuker
383
Assert (1/2)
• Die Klasse Assert definiert eine Menge von assertXY
Methoden, welche die Testklassen erben.
• Mit den assertXY Methoden können unterschiedliche
Behauptungen über den zu testenden Code aufgestellt werden.
• Trifft eine Behauptung nicht zu, wird ein Testfehler
protokolliert.
• assertTrue (boolean condition)
verifiziert, ob einen Bedingung wahr ist.
• assertEquals(Object expected, Object actual)
verifiziert, ob zwei Objekte gleich sind. Der Vergleich erfolgt mit
der equals Methode.
• assertEquals(int expected, int actual)
verifiziert, ob zwei ganze Zahlen gleich sind. Der Vergleich
erfolgt mit dem == -Operator.
• assertNull(Object object)
verifiziert, ob einen Objektreferenz null ist.
Grundkurs Software-Engineering mit UML
Stephan Kleuker
384
Assert (2/2)
• assertEquals(double expected, double actual,
double delta)
verifiziert, ob zwei Fließkommazahlen gleich sind. Da
Fließkommazahlen nicht mit unendlicher Genauigkeit
verglichen werden können, kann mit delta ein Toleranzwert
angegeben werden.
• assertNotNull(Object object)
verifiziert, ob eine Objektreferenz nicht null ist.
• assertSame(Object expected, Object actual)
verifiziert, ob zwei Referenzen auf das gleiche Objekt verweisen.
• Für die primitiven Datentypen float, long, boolean,
byte, char und short existieren ebenfalls assertEquals
Methoden.
• Jede Assert-Methode gibt es mit einem zusätzlichen ersten
Parameter vom Typ String, dieser String wird zum Fehler
ausgegeben (also sinnvoll diese Methoden zu nutzen)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
385
Anmerkungen
• keine gute Idee: mehrere Asserts hintereinander
(scheitert das Erste, wird Zweite nicht betrachtet ->
Tests trennen)
• Assert-Methoden haben optionalen ersten StringParameter
• String kann genauere Informationen über erwartete
Werte enthalten, z. B. über toString-Methoden der
beteiligten Objekte
• generell reicht Assert.assertTrue() aus, gibt viele
weitere Methoden
• Um nicht immer die Klasse Assert vor Methoden
angeben zu müssen, kann man auch (persönlich
unschön) folgendes nutzen:
import static org.junit.Assert.*;
Grundkurs Software-Engineering mit UML
Stephan Kleuker
386
Test-Fixture
• Testfall sieht in der Regel so aus, dass eine
bestimmte Konfiguration von Objekten aufgebaut
wird, gegen die der Test läuft
• Menge von Testobjekten heißt Test-Fixture
• Damit fehlerhafte Testfälle nicht andere Testfälle
beeinflussen können, wird die Test-Fixture für jeden
Testfall neu initialisiert
• In der mit @Before annotierten Methode werden
Exemplarvariablen initialisiert
• In der mit @After annotierten Methode werden
wertvolle Testressourcen wie zum Beispiel
Datenbank- oder Netzwerkverbindungen wieder
freigegeben
Grundkurs Software-Engineering mit UML
Software-Qualität
387
Testen von Exceptions
• Exceptions in Java mit catch Block behandelt
• Mit der Methode fail aus der Assert Klasse wird
ein Testfehler ausgelöst und protokolliert
• Im Beispiel wird beim Aufruf des Konstruktors der
Klasse MyClass mit einer negativen Zahl die
IllegalArgumentException ausgelöst
@Test
public void testNegativeInitialisierung() {
try {
new MyClass(-10);
fail("Meine Meldung im Fehlerfall");
}catch (IllegalArgumentException e) {}
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
388
Zu testende Klasse (1/2)
package kapitel11_Rabatt;
public class Rabatt {
private double rabatt;
private boolean gesperrt;
public Rabatt(double rabatt, boolean gesperrt) {
this.rabatt = rabatt;
this.gesperrt = gesperrt;
}
public boolean isGesperrt() {
return this.gesperrt;
}
public void setGesperrt(boolean gesperrt) {
this.gesperrt = gesperrt;
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
389
Zu testende Klasse (2/2)
public double getRabatt() {
return rabatt;
}
public void setRabatt(double rabatt) {
this.rabatt = rabatt;
}
double preis(double ursprungspreis)
throws RabattException{
if(this.gesperrt)
throw new RabattException();
return ursprungspreis*(1-(rabatt/100));
}
}
package kapitel11_Rabatt;
public class RabattException extends Exception {}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
390
Testfälle (1/3)
package kapitel11_Rabatt;
public class RabattTest {
// imports fehlen
private Rabatt gut;
private Rabatt boese;
@Before
protected void setUp() throws Exception {
super.setUp();
gut = new Rabatt(3.0,false);
boese = new Rabatt(0.0,true);
}
@Test
public void testGetRabatt(){
assertTrue(3.0 == gut.getRabatt());
assertTrue(0.0 == boese.getRabatt());
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
391
Testfälle (2/3)
@Test
public void testSetRabatt(){
gut.setRabatt(17.0);
assertTrue(17.0 == gut.getRabatt());
}
@Test
public void testIsGesperrt(){
assertTrue(!gut.isGesperrt());
assertTrue(boese.isGesperrt());
}
@Test
public void testSetGesperrt(){
gut.setGesperrt(true);
boese.setGesperrt(false);
assertTrue(gut.isGesperrt());
assertTrue(!boese.isGesperrt());
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
392
Testfälle (3/3)
@Test
public void testPreisErfolgreich(){
try {
double ergebnis=gut.preis(100.0);
assertEquals(ergebnis,97.0,0.001);
} catch (RabattException e) {
fail("falsche RabattException");
}
}
@Test
public void testPreisMitException(){
try {
boese.preis(100.0);
fail("fehlende RabattException");
} catch (RabattException e) {
}
}
public static void main(String[] args) {
junit.swingui.TestRunner.run(RabattTest.class);
}
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
393
TestSuite
Für große Projekte sind folgende Wünsche bzgl. der
Tests typisch:
a) mehrere Testklassen sollen zusammen laufen
können
b) man möchte Tests flexibel kombinieren können;
Testwiederholung soll davon abhängen, welche
Klassen betroffen sein können [schwierige
Weissagung]
c) man möchte Tests automatisiert ablaufen lassen
können möglich z. B.:
– JUnit hat Klassen zum einfachen Start von der
Konsole aus
– Nutzung eines cron-Jobs
zu a) und b) TestSuite in JUnit
Grundkurs Software-Engineering mit UML
Stephan Kleuker
394
Vergleich von JUnit und Assertions
• Assertions werden vom Entwickler eingesetzt um
Vor- und Nachbedingungen, sowie Invarianten zu
beschreiben
• Assertions können auch innerhalb von Methoden für
lokale Zustandsüberprüfungen eingesetzt werden
• Assertions werden tief in der Programmstruktur
eingesetzt, JUnit schaut auf die Schnittstellen der
Klassen von außen
• JUnit ist sehr mächtig, da nicht nur einzelne
Klassen, sondern auch die Zusammenarbeit von
Klassen geprüft werden kann (der Name „Unit“ ist
eher irreführend)
• Es spricht nichts dagegen, Assertions und JUnit
zusammen einzusetzen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
395
Klassen testbar machen
11.4
• Bei Objekten mit internen Zuständen ist der Test von außen mit
JUnit sehr schwierig
• es ist oftmals hilfreich, zusätzliche Methoden zu
implementieren, die das Testen einfacher machen
public String getInternenZustand(){ return "..." }
• Häufiger reicht ein get für den internen Zustand nicht aus, es
muss Methoden geben, mit denen man ein Objekt von außen in
einen gewünschten Zustand versetzen kann (Ergänzung
weiterer Testmethoden)
• Im Quellcode sollen Testmethoden eindeutig von anderen
Methoden getrennt sein, damit sie ggfls. automatisch gelöscht
werden können
• Bei komplexeren Klassen sollte man Teile der Entwicklung
bereits testen, hierzu müssen die aufgerufenen Methoden
zumindest in minimaler Form implementiert werden
Grundkurs Software-Engineering mit UML
Stephan Kleuker
396
Zusammenspiel von Klassen testen
• Bis jetzt wurde nur eine Klasse betrachtet, die keine
Assoziation zu anderen zu testenden Klassen hat, diese
Klassen werden elementare Klassen genannt
• Grundsätzlich sollte man versuchen, zunächst elementare
Klassen und dann Klassen, die auf diesen aufbauen, zu Testen
• Da es in der Entwicklung nicht garantiert werden kann, wann
Klassen vorliegen, muss man sich häufiger mit einem Trick
behelfen
• Dieser Trick ist es, die benötigte Klasse soweit selbst zu
implementieren, dass man die eigene Klasse testen kann. Diese
Klasse wird Mock genannt.
• Die Grundregel lautet, den Mock so primitiv wie möglich zu
halten
• Liegt die Klasse vor, die man temporär durch den Mock prüfen
wollte, müssen diese Tests mit der realen Klasse wiederholt
werden
Grundkurs Software-Engineering mit UML
Stephan Kleuker
397
Mocks programmieren
• Es wird zunächst eine Klasse mit den notwendigen Methoden
implementiert, die alle die leere Implementierung oder die
Rückgabe eines Dummy-Werts enthalten
public void setParameter(int parameter){}
public int getParameter() { return 0;}
• Diese Implementierung wird soweit ergänzt, dass wir unsere
Klasse testen können (möglichst einfache
Fallunterscheidungen, man bedenke, dass man von der
Korrektheit der anderen Klasse ausgeht)
• Es gibt Werkzeuge, die die einfachst möglichen Mocks
automatisch generieren, die können dann ergänzt werden
• D. h., neben den Tests entsteht ein zusätzlicher Codieraufwand
für Mocks, in größeren (erfolgreichen) Projekten kann der
Anteil des Testcodes am Gesamtcode in Abhängigkeit von der
Komplexität des Systems zwischen 30% und 70% liegen!
Grundkurs Software-Engineering mit UML
Stephan Kleuker
398
Beispiel für Mock-Erstellung (1/4)
public class Buchung {
public static LogDatei logging;
...
public synchronized void abbuchen(int id, Konto konto,
int betrag) throws BuchungsException{
if(konto.istLiquide(betrag)){
konto.abbuchen(betrag);
logging.schreiben(id+ " bearbeitet");
}
else{
logging.schreiben(id +" abgebrochen, insolvent");
throw new BuchungsException("insolvent");
}
}
...
}
• Zum Test der Methode abbuchen werden Test-Mocks der
Klassen Konto und LogDatei benötigt, Ziel ist es möglichst
einfache Mocks zu schreiben
Grundkurs Software-Engineering mit UML
Stephan Kleuker
399
Beispiel für Mock-Erstellung (2/4)
• Mock für LogDatei (wahrscheinlich) einfach
public class LogDatei { // Mock für Buchung
public void schreiben(String s){}
}
• Für Konto verschiedene Varianten denkbar, wichtig für unsere
Tests, dass istLiquide() true und false zurück geben kann
public class Konto { //Mock für Buchung
public boolean istLiquide(int betrag){
if( betrag < 1000) return true;
return false;
}
public void abbuchen(int betrag){}
}
• In dieser Variante muss sich der Tester den Schwellenwert zur
Prüfung merken (Mocks müssen auch getestet werden)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
400
Beispiel für Mock-Erstellung (3/4)
public class BuchungTest {//nutzen
private Konto konto;
private Buchung buchung;
@Before
protected void setUp() throws Exception {
Buchung.logging= new LogDatei();
buchung= new Buchung();
konto= new Konto();
}
@After
protected void tearDown() throws Exception {
// logging schließen}
@Test
public void testErfolreicheBuchung(){
try {
buchung.abbuchen(42,konto,100);
} catch (BuchungsException e) {
fail();
}
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
401
Beispiel für Mock-Erstellung (4/4)
@Test
public void testErfolgloseBuchung(){
try {
buchung.abbuchen(42,konto,2000);
fail();
} catch (BuchungsException e) {
} }...
• Die Tests des Mocks gehören in eine eigene Testklasse, da sie
später bei einer Testwiederholung für eine vollständige
Implementierung nicht wiederholt werden
• Werden kompliziertere Mock-Eigenschaften verlangt, sollte die
Klasse generell spezielle Konstruktoren oder Methoden zum
Setzen des internen Zustands beinhalten
• In Coding-Guidelines ist auf das Ziel der Testbarkeit
hinzuweisen, Programmierer müssen die internen Zustände
ihrer Klassen zu Testzwecken sichtbar machen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
402
Vererbung - Test von Unterklassen
• Tests einer Unterklasse C’ (einer Oberklasse C) sind
durchzuführen
• für alle neuen Methoden:
neue Testfälle aufstellen und ausführen
• für alle redefinierten Methoden:
neue Testfälle aufstellen und ausführen; semantisch ähnliche
Programm(teil)e müssen unterschiedlichen Tests unterzogen
werden
• für alle geerbten Methoden:
müssen alle Testfälle der Klasse C erneut durchgeführt werden;
Kontext der Unterklasse ist anders, erneuter Test daher
notwendig
nach : E. Perry, G. E. Kaiser, Adequate Testing and ObjectOriented Programming. Journal of Object-Oriented
Programming, Vol. 2, No. 5, Seiten 13-19
Grundkurs Software-Engineering mit UML
Stephan Kleuker
403
Klassen von Testfällen
11.5
In der Literatur gibt es recht unterschiedlich detaillierte
Klassifizierungen von Testfällen, eine erste grobe
Einteilungsmöglichkeit ist :
• Datenbezogene Testfälle: Ausgehend von der
Spezifikation des zu untersuchenden Objekts
werden verschiedene Eingaben überlegt, deren
gewünschtes Resultat aus der Spezifikation
abzuleiten ist
• Ablaufbezogene Testfälle: Es wird die Struktur des
zu untersuchenden Programms analysiert und
versucht, möglichst alle Ablaufalternativen (if, while)
durchzuspielen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
404
Äquivalenzklassenbildung
• Äquivalenzklassenbildung zerlegt Menge in
disjunkte Teilmengen
• jeder Repräsentant einer Teilmenge hat das gleiche
Verhalten bzgl. einer vorgegebenen Operation
• Beispiel: Restklassen (modulo x), werden zwei
beliebige Repräsentanten aus Restklassen addiert,
liegt das Ergebnis immer in der selben Restklasse
• Übertragungsidee auf Tests: Eingaben werden in
Klassen unterteilt, die durch die Ausführung des zu
testenden Systems zu „gleichartigen“ Ergebnissen
führen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
405
Beispiele für Äquivalenzklassen von Eingaben
• erlaubte Eingabe: 1 <= Wert <= 99 (Wert sei ganzzahlig)
– eine gültige Äquivalenzklasse: 1 <= Wert <= 99
– zwei ungültige Äquivalenzklassen: Wert < 1, Wert > 99
• erlaubte Eingabe in einer Textliste: für ein Auto können
zwischen einem und sechs Besitzer eingetragen werden
– eine gültige Äquivalenzklasse: ein bis sechs Besitzer
– zwei ungültige Äquivalenzklassen: kein Besitzer, mehr als
sechs Besitzer
• erlaubte Eingabe: Instrumente Klavier, Geige, Orgel, Pauke
– vier gültige Äquivalenzklassen: Klavier, Geige, Orgel, Pauke
– eine ungültige Äquivalenzklasse: alles andere, z.B. Zimbeln
Grundkurs Software-Engineering mit UML
Stephan Kleuker
406
Regeln zur Bildung von Äquivalenzklassen
• man muss mögliche Eingaben kennen (aus Spezifikation)
• für einfache Zahlenparameter meist einfach:
– Intervall mit gültigen Werten
– eventuell Intervall mit zu kleinen und Intervall mit zu großen
Werten (wenn z. B. alle int erlaubt, gibt es nur eine
Äquivalenzklasse, etwas schwieriger bei double))
• explizit eine Menge von Werten vorgegeben:
– jeder Wert eine Äquivalenzklasse dar
– andere Eingaben möglich: dies zusätzliche
Äquivalenzklasse
• falls nach Analyse der Spezifikation Grund zur Annahme
besteht, dass Elemente einer Äquivalenzklasse unterschiedlich
behandelt werden, ist die Klasse aufzuspalten
Grundkurs Software-Engineering mit UML
Stephan Kleuker
407
Beispiel (1/5)
Spezifikation:
• Als Beispiel dient eine Methode, genauer ein
Konstruktor, zur Verwaltung von Studierendendaten,
der ein Name, ein Geburtsjahr und ein Fachbereich
übergeben werden. Dabei darf das Namensfeld nicht
leer sein, das Geburtsjahr muss zwischen 1900 und
2000 liegen und es können nur die Fachbereiche
FBING, FBBWL und FBPOL aus einer Aufzählung
übergeben werden.
Grundkurs Software-Engineering mit UML
Stephan Kleuker
408
Beispiel (2/5)
Äquivalenzklassen:
Eingabe
gültige
Äquivalenzklassen
ungültige
Äquivalenzklassen
Name
Ä1) nicht leer
Ä2) leer
Geburtsjahr
Ä4) 1900< =
Ä3) Geburtsjahr < 1900
Geburtsjahr <= 2000 Ä5) Geburtsjahr > 2000
Fachbereich
Ä6) FBING
Ä7) FBBWL
Ä8) FBPOL
Grundkurs Software-Engineering mit UML
Stephan Kleuker
409
Testfallerzeugung aus Äquivalenzklassen
• Die Äquivalenzklassen sind eindeutig zu
nummerieren. Für die Erzeugung von Testfällen aus
den Äquivalenzklassen sind zwei Regeln zu
beachten:
• gültige Äquivalenzklassen:
– möglichst viele Klassen in einem Test
kombinieren
• ungültige Äquivalenzklassen:
– Auswahl eines Testdatums aus einer ungültigen
Äquivalenzklasse
– Kombination mit Werten, die ausschließlich aus
gültigen Äquivalenzklassen entnommen sind.
– Grund: für alle ungültigen Eingabewerte muss
eine Fehlerbehandlung existieren
Grundkurs Software-Engineering mit UML
Stephan Kleuker
410
Beispiel (3/5)
Testfälle nach einer Äquivalenzklassenanalyse: (jeder Klasse
wird [mindestens] einmal getestet, die Testanzahl soll
möglichst gering sein)
Testnummer
1
geprüfte
Ä1
Äquivalenz- Ä4
klassen
Ä6
Name
2
3
4
5
6
(Ä1)
(Ä4)
Ä7
(Ä1)
(Ä4)
Ä8
Ä2
Ä3
Ä5
„Meier“
„Meier“
„Meier“ „Schmidt“ „Schulz“ „“
Geburtsjahr 1987
1985
1988
1892
2006
Fachbereich FBING FBBWL
FBPOL
FBING
FBING
FBING
Ergebnis
ok
Abbruch Abbruch Abbruch
ok
1989
ok
Grundkurs Software-Engineering mit UML
Stephan Kleuker
411
Grenzwertanalyse
• Viele Software-Fehler sind auf Schwierigkeiten in Grenzbereichen
der Äquivalenzklassen zurück zu führen (z.B. Extremwert nicht
berücksichtigt, Array um ein Feld zu klein)
• Aus diesem Grund wird die Untersuchung von
Äquivalenzklassen um die Untersuchung der Grenzen ergänzt
• Beispiel: 1<=Wert<=99 (wobei Wert ganzzahlig ist)
– Äquivalenzklasse Int-Wert<1: obere Grenze Wert=0 (untere
Grenze spielt hier keine Rolle)
– Äquivalenzklasse Int-Wert>99: untere Grenze Wert=100 (obere
Grenze spielt keine Rolle)
– Äquivalenzklasse 1<=Int-Wert<=99 : untere Grenze Wert=1
und obere Grenze Wert=99
• Diese Grenzfallbetrachtung kann direkt in die Testfallerzeugung
eingehen (es gibt Ansätze, bei denen zusätzlich ein Fall mit
einem Wert aus der „Mitte“ der Äquivalenzklasse genommen
wird)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
412
Beispiel (4/5)
• Testfälle nach einer Äquivalenzklassenanalyse und
Grenzwertanalyse
• Anmerkung: Testfallanzahl erhöht sich meist
Testnummer
1
geprüfte
Ä1
Äquivalenz- Ä4U
klassen
Ä6
Name
2
3
4
5
6
(Ä1)
Ä4O
Ä7
(Ä1)
(Ä4)
Ä8
Ä2
Ä3O
Ä5U
„Meier“ „Schmidt“ „Schulz“ „“
Geburtsjahr 1900
1985
1988
1899
2001
Fachbereich FBING FBBWL
FBPOL
FBING
FBING
FBING
Ergebnis
ok
Abbruch Abbruch Abbruch
ok
2000
„Meier“ „Meier“
ok
Grundkurs Software-Engineering mit UML
Stephan Kleuker
413
Beispiel (5/5)
• mögliche Übersetzung nach JUnit (Ausschnitt)
public class ImmatrikulationTest {
...
@Test
public void test1(){
try{
new Immatrikulation("Meier",1900,Bereich.FBING);
}catch(ImmatrikulationsException e){
fail("falsche Exception");
}
}
@Test
public void test4(){
try{
new Immatrikulation("",1988,Bereich.FBING);
fail("fehlende Exception");
}catch(ImmatrikulationsException e){
}
}
...
Grundkurs Software-Engineering mit UML
Stephan Kleuker
414
Schwierige Äquivalenzklassenbildung (1/4)
• Schreibe eine Methode max(), der drei Integer-Werte übergeben
werden, die den größten Wert dieser Werte zurück gibt
public class Maxi {
public static int max(int x, int y, int z){
int max=0;
if(x>z)max = x;
if(y>x)max = y;
if(z>y)max = z;
return max;
}
}
• nullter Klassenansatz: jeder Parameter darf beliebige Werte
annehmen, jeweils eine Klasse für x, y, z
• erster Klassen-Ansatz: es gibt keine Ausnahmefälle, also drei
Ergebnisse : Maximum steht an erster, zweiter oder dritter
Stelle
Grundkurs Software-Engineering mit UML
Stephan Kleuker
415
Schwierige Äquivalenzklassenbildung (2/4)
public class MaxiTest {
public MaxiTest(String arg0) {
super(arg0);
}
@Test
public void testErstesMax(){
assertTrue("Maximum an erster Stelle",
7==Maxi.max(7,5,4));
}
@Test
public void testZweitesMax(){
assertTrue("Maximum an zweiter Stelle",
7==Maxi.max(5,7,4));
}
Alle Tests laufen erfolgreich,
allerdings war die
Klassenbildung zu ungenau,
nächster Versuch mit den
Klassen:
x>=y>=z
x>=z>=y
z>=x>=y
z>=y>=x
y>=x>=z
y>=z>=x
[Frage: sind dies
Äquivalenzklassen ??]
@Test
public void testDrittesMax(){
assertTrue("Maximum an dritter Stelle",
7==Maxi.max(4,5,7));
}
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
416
Schwierige Äquivalenzklassenbildung (3/4)
• sechs Testfälle, Ausschnitt:
@Test
public void testXYZ(){
assertTrue("X>=Y>=Z", 7==Maxi.max(7,5,4));}
@Test
public void testXZY(){
assertTrue("X>=Z>=Y", 7==Maxi.max(7,4,5));}
@Test
public void testYXZ(){
assertTrue("Y>=X>=Z", 7==Maxi.max(5,7,4));}
• Fall X>=Z>=Y offenbart, dass das Verfahren nicht funktioniert
• Allerdings ist die Äquivalenzklassenwahl nicht sauber
Grundkurs Software-Engineering mit UML
Stephan Kleuker
417
Schwierige Äquivalenzklassenbildung (4/4)
• Saubere Äquivalenzklassen sind:
– x>y=z
y=z>x
– y>x=z
x=z>y
– z>y=x
y=x>z
– z>y>x
z>x>y
– y>z>x
y>x>z
– x>z>y
x>y>z
– x=y=z
• Bei Grenzwertanalyse muss der Übergang zwischen den
untersuchten Klassen betrachtet werden, d.h. wenn zwei oder
drei Argumente gleich sind (letzter Fall liefert auch Fehler)
• Aus der Spezifikation nicht ableitbar, allerdings gegebenenfalls
aus der Erfahrung mit der Mathematik zu ergänzen, ist die
Untersuchung des Verhaltens bei negativen Zahlen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
418
Äquivalenzklassenbildung und Objektorientierung
• Äquivalenzklassenbildung ist ein zentrales
Verfahren, um systematisch Tests aufzubauen
• für Methoden von Objekten spielt neben Ein- und
Ausgaben der interne Zustand häufig eine wichtige
Rolle (erst wenn Methode x ausführt wurde, dann
kann Methode y sinnvoll ausgeführt werden)
• Konsequenterweise muss man sich also mit dem
Ein-/Ausgabeverhalten pro möglichem
Objektzustand beschäftigen (was noch extrem
aufwändiger sein kann)
• das bisher vorgestellte Verfahren kann in der reinen
Form nur für gedächtnislose Objekte genutzt werden
Grundkurs Software-Engineering mit UML
Stephan Kleuker
419
Äquivalenzklassen und Objekte (1/5)
Spezifikation:
• In einem Bestellsystem wird für jeden Kunden im Objekt einer
Klasse Zuverlaessigkeit festgehalten, wie er bezüglich seines
Bezahlverhaltens eingestuft wird. Diese Einstufung wird durch
die folgende Aufzählung beschrieben.
public enum Bezahlstatus {
STANDARD, GEPRUEFT, KRITISCH;
}
• Die Klasse Zuverlaessigkeit soll eine Methode anbieten, mit der
geprüft werden soll, ob eine Bestellung über eine bestimmte
Summe ohne eine weitere Liquiditätsprüfung erlaubt werden
soll. Die Bestellung soll für geprüfte Kunden immer und für
kritische Kunden nie ohne zusätzliche Prüfung möglich sein.
Für sonstige Kunden muss eine Prüfung ab einer
Bestellstumme von 500€ erfolgen.
Grundkurs Software-Engineering mit UML
Stephan Kleuker
420
Äquivalenzklassen und Objekte (2/5)
public class Zuverlaessigkeit { // zu testen
private Bezahlstatus status;
public void setStatus(Bezahlstatus status){
this.status = status;
}
public boolean einkaufssummePruefen(int wert){
switch(this.status){
case GEPRUEFT:{
return true;
}
case STANDARD:{
return wert < 500;
}
}
return false;
}
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
421
Äquivalenzklassen und Objekte (3/5)
• erste Überlegung: nur Parameter wert zu testen, [wert<500] und
[wert>=500] (zwei Tests)
• zweite Überlegung: Objektzustand als weiteren Parameter
berücksichtigen; ergibt drei Testfälle: jeder Objektzustand mit
wert=499 oder wert=500 (Grenzwertanalyse) kombiniert
• dritte Überlegung: Kombination von Äquivalenzklassen
betrachten [status==STANDARD && wert==499] und
[status==STANDARD && wert==500] (d. h. vier Tests, noch
einen für GESPRUEFT und KRITISCH)
• vierte Überlegung: Alle Kombinationen betrachten (leider nur
selten machbar) (d. h. sechs Tests)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
422
Äquivalenzklassen und Objekte (4/5)
public class ZuverlaessigkeitTest extends {
private Zuverlaessigkeit zvl;
@Before
protected void setUp() throws Exception {
zvl = new Zuverlaessigkeit();
}
@Test
public void testGeprueft1(){
zvl.setStatus(Bezahlstatus.GEPRUEFT);
assertTrue(zvl.einkaufssummePruefen(499));
}
@Test
public void testGeprueft2(){
zvl.setStatus(Bezahlstatus.GEPRUEFT);
assertTrue(zvl.einkaufssummePruefen(500));
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
423
Äquivalenzklassen und Objekte (5/5)
}
@Test
public void testKritisch1(){
zvl.setStatus(Bezahlstatus.KRITISCH);
assertTrue(!zvl.einkaufssummePruefen(499));
}
@Test
public void testKritisch2(){
zvl.setStatus(Bezahlstatus.KRITISCH);
assertTrue(!zvl.einkaufssummePruefen(500));
}
@Test
public void testStandard1(){
zvl.setStatus(Bezahlstatus.STANDARD);
assertTrue(zvl.einkaufssummePruefen(499));
}
@Test
public void testStandard2(){
zvl.setStatus(Bezahlstatus.STANDARD);
assertTrue(!zvl.einkaufssummePruefen(500));
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
424
Kontrollflussgraph (KFG)
11.6
• eines Programms P ist ein gerichteter Graph
KFG(P) =def G = (V,E, VStart, VZiel)
• V: Menge der Knoten (Anweisungen des Programms)
• E ist Teilmenge von V×V: Menge der Kanten
(Nachfolgerelation bezüglich der Ausführung des
Programms)
• VStart , VZiel aus V : Ausgewählte Knoten für Start,
Ende des Programms
(VZiel kann auch eine Menge von Knoten sein)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
425
Beispiel: KFG
public int aha(int ein){
int erg=-ein/2;
//
int i=ein;
//
while(i>0){
//
erg=erg+(i--);
//
}
if (ein <0 || ein%2==1){//
erg=0;
//
}
return erg*2;
//
}
0
1
2
3
0
01
1
2
2
3
4
5
4
5
6
3
4
5
6
6
• Wunsch: Graph sollte unabhängig von der Formatierung sein!
• Programm gibt Quadrat aller positiven geraden Zahlen, sonst 0
zurück
• Testergebnisse werden vereinfachend bei folgenden
Testfallbeschreibungen weggelassen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
426
Normalisierung eines KFG durch Blockung
folgende Regeln, mit denen mehrere Knoten k1,k2,...,kn,
die nacheinander durchlaufen werden können, also
k1k2...kn, zu einem Knoten verschmolzen
werden.
• Die Knotenfolge wird bei jedem Durchlauf immer nur
über k1 betreten, es gibt außer den genannten
Kanten keine weiteren Kanten, die in k2,...,kn enden.
• Die Knotenfolge wird bei jedem Durchlauf immer nur
über kn verlassen, es gibt außer den genannten
Kanten keine weiteren Kanten, die in k1,...,kn-1
beginnen.
• Die Knotenfolge ist maximal bezüglich a) und b).
Grundkurs Software-Engineering mit UML
Stephan Kleuker
427
Analyse vollständiger Pfade
• Ein vollständiger Pfad ist eine Folge von verbundenen Knoten
(über Kanten) im KFG, die mit Vstart beginnt, und mit Vziel
endet.
• Die möglichen Ausführungsreihenfolgen des Programms sind
eine Teilmenge der vollständigen Pfade
• Wunsch: Durchlauf „repräsentativer“ vollständiger Pfade beim
Test
• Überdeckung aller vollständigen Pfade ist im allgemeinen nicht
ausführbar
• Ansatz: Verschiedene Approximationsstufen
(Anweisungsüberdeckungstest, ..., MehrfachBedingungsüberdeckungstest) für die Menge der vollständigen
Pfade bei Auswahl der Testdurchläufe wählen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
428
Anweisungsüberdeckung (C0)
• Ziel: alle Anweisungen des Programms durch Wahl geeigneter
Testdaten mindestens einmal ausführen, alle Knoten des KFG
mindestens einmal besuchen.
Anzahl der ausgeführten Knoten
• Testmaß
C0=
|V|
• Ziel: C0=1 (=100%)
• für {-1}
C0=
5/6
• für {-1,0}
C0=
5/6
• für {-1,2}
C0=
6/6
C0=
Grundkurs Software-Engineering mit UML
ein=-1
ein=0
ein=1
ein=2
01
01
01
01
2
2
2
2
3
3
3
3
4
4
4
4
5
5
5
5
6
6
6
6
5/6
4/6
6/6
5/6
Stephan Kleuker
429
Zweigüberdeckung (C1)
• Ziel :alle Kanten des KFG überdecken, d.h. alle Zweige des
Programms einmal durchlaufen
• Testmaß
Anzahl der durchlaufenen Kanten
C1=
|E|
ein=-1
• Ziel: C1=1
• für {-1}
C1=
4/7
• für {-1,0}
C1=
5/7
• für {-1,2}
C1=
7/7
C1=
Grundkurs Software-Engineering mit UML
ein=0
ein=1
ein=2
01
01
01
01
2
2
2
2
3
3
3
3
4
4
4
4
5
5
5
5
6
6
6
6
4/7
3/7
6/7
5/7
Stephan Kleuker
430
Kommentare zur Anweisungs- und Zweigüberdeckung
• Vorteile der Anweisungsüberdeckung:
– einfach
– geringe Anzahl von Eingabedaten
– nicht ausführbare Programmteile werden erkannt
• großer Nachteil der Anweisungsüberdeckung:
– Logische Aspekte werden nicht überprüft
• deshalb: Zweigüberdeckungstest gilt als das Minimalkriterium
im Bereich des dynamischen Softwaretests,
– schließt den Anweisungsüberdeckungstest ein,
– fordert die Ausführung aller Zweige eines KFG,
– jede Entscheidung mindestens einmal wahr und falsch
• Nachteile der Zweigüberdeckung:
– Fehlende Zweige werden nicht automatisch entdeckt
– Kombinationen von Zweigen sind unzureichend geprüft
– Komplexe Bedingungen werden nicht analysiert
– Schleifen werden nicht ausreichend analysiert
Grundkurs Software-Engineering mit UML
Stephan Kleuker
431
Einfache Bedingungsüberdeckung
• Ziel: Teste gezielt Bedingungen in Schleifen und
Auswahlkonstrukten
• Bedingungen sind Prädikate
– A1,..., A4 atomar
• z.B. (x==1) [auch !(x==1)]
– zusammengesetzt
• Konjunktion K
• Disjunktion D
• ( ( (x==1) || (x==2) )&&( (y==3) || (y==4) ) ) hat
7 Teilprädikate: x==1, x==2, y==3, y==4, (x==1) || (x==2),
(y==3) || (y==4) , ( ( (x==1) || (x==2) )&&( (y==3) || (y==4) ) )
• Hinweis: Bei Java und anderen Programmiersprachen ist der
Unterschied zwischen || und && (mit Kurzschlussauswertung)
und | und & (ohne Kurzschlussauswertung) zu beachten
if(true || 5/0==0) läuft, if(true | 5/0==0) läuft nicht
Grundkurs Software-Engineering mit UML
Stephan Kleuker
432
Einfache Bedingungsüberdeckung (C2)
• Ziel: alle atomaren Prädikate einmal TRUE, einmal FALSE
|wahre Atome| + |falsche Atome|
• Testmaß:
C2=
2 * |alle Atome|
• |alle Atome| =Anzahl aller Atome, |wahre Atome|= Anzahl aller
Atome, die mit true ausgewertet werden (analog | falsche
Atome|)
Testfälle {-1} {0} {1} {2}
{-1,0} {0,1} {1,2} {-1,1} {-1,1,2}
i>0
f
f
f,t
f,t
f
f,t
f,t
f,t
f,t
ein<0
t
f
f
f
t,f
f
f
t,f
t,f
ein%2==1 -
f
t
f
f
f,t
t,f
t
t,f
C2-Überdeckung
3/6 4/6 4/6
4/6
5/6
5/6
5/6
6/6
2/6
Grundkurs Software-Engineering mit UML
Stephan Kleuker
433
Kein Zusammenhang zwischen C1 und C2
• Die Nummerierung C1, C2 ist historisch gewachsen
• betrachte if (a || b)
– a=true, b=false
a=false, b=true
• garantiert vollständige einfache
Bedingungsüberdeckung (C2)
• else-Zweig wird nicht durchlaufen, keine Zweigoder Anweisungsüberdeckung (C1, C0)
– a=true, b=false
a=false, b=false
• if- und else-Zweig wird durchlaufen, damit
Zweig- und Anweisungsüberdeckung
• keine vollständige einfache
Bedingungsüberdeckung, da b=true fehlt
Grundkurs Software-Engineering mit UML
Stephan Kleuker
434
Minimale Mehrfachbedingungsüberdeckung (C3)
• Ziel: alle Prädikate und Teil-Prädikate einmal TRUE, einmal
FALSE
|wahre Teilprädikate| + |falsche Teilprädikate|
C3=
• Testmaß:
2 * |alle Teilprädikate|
Testfälle {-1} {0} {1} {2}
{-1,0} {0,1} {1,2} {-1,1} {-1,1,2}
i>0
f
f
f,t
f,t
f
f,t
f,t
f,t
f,t
ein<0
t
f
f
f
t,f
f
f
t,f
t,f
ein%2==1 -
f
t
f
f
f,t
t,f
t
t,f
ein<0 ||
ein%2==1
t
f
t
f
t,f
f,t
t,f
t
t,f
C3-Überdeckung
3/8
4/8 5/8 5/8
6/8
7/8
7/8
6/8
8/8
Grundkurs Software-Engineering mit UML
Stephan Kleuker
435
Zusammenhang zwischen den Testverfahren
Anmerkung: Diese Thema
kann noch wesentlich
vertieft werden
Minimaler
Mehrfachbedingungsüberdeckungstest (C3)
Zweigüberdeckungstest (C1)
Einfacher Bedingungsüberdeckungstest (C2)
Anweisungsüberdeckungstest (C0)
vollständige Überdeckung des einen bedeutet
vollständige Überdeckung des anderen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
436
Automatisierung der Ci-Tests
• Ohne eine Tool-Unterstützung ist es sehr aufwändig
und fehlerträchtig, solche Überprüfungen zu machen
• Für andere Sprachen als Java (und C#) sind
Coverage-Werkzeuge vorhanden, die man bzgl. der
zu untersuchenden Überdeckung einstellen kann
• Für Java gibt es nur verschiedene Programme, die
den Anweisungsüberdeckungstest und teilweise den
Zweigüberdeckungstest (CoceCover, Eclemma,
Coverlipse, JCoverage, Hansel für JUnit, Clover)
unterstützen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
437
Info: Standard DO-178B
•
•
•
•
•
•
Um die Zertifizierung der Federal Aviation Administration (FAA) zu
erhalten, muss Software für Luftverkehrssysteme den Richtlinien des
Standards DO-178B für requirement-basiertes Testen und Code
Coverage Analysen genügen.
DO-178B-Levels orientieren sich an den Konsequenzen möglicher
Softwarefehler: katastophal (Level A), gefährlich/schwerwiegend
(Level B), erheblich (Level C), geringfügig (Level D) bzw. keine
Auswirkungen (Level E).
Je nach DO-178B-Level wird der 100%-ige Nachweis folgender
Testabdeckungen (Code Coverages) verlangt:
DO-178B Level A:
– Modified Condition Decision Coverage (MC/DC)
– Branch/Decision Coverage
– Statement Coverage
DO-178B Level B:
– Branch/Decision Coverage
– Statement Coverage
DO-178B Level C:
– Statement Coverage
Grundkurs Software-Engineering mit UML
Stephan Kleuker
438
Teststufen (grober Ablauf)
11.7
Klassentest
entwicklungsintern
Integrationstest
Systemtest
entwicklungsextern (mit Kunden)
Grundkurs Software-Engineering mit UML
Abnahmetest
Stephan Kleuker
439
Klassentest (Modultest)
• Varianten:
– Unit-Test: einzelne Methoden und/oder Klassen
– Modultest: logisch-zusammengehörige Klassen,
z.B. ein Package in Java
• Testziel: Prüfung gegen Feinspezifikation
– Architektur, Design, Programmierkonstrukte
• Testmethode: White-Box-Test
• Alle Module müssen getestet werden
– eventuell mit unterschiedlicher Intensität
Grundkurs Software-Engineering mit UML
Stephan Kleuker
440
Integrationstest
• Module werden zu einem System integriert und gemeinsam
getestet
• Testziele:
– Werden Schnittstellen richtig benutzt?
– Werden Klassen bzw. ihre Methoden richtig aufgerufen?
• Konzentration auf (Export-) Schnittstellen
– Interne Schnittstellen können nicht mehr direkt beeinflusst
werden
– Geringere Testtiefe als beim Modultest
– Grey-Box-Test (oder auch Black-Box)
• Techniken ähnlich wie bei Modultest
– Pfadanalyse über die komplette Interaktion der Module oft
nicht mehr sinnvoll
• Mit minimaler Systemkonfiguration beginnen,
Integrationsstrategie spielt eine Rolle
Grundkurs Software-Engineering mit UML
Stephan Kleuker
441
Systemtest
• Orientierung an den spezifizierten Systemaufgaben (z.B. Use
Cases)
• Interaktion mit den (simulierten) Nachbarsystemen
• (endgültige) Validierung der nicht-funktionalen Anforderungen,
z.B. Skalierbarkeit, Verfügbarkeit, Robustheit, ...
• wichtige Teilaufgabe: Testdaten-Verwaltung
– Wiederherstellung des ursprünglichen Zustands der
Testdaten
– Autarke Datenbestände:
Kein gegenseitiges “Zerschießen“ der Testdaten
– für DB: Kollisionen in den Nummernkreisen der
Schlüsselattribute vermeiden
– Datumsfelder können altern. Wie können Testdaten zum
aktuellen Datum passen?
• Tagesdatum aus (manipuliertem) Kalender-Modul holen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
442
Testansätze zusammengefasst
White-Box-Test
Gray-Box-Test
Anweisungen
Entscheidungen
Pfade
Black-Box-Test
Paket/
Komponente
Eingaben
Schnittstellen
System
Ausgaben
Methoden-/Klassentest
Grundkurs Software-Engineering mit UML
Integrationstest
Stephan Kleuker
Systemtest
443
Testfälle und die UML
Entwicklung in der UML
Testen
Use Case Diagramme
Systemtestfälle
Aktivitätsdiagramme
Komponentendiagramme
Integrationstestfälle
Sequenzdiagramme
Klassentestfälle
Klassendiagramme
Zustandsdiagramme
Grundkurs Software-Engineering mit UML
Stephan Kleuker
444
Effiziente Massentests
• Oftmals muss man recht ähnliche Daten zum Testen
nutzen, dabei bietet es sich an, diese Testdaten in
einem File zu speichern und die Daten schrittweise
auszulesen
• Generell können professionelle Testwerkzeuge meist
Daten aus Datenbanken, kommaseparierten Listen,
Excel-Files, ... lesen
• TestNG als JUnit-Erweiterung erlaubt
Testdatengenerierung für Unit-Tests
Grundkurs Software-Engineering mit UML
Stephan Kleuker
445
Prinzip des Regressionstests
Software
Version n
Testfallspezifikation
Version n
Test
Testarchivierung
der Iteration n
Referenztestfälle
Testfallergebnisse
Software
Version n+1
Regressionstest
Testfalldatenbank
Vergleich der
Testergebnisse
Grundkurs Software-Engineering mit UML
Stephan Kleuker
446
Regressionstests im Entwicklungszyklus
Testfallentwicklung
erste Entwicklung
Version 1
Test
Testfallentwicklung
Weiterentwicklung
Regressionstestfälle
Test
Testfallentwicklung
Version 2
Weiterentwicklung
Regressionstestfälle
Test
Grundkurs Software-Engineering mit UML
Version n
Stephan Kleuker
447
Regressionstest
• Änderungen an bereits freigegebenen Modulen sind
notwendig
• Gibt es Auswirkungen auf die alten Testergebnisse?
• Wenn ja, welche?
• Wiederholbarkeit der Tests
• Wiederherstellung der Testdaten
• Der Testprozess muss automatisierbar sein
• Testfälle müssen gruppiert werden können, damit
man sie wegen der untersuchten Funktionalität (oder
auch Testdauer) gezielt einsetzen kann
Grundkurs Software-Engineering mit UML
Stephan Kleuker
448
Wartung und Testen
• Der Test ist geteilt in Änderungstest (White-Box) und
Regressionstest (Black-Box)
• Änderungstest vom Entwickler, er schreibt die
Testfälle fort.
• Regressionstest von unabhängiger Testgruppe mit
den alten plus neuen Testfällen durchgeführt
• Testgruppe ist für Pflege und Fortschreibung der
Systemtestfälle verantwortlich
Grundkurs Software-Engineering mit UML
Stephan Kleuker
449
Lasttest
• Geforderte Performance
– Durchsatz bzw. Transaktionsrate
– Antwortzeiten
• Skalierbarkeit
– Anzahl Endbenutzer
– Datenvolumen
– Geografische Verteilung
• Zugriffskonflikte konkurrierender Benutzer
• Entspricht dem Zeitraum nach der Inbetriebnahme
• Simulation von
– Anzahl Endbenutzer,
– Transaktionsrate , ...
– Über einen signifikanten Zeitraum (mehrere Stunden)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
450
Untersuchung des Laufzeitverhaltens
• wie oft wird jede Methode aufgerufen (oder Quellcodezeile
durchlaufen)
• welche Methode ruft wie oft welche andere Methode
(descendants) auf oder von welchen Methoden (callers) wird
eine Methode wie oft gerufen
• wie viel Prozent der Gesamtlaufzeit wird mit Ausführung einer
bestimmten Methode verbracht (ggf. aufgeteilt nach callers und
descendants)
Nutzen der ermittelten Daten
• Operationen, die am meisten Laufzeit in Anspruch nehmen,
können leicht identifiziert (und optimiert) werden
• tatsächliche Aufrufabhängigkeiten werden sofort sichtbar
Grundkurs Software-Engineering mit UML
Stephan Kleuker
451
Untersuchung des Speicherplatzverhaltens
• welche Operationen fordern wie viel Speicherplatz an (geben
ihn frei)
• wo wird Freigabe von Speicherplatz vermutlich bzw. bestimmt
vergessen (memory leak = Speicherloch):
• bestimmt vergessen: Objekt lebt noch, kann aber nicht mehr
erreicht werden (Garbage Collector von Java würde es
entsorgen)
• vermutlich vergessen: Objekt lebt noch und ist erreichbar, wird
aber nicht mehr benutzt (Garbage Collector von Java kann es
nicht freigeben)
• wo wird auf bereits freigegebenen Speicherplatz zugegriffen
(nur für C++) bzw. wo wird Speicherplatz mehrfach freigegeben
(nur für C++)
• wo wird auf nicht initialisierten Speicherplatz zugegriffen;
anders als bei der statischen Programmanalyse wird für jede
Feldkomponente (Speicherzelle) getrennt Buch darüber geführt
• wo finden Zugriffe jenseits der Grenzen von Arrays statt
(Laufzeitfehler in meisten Programmiersprachen)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
452
Lasttest und Speicherverhalten in Java
• Hinweis: Java unterstützt das „Profiling“, hierzu
stehen explizite Compiler- und Ausführungsoptionen
zur Verfügung
• kommerzielle Produkte, z. B. „IBM/Rational Purify
und Quantifiy
• freies Werkzeug:
– JMeter: http://jakarta.apache.org/jmeter/
(besonders interessant für Lasttests von WebServern und Datenbankzugriffen)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
453
Test von Oberflächen
• Grundsätzlich sind Oberflächen gewöhnliche SW-Module und
können wie diese getestet werden.
• Für xUnit-Werkzeuge ist der Zugriff auf Oberflächen teilweise
schwierig (xUnit muss auf Oberflächenkomponenten zugreifen
und diese bedienen können, JButton in Java hat z.B. Methode
doClick())
• Für Oberflächen gibt es deshalb Capture & Replay-Werkzeuge
• Grundidee: Das Werkzeug zeichnet alle Mausbewegungen und
Tastatureingaben auf, die können dann zur Testwiederholung
erneut abgespielt werden
• Typisch ist, dass der Nutzer die aufgezeichneten Skripte
modifizieren kann (z. B. Test von berechneten Daten)
• Tools können teilweise auch Oberfläche lesen (Frage ob Texte
richtig ausgegeben), Snapshots vergleichen
• professionelle Beispiele: Winrunner von HP (früher Mercury),
VisualTest von IBM-Rational
• zum Ausprobieren: Abbot (http://abbot.sourceforge.net/)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
454
Nutzung von Maßsystemen
• Die bisherigen Überprüfungsverfahren sind recht aufwändig,
es besteht der Wunsch, schneller zu Qualitätsaussagen zu
kommen
• Der Ansatz ist die Einführung eines Maßsystems, aus dem
System werden Zahlenwerte generiert, deren Werte ein Indiz
für die Qualität eines Produktes geben
• Werden diese Maße automatisch berechnet, kann man
Qualitätsforderungen stellen, dass bestimmte Maßzahlen in
bestimmten Bereichen liegen
• Wichtig ist, dass man weiß, dass nur Indikatoren betrachtet
werden, d.h. gewonnene Aussagen müssen nachgeprüft
werden
• Ähnliche Ansätze in der Projektverfolgung und Analyse der
Firmengesamtlage (-> Balanced Scorecard)
-> siehe Qualitätsmanagement
Grundkurs Software-Engineering mit UML
Stephan Kleuker
455
Metriken zur Ermittlung des Projektstands
11.8
programmiert/
überdeckt
100%
50%
0%
Use
Cases
Grundkurs Software-Engineering mit UML
Pakete
C1-Überdeckung
Stephan Kleuker
C2-Überdeckung
456
Grobe Metriken (Min, Max, Schnitt, Abweichung)
• Lines of Code pro Methode (LOC)
Nach der Grundregel des guten Designs sollte die maximale
Zahl unter 20 liegen
• Methoden pro Klasse
Die Zahl sollte zwischen 3 und 15 liegen
• Parameter pro Methode
Die Zahl sollte unter 6 liegen
• Exemplarvariablen pro Klasse
Die Zahl sollte unter 10 liegen [Entitäten ?]
• Abhängigkeiten zwischen Klassen
Keine Klasse sollte von mehr als vier Klassen abhängen
• andere Maßzahlen, wie die Anzahl von Klassenvariablen und
Klassenmethoden können auch als Indikatoren eingesetzt
werden
Grundkurs Software-Engineering mit UML
Stephan Kleuker
457
Zyklomatische Zahl nach McCabe
1. Man konstruiere die Kontrollflussgraphen
2. Man messe die strukturellen Komplexität
Die zyklomatische Zahl z(G) eines
Kontrollflussgraphen G ist:
z(G) = e – n + 2 mit
• e = Anzahl der Kanten des Kontrollflussgraphen
• n = Anzahl der Knoten
Zyklomatische Komplexität gibt Obergrenze für die
Testfallanzahl für den Zweigüberdeckungstest an
In der Literatur wird 10 oft als maximal vertretbarer Wert
genommen (für OO-Programme geringer, z. B. 5)
für Java: #if + #do + #while + #switch-cases+ 1
Grundkurs Software-Engineering mit UML
Stephan Kleuker
458
Beispiele für die zyklomatische Zahl
Anzahl
Kanten
Anzahl
Knoten
McCabe
Zahl
0
2
4
3
6
1
3
4
3
5
1
1
2
2
3
Grundkurs Software-Engineering mit UML
Stephan Kleuker
459
Erweiterte McCabe-Zahl
• Komplexität von Verzweigungen berücksichtigen
• gezählt werden alle Booleschen Bedingungen in
if(<Bedingung>) und while(<Bedingung>):
anzahlBedingung
• gezählt werden alle Vorkommen von atomaren
Prädikaten: anzahlAtome
z. B.: ( a || x>3) && y<4 dann anzahlAtome=3
• erweitere McCabe-Zahl
ez(G) = z(G) + anZahlAtome - anzahlBedingung
• wenn nur atomare Bedingungen, z. B. if( x>4), dann
gilt ez(G) = z(G)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
460
Lack of Cohesion in Methods (LCOM*)
• nutzt(a) die Zahl der Methoden, die eine Exemplarvariable a der
untersuchten Klasse nutzen
• sei avgNutzt der Durchschnitt aller Werte für alle
Exemplarvariablen
• sei m die Anzahl aller Methoden der untersuchten Klasse
• LCOM* = (avgNutzt–m) /(1-m)
• Ist der Wert nahe Null, handelt es sich um eine eng
zusammenhängende Klasse
• Ist der Wert nahe 1, ist die Klasse schwach zusammenhängend,
man sollte über eine Aufspaltung nachdenken
• Hinweis: Es muss vorher festgelegt werden, ob
Klassenvariablen und Klassenmethoden berücksichtigt werden
sollen
• Was passiert, wenn man konsequent exzessiv OO macht und
auch in den Exemplarmethoden get() und set() Methoden nutzt?
Wie ist LCOM* dann rettbar?
Grundkurs Software-Engineering mit UML
Stephan Kleuker
461
LCOM*-Beispiel
public class LCOMSpielerei {
private int a;
private int b;
private int c;
public void mach1(int x){
a=a+x;
}
public void mach2(int x){
a=a+x;
b=b-x;
}
nutzt(a)=3
nutzt(b)=2
nutzt(c)=1
avgNutzt=6/3=2
LCOM*= (2-3) /(1-3)
= -1/-2= 0.5
public void mach3(int x){
a=a+x;
für Eclipse gibt es Plugin Metrics
b=b-x;
http://sourceforge.net/projects/metrics/
c=c+x;
berechnet u. A. erweiterte
}
MCCabe-Zahl und LCOM*
}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
462
Konstruktive Qualitätssicherung
11.9
• die analytische Qualitätssicherung greift erst, wenn
ein Produkt erstellt wurde
• interessant ist der Versuch, Qualität bereits bei der
Erstellung zu beachten
• typische konstruktive Qualitätsmaßnahmen sind
– Vorgabe der SW-Entwicklungsumgebung mit
projekteigenem Werkzeughandbuch, was wann
wie zu nutzen und zu lassen ist
– Stilvorgaben für Dokumente und Programme
(sogenannte Coding-Guidelines)
• Die Frage ist, wie diese Maßnahmen überprüft
werden
Grundkurs Software-Engineering mit UML
Stephan Kleuker
463
Coding Guidelines
• Detailliertes Beispiel: Taligent-Regeln für C++
(http://pcroot.cern.ch/TaligentDocs/TaligentOnline/D
ocumentRoot/1.0/Docs/index.html)
• Sun hat auch Regeln für Java herausgegeben (nicht
ganz so stark akzeptiert)
• z. B. Eclipse-Erweiterung Checkstyle
• Generell gibt es Regeln
– zur Kommentierung,
– zu Namen von Variablen und Objekten (z.B.
Präfix-Regeln),
– zum Aufbau eines Programms (am schwierigsten
zu formulieren, da die Programmarchitektur
betroffen ist und es nicht für alle Aspekte „die
OO-Regeln“ gibt)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
464
Beispiel-Coding-Regel
•
•
Ausschnitt aus „Java Code Conventions“, Sun, 1997
Inhalt soll sich nicht nur auf Formatierung beziehen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
465
Anti-Pattern
• Pattern dienen zur sinnvollen Strukturierung komplexer, aber
gleichartiger Systeme
• Anti-Pattern sind wiederkehrende schlechte Lösungen, die man
an Strukturen erkennen kann, z. B.
– Spaghetti-Code, viele if, while und repeat-Schleifen
gemischt, intensive Nutzung der Möglichkeiten mit break,
früher: goto
– Cut-and-Paste-Programmierung: „was oben funktionierte,
funktioniert hier auch“
– allmächtige Klassen, kennen jedes Objekt, sitzen als Spinne
im Klassendiagramm, immer „gute“ Quelle für
Erweiterungen
– Rucksack-Programmierung: bei vergessenem Sonderfall in
allen betroffenen Methoden
if (Sonderfall){ Reaktion } else { altes Programm}
• Literatur (z. B.): W. J. Brown, R. C. Malveau, H. W. McCormick
III, T. J. Mowbray, AntiPatterns, Wiley, 1998
Grundkurs Software-Engineering mit UML
Stephan Kleuker
466
Manuelle Prüfmethoden
11.10
• Produkte und Teilprodukte werden manuell
analysiert, geprüft und begutachtet
• Ziel ist es, Fehler, Defekte, Inkonsistenzen und
Unvollständigkeiten zu finden
• Die Überprüfung erfolgt in einer Gruppensitzung
durch ein kleines Team mit definierten Rollen
• Anmerkung: Es werden hier Inspektionen, Reviews
und Walkthroughs betrachtet (in abnehmender
Formalität), in der Literatur ist „Reviews“ teilweise
der Oberbergriff
Grundkurs Software-Engineering mit UML
Stephan Kleuker
467
Voraussetzungen manueller Prüfmethoden
• notwendigen Aufwand und benötigte Zeit einplanen
• Jedes Mitglied des Prüfteams muss in der
Prüfmethode geschult sein
• Prüfergebnisse nicht zur Beurteilung von
Mitarbeitern nutzen
• Die Prüfmethode muss schriftlich festgelegt und
deren Einhaltung überprüft werden
• Prüfungen haben hohe Priorität, d.h. sie sind nach
der Prüfbeantragung kurzfristig durchzuführen
• Vorgesetzte und Zuhörer sollen an den Prüfungen
nicht teilnehmen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
468
Inspektionsablauf (1/3)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
469
Inspektionsablauf (2/3)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
470
Inspektionsablauf (3/3)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
471
weitere manuelle Prüfmethoden (1/2)
Review
• weniger formal als Inspektion
• Gutachter überprüfen ein schriftliches Dokument, um dessen
Stärken und Schwächen festzustellen
• Review-Ablauf ist im wesentlichen wie der Ablauf einer
Inspektion. Die Unterschiede bestehen darin, dass:
– der Autor dabei ist (passiv und um Missverständnisse zu
klären),
– der Autor die verteilten und markierten Kopien des
Prüfobjekts erhält und
– das Review-Team im Falle einer Zurückweisung eine
erneute Sitzung verlangen kann
• Während des Reviews werden keine Lösungen diskutiert!
Damit gute Ideen nicht verloren gehen, kann eine formlose
„dritte Stunde“ angehängt werden
Grundkurs Software-Engineering mit UML
Stephan Kleuker
472
weitere manuelle Prüfmethoden (2/2)
Walkthrough
• ist abgeschwächte Form des Reviews
• Autor leitet als Moderator die Walkthrough-Sitzung
• Zu Beginn [evtl. früher] der Sitzung erhält jeder
Gutachter eine Kopie des Prüfobjektes
• Das Prüfobjekt wird Schritt für Schritt vorgestellt
und die Gutachter stellen spontane Fragen und
versuchen so, mögliche Probleme zu identifizieren
• Probleme werden protokolliert
• Walkthrough-Variante besteht darin, vor der Sitzung
eine individuelle Vorbereitung durchzuführen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
473
Vor- und Nachteile manueller Prüfmethoden
+ Oft die einzige Möglichkeit, Semantik zu überprüfen
+ Notwendige Ergänzung werkzeuggestützter Überprüfungen
+ Die Verantwortung für die Qualität der geprüften Produkte wird
vom ganzen Team getragen
+ Da die Überprüfungen in einer Gruppensitzung durchgeführt
werden, wird die Wissensbasis der Teilnehmer verbreitert
+ Jedes Mitglied des Prüfteams lernt die Arbeitsmethoden seiner
Kollegen kennen
+ Die Autoren bemühen sich um eine verständliche
Ausdrucksweise, da mehrere Personen das Produkt
begutachten
+ Unterschiedliche Produkte desselben Autors werden von
Prüfung zu Prüfung besser, d.h. enthalten weniger Fehler
- In der Regel aufwändig (bis zu 20 Prozent der
Erstellungskosten des zu prüfenden Produkts)
- Autoren geraten u.U. in eine psychologisch schwierige
Situation (»sitzen auf der Anklagebank«, »müssen sich
verteidigen«)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
474
12. Umfeld der SoftwareEntwicklung
12.1 Versionsmanagement
12.2 Build-Management
12.3 Grundlagen der Projektplanung und verfolgung
12.4 Aufwandsschätzung
12.5 Qualitätsmanagement
12.6 Der Mensch im Projekt
Grundkurs Software-Engineering mit UML
Stephan Kleuker
475
Typischer Weg der Software-Entwicklung
12.1
A u fg a b e n te il
a u s w ä h le n
P ro g ra m m s tü c k
k o d ie re n
P ro g ra m m s tü c k
te s te n
[lä u ft]
[kle in e r
F e h le r]
K o rre k tu rv e rs u c h
[F e h le r
u n kla r]
E in b a u /N u tz u n g v o n
D e b u g in fo rm a tio n e n
[kle in e
Ü b e ra rb e itu n g ]
k le in e
L ö s u n g s v a ria n te
[U m stru k tu rie ru n g ]
g ro ß e
L ö s u n g s v a ria n te
[n ich t fe rtig ]
[fe rtig ]
Grundkurs Software-Engineering mit UML
Stephan Kleuker
476
Software-Versionen
• Software entwickelt sich inkrementell, bei Versuchen muss der
Weg zurück möglich sein
• Versionsbaum
Paket 1
Paket 2
Paket 3
V1
V1
V1
V2
V2
V2
V3
V4
V3
V4
V5
V6
V3
Inkrement 1
V4
V5
V6
Inkrement 2
V7
V5
Grundkurs Software-Engineering mit UML
Stephan Kleuker
477
Verwaltung von Software
• Die gemeinsame Entwicklung von Software hat u. a.
folgende Aufgaben zu lösen:
– wie kann ein Entwickler seine eigene
Softwareentwicklung koordinieren
– wie bekommen andere Entwickler mit, was der
aktuelle Entwicklungsstand ist
– wie wird aus den einzelnen Dateien effizient das
lauffähige System kompiliert
• Die ersten beiden Fragen beantwortet ein
Versionskontrollsystem
• die letzte Frage fordert die Erweiterung zum
Softwarekonfigurationsmanagementsystem (-> Ant)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
478
Konflikt bei gemeinsamer Bearbeitung
A rto n
D a te i D
auschecken
N a d ia
D a te i D
V e rsio n n
D a te i D
auschecken
D b e a rb e ite n
D b e a rb e ite n
D a te i D
V e rsio n n + 1
D a te i D
e in c h e c k e n
D a te i D
e in c h e c k e n
Grundkurs Software-Engineering mit UML
Stephan Kleuker
479
Versionskontrolle: konservative Variante
•
•
•
•
Dateien werden zentral im Repository verwaltet
Entwickler checkt zu ändernde Software aus
Entwickler erhält damit lokale Kopie zur Bearbeitung
Während der Entwickler an der Software arbeitet, kann niemand
anderes diese Software bearbeiten (erhält die Situation
klärenden Hinweis)
• Entwickler checkt lokale Kopie (mit Änderungsverweis) wieder
ein; jeder kann diese Kopie zur erneuten Bearbeitung
auschecken
• Vorteil: garantiert nur ein Bearbeiter
• Nachteile: keine gleichzeitige Arbeit an unterschiedlichen
Programmstellen, wartende Entwickler, vergessenes
Einchecken
• Realisierung von Repository sehr unterschiedlich lösbar
(Datenbanksystem, Aufsatz auf Filesystem)
• Hinweis: Generell sollte das Einchecken mit einer Prüfung
verbunden sein
Grundkurs Software-Engineering mit UML
Stephan Kleuker
480
Versionskontrolle: progressive/chaotische Variante
•
•
•
•
Dateien werden zentral im Repository verwaltet
Entwickler checkt zu ändernde Software aus
Entwickler erhält damit lokale Kopie zur Bearbeitung
andere Entwickler können gleichen Programmcode
auschecken
• erst beim Einchecken wird geprüft, ob seit dem Auschecken
zwischenzeitliche neue Version eingecheckt wurde, wenn ja,
passiert Versionsabgleich, Konflikt muss gelöst werden
• Vorteil: massive parallele Arbeit wird möglich, kein
Ausbremsen anderer Entwickler
• Nachteil: Chaos bei häufig veränderten Ressourcen
• Lösung: für selten genutzte Dateien progressiver, für sehr
kritische oder häufig genutzte Dateien konservativer Ansatz
Grundkurs Software-Engineering mit UML
Stephan Kleuker
481
Herstellung der Entwicklungsumgebung
12.2
• In großen Projekten arbeiten Entwickler häufig nicht auf einer
Quelldatei; Dateien werden lokal kopiert und dort bearbeitet
– Vorteil: ordentliche Verfolgung von Änderungen, laufende
Programmversionen können nicht verloren gehen
– Nachteil: Entwickler muss Kopien für seinen Arbeitsbereich
erstellen
• Lösung: Automatisierung des Kopier- und
Übersetzungsprozesses (+ weiterer Standardaufgaben)
– Einsatz von Skripten sh, *.bat
– besser: Einsatz von Werkzeugen, wie make und ant (auch
Build-Tools genannt)
• In Großprojekten muss der Entwickler die dahinter liegenden
automatisierten Prozesse nicht kennen, er muss nur wissen,
wo „seine“ mit welchen Randbedingungen läuft
• Software durchläuft bei der Installation häufig eine Installationsroutine, bei der u. a. Pfade gelesen und bearbeitet werden
Grundkurs Software-Engineering mit UML
Stephan Kleuker
482
Ant
• Apache Ant (another neat tool, James Duncan
Davidson) ist Alternative zu make-Files
• Ant-Files können betriebssystemunabhängig
formuliert werden
• alle Befehle im XML-Format
• viele Werkzeuge bieten XML-Tasks an, mit denen
verschiedene Befehle des Werkzeugs aus Ant
heraus ausgeführt werden können (z. B.
Kompilieren)
• Ant kann leicht erweitert werden, da in Java
geschrieben, als Framework konzipiert
• Ant benötigt XML-Parser, Apache Xerces mitgeliefert
• erste Schritte auf Veranstaltungswebseite
Grundkurs Software-Engineering mit UML
Stephan Kleuker
483
Konzept von Ant (und make)
• Es gibt zentrales Ziel (project) , was erreicht werden
soll (z. B. vollständige Kompilation)
• Jedes Ziel besteht aus Teilzielen (target), die vorher
erreicht werden müssen (z. B. Übersetzung eines
Teilpakets)
• Werkzeug stellt Regeln auf, was in welcher
Reihenfolge gemacht werden muss, um zentrales
Ziel zu erreichen
• Werkzeug bietet dabei u. a.
– Reaktionsmöglichkeiten bei Fehlern
– Varianten bei der Ausführung
– Möglichkeit, Ordner zu löschen und anzulegen,
Dateien zu kopieren, verschieben und löschen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
484
Erinnerung an make
all : file1.o file2.o file3.o
gcc -o prog file1.o file2.o file3.o
file1.o : file1.c
gcc -Wall -c file1.c
file2.o : file2.c
gcc -Wall -c file2.c
file3.o : file3.c
gcc -Wall -c file3.c
Grundkurs Software-Engineering mit UML
Stephan Kleuker
485
Beispiel für Abhängigkeiten
<target
<target
<target
<target
name="init"/>
name="preprocess" depends="init"/>
name="compile" depends="init,preprocess"/>
name="package" depends="compile"/>
• Die Reihenfolge der Ziele (target) in der Datei hat keine
Bedeutung, nur „depends“ dabei wichtig
• Neben einem default-Ziel kann man beim Start ein Ziel
auswählen, z. B. compile
• alle depends betrachtet und schrittweise vom Werkzeug in
mögliche Reihenfolge gebracht, hier:
– init hat keine Abhängigkeiten, wird zuerst ausgeführt (was,
hier nicht sichtbar)
– preprocess benötigt init, da schon ausgeführt, wird nur
preprocess ausgeführt
Grundkurs Software-Engineering mit UML
Stephan Kleuker
486
Ant-Basisskript (erzeugt von Eclipse)
<?xml version="1.0"?>
<!-- =============================================
Projekt, Datum, Aufgabe Autor,
============================================= -->
<project name="project" default="default">
<description>
description
</description>
<!-- =================================
target: default
================================= -->
<target name="default" depends="depends"
description="--> description">
</target>
<!-- - - - - - - - - - - - - - - - - target: depends
- - - - - - - - - - - - - - - - - -->
<target name="depends">
</target>
</project>
Grundkurs Software-Engineering mit UML
Stephan Kleuker
487
Skript-Konstanten (Eigenschaften, Properties)
• <property name="eigen" value = "Wert" />
• Nutzung von Property-Werten mit ${eigen}
<property name= "db" value = "${eigen}.db"/>
• Bei Pfaden wird statt „value“ dann „location“ genutzt, dabei
werden / und \ automatisch angepasst
<property name="ziel" location="${p}/bla/fas"/>
<property name="ziel" location="${p}\bla\fas"/>
• Laufwerksbuchstaben, wie „C:“ sind verboten (möglichst mit
relativen Pfaden arbeiten)
• Es gibt vordefinierte Properties, z. B. ${user.home}
Grundkurs Software-Engineering mit UML
Stephan Kleuker
488
Beispiel-Task: Kompilieren
<!-- classpath in der Form besser weglassen! -->
<target name="compile"
depends="start"
description="kompiliere">
<javac srcdir="src"
destdir="build"
classpath="."
debug="on">
</javac>
<echo message="in compile"/>
</target>
• weitere Parameter können der Ant-Dokumentation entnommen
werden (...\ant\docs\manual\index.html)
• classpath nur nutzen, wenn weitere Pakete genutzt werden
• echo hier als Spielerei
• Übersetzung aller Klassen in Verzeichnis src und
Unterverzeichnissen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
489
Beispiel-Task: Packen
<!-- existierendes Manifest mit Attribut file="" -->
<target name="pack"
depends="compile"
description="packe">
<jar destfile="dist/gepackt.jar"
basedir="build">
<manifest>
<attribute name="Main-class"
value="de.kleuker.XStarter">
</attribute>
</manifest>
</jar>
<echo message="in pack"/>
</target>
• hier wird Manifest-Datei direkt erzeugt, zu nutzende Datei kann
auch angegeben werden
Grundkurs Software-Engineering mit UML
Stephan Kleuker
490
Hilfsmittel: Zeitstempel
• Einfachste Form: Task <tstamp/> , dann nutzbare Variablen:
– DSTAMP: aktuelles Datum, Default-Format yyyymmdd
– TSTAMP: aktuelle Uhrzeit, Default-Format hhmm
– TODAY: aktuelles Datum als String
• konfigurierbar über format-Property
<target name="zeigeZeit">
<tstamp>
<format property="TODAY"
pattern="dd.MMMM.yyyy" locale="de,DE"/>
</tstamp>
<echo message="DSTAMP = ${DSTAMP}"/>
<echo message="TSTAMP = ${TSTAMP}"/>
<echo message="TODAY = ${TODAY}"/>
</target>
[echo] DSTAMP = 20080209
[echo] TSTAMP = 1234
[echo] TODAY = 09.Februar.2008
Grundkurs Software-Engineering mit UML
Stephan Kleuker
491
Umgang mit Files und Dateien
• <mkdir dir="${builddir}"/>
– legt auch fehlende Unterverzeichnisse z. B. bei
/dist/nase/simpel/billig an
– übersprungen, falls Verzeichnis existiert
• <delete dir="${builddir}"/>
• <copy file="src/Hai.java" tofile="back/Hai.java"/>
• <move file="src/Hai.java" tofile="back/Hai.java"/>
• Pattern / Wildcards / reguläre Ausdrücke
– * für beliebig viele Zeichen
– ? für genau ein Zeichen
– ** alle Unterverzeichnisse, z. B. **/*.java
• häufig Property fileset zum Ein- und Ausschließen nutzbar
<copy todir="archive">
<fileset dir="src">
<include name="*.java"/>
</fileset>
</copy>
Grundkurs Software-Engineering mit UML
Stephan Kleuker
492
Aufgaben des Konfigurationsmanagements (1/3)
BuildManagement
ReleaseManagement
Versionsmanagement
Änderungsmanagement
Grundkurs Software-Engineering mit UML
ProzessUnterstützung
Stephan Kleuker
493
Aufgaben des Konfigurationsmanagements (2/3)
• Versionsmanagement
– soll Produkte zu einem definierten Zeitpunkt eindeutig
identifizieren und kennzeichnen
– erstellt damit Gültigkeitsreihenfolge
• Build-Management
– den Build-Prozess vollständig beschreiben
– automatische Abläufe unterstützen
– Reproduzierbarkeit von Softwareintegrationen sicher
stellen
• Release-Management
– Verwaltung von ausgelieferter Software
– Releaseplanung
– Distribution (Erstauslieferung, Ersatz gelieferter SoftwareVersionen)
– Rückruf gelieferter Software
Grundkurs Software-Engineering mit UML
Stephan Kleuker
494
Aufgaben des Konfigurationsmanagements (3/3)
• Änderungsmanagement
– stellt die kontrollierte Änderung von akzeptierten Produkten
sicher
– dazu werden Daten festgehalten über:
• Fehler- und Problemmeldungen
• Änderungsaufträge
• Bearbeitungsstand der Änderungsaufträge
• erforderliche und geleistete Aufwände
• geänderte Produkte
• Prozessunterstützung
– da im KM alle Projekt-Produkte verwaltet werden, muss das
werkzeuggestützte KM die zugehörigen Prozesse
unterstützen
– Erstellung und Änderung von Produkten
– Berücksichtigung von Abhängigkeiten
Grundkurs Software-Engineering mit UML
Stephan Kleuker
495
Voraussetzungen für einen Projektbeginn
12.3
• klare Aufgabenbeschreibung
• Festlegung des Projektleiters
• Klärung, welche technischen und organisatorischen
Randbedingungen berücksichtigt werden müssen
• in studentischen Projekten liegt meist keine
Aufwandsschätzung vor, diese muss durch
Annahmen ersetzt werden
• Übung: Diskutieren Sie typische Vorgaben für
Projekte in Unternehmen, die gemacht werden, aber
nicht unbedingt hilfreich sind
Grundkurs Software-Engineering mit UML
Stephan Kleuker
496
Auswahl des Vorgehensmodells
• Vorgehensweise beeinflusst Planung maßgeblich
– Wasserfall
– prototypische Entwicklung
– iterativ inkrementelles Modell
– agiles Vorgehensmodell
• Planungsaufwand (am Anfang und im Laufe des
Projekts) nimmt von oben nach unten zu
• Vorgehensweise muss zur Aufgabengröße und
Projektmitarbeitern passen
• im folgenden: kurzer inkrementeller Ansatz (leicht
für komplexere Ansätze erweiterbar)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
497
Festlegung der Arbeitspakete
• Zerlegung in sogenannter Work-BreakdownStructure (auch Projektstrukturplan)
• hierarchische Untergliederung
• Ziele: klare Aufgabenpakete, Vermeidung
überflüssiger Schnittstellen
• Berücksichtigung von Querschnittsaufgaben wie
Projektleitung, Qualitätssicherung
• für Aufgabenpakete werden Aufwände kalkuliert (wie
siehe später)
• Später kann WBS weiter verfeinert werden
(Detailaufgaben, Verantwortliche, Beteiligte)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
498
Beispiel für WBS
• PT = Personentage
• Es muss deutlich sein, wo
welches Produkt zugehört
(hier z. B. Dokumentation
querschnittlich bei allen)
P ro je k t
P e rp e tu u m
130 PT
10 PT
P ro je k tle itu n g
80 PT
Q u a litä tss ic h e ru n g
P ro to ty p e n tw ic k lu n g
35 PT
P ro je k tin fra stru k tu r
U se C ase
E n e rg ie v e rb ra u c h
15 PT
Grundkurs Software-Engineering mit UML
10 PT
5 PT
E n tw ic k lu n g
U se C ase
E n e rg ie e rz e u g u n g
35 PT
Stephan Kleuker
N e tz w e rk a n b in d u n g
20 PT
499
Abhängigkeiten von Arbeitspaketen
Es gibt Beziehungen zwischen
Arbeitspaketen:
• typisch: Paket 2 benötigt Ergebnisse
von Paket 1, also muss Paket 1 vorher
fertig werden (Ende-Anfang-Beziehung)
• Anfang-Anfang-Beziehung: Arbeiten
sollen bzw. müssen parallel starten (z.
B. Nutzung gemeinsamer Ressourcen,
wie Testumgebungen)
• Ende-Ende-Beziehung: Arbeiten sollen
möglichst gleichzeitig abgeschlossen
werden (z. B. damit Ergebnisse
integriert werden können)
• (Anfang-Ende-Beziehung, vor dem
Anfang einer Arbeit muss andere Arbeit
abgeschlossen sein, bei
Rückwärtsplanung)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
500
Netzplan und kritische Pfade
• Abhängigkeiten und Aufwände können als Graph dargestellt
werden
P2
Paket
4 6
min.
max.
P1
P5
Dauer Dauer
3 7
5 7
P3
P4
2 5
3 4
• Grundregel 1: Jedes Arbeitspaket enthält einen gewissen
Risikoaufschlag
• Jeder zeitlich mögliche Durchlauf durch den Graphen stellt
möglichen Projektplan dar
• Beispiel P1 P2 P3 P4 P5, minimale Dauer 17, maximale Dauer 29
• Optimierungen berechnen, hier z. B. zuerst P1, dann parallel P2
und P3 starten, nach P3 dann P4, nach P4 und P2 dann P5,
minimale Dauer 13, maximale Dauer 23
• zwischen P2 und P5 maximale Pause von 5
• Man erkennt kritische Pfade (legen Projektdauer fest)
• Grundregel 2: Jedes Arbeitspaket auf dem kritischen Pfad
erhält einen zusätzlichen Risikoaufschlag
Grundkurs Software-Engineering mit UML
Stephan Kleuker
501
Einflüsse der Projektplanung
A b h ä n g ig ke ite n vo n
A rb e itsp a ke te n
R isiko m in im ie ru n g
d u rch Z e itp u ffe r
P ro je k tp la n
V e rfü g b a rke it
vo n M ita rb e ite rn
Grundkurs Software-Engineering mit UML
in d ivid u e lle
R a n d b e d in g u n g e n
(z. B . K u n d e n w ü n sch e ,
A u sb ild u n g e n , M e sse n )
Stephan Kleuker
502
Erster Projektplan (1/2)
M ai 2008
Juni 2008
Juli 2008
P rojekt P erpetuum
M achm ann[30% ]
[30 % ]
> P rojektleitung
P enibel[30% ]
[30 % ]
> Q ualitätssicherung
V ersionm ann[20% ]
[30 % ]
> Infrastruktur
> E ntw icklung
> P rototyp
S chm idt[60% ]
> A nalyse
[100 % ]
S chm idt[80% ]
> D esign
[100 % ]
M eier[80% ]
> C odierung
[100 % ]
> A bnahm e
N etzbert[50% ]
Grundkurs
Software-Engineering
mit UML
> N etzw
erkanbindung
Stephan Kleuker
[70 % ]
503
M eier[80% ]
> C odierung
[100 % ]
Erster
Projektplan (2/2)
> A bnahm e
N etzbert[50% ]
> N etzw erkanbindung
[70 % ]
> U C E nergieverbrauch
M eier[20% ], S chm idt[60% ]
> A nalyse
[30 % ]
M eier[80% ]
> D esign
> C odierung
[0 % ]
M eier[100% ]
[0 % ]
> A bnahm e
> U C E nergieerzeugung
S chm idt[80% ]
> A nalyse
[30 % ]
S chm idt[80% ]
> D esign
[0 % ]
S chm idt[80% ]
> C odierung
[0 % ]
M eier[40% ] S chm idt[80% ]
> Integration
[0 % ]
> E ndabnahm e
Grundkurs Software-Engineering mit UML
Stephan Kleuker
504
Sachstandsanalyse
Ressourcenverbauch
(Abweichung)
zu langsam
Verbrauch ok
-50%
(zu) schnell
(zu) effizient
zu langsam
Verbrauch
nicht ok
Fertigstellungsgrad
(Abweichung)
0
-50%
Desaster!
+50%
(zu) schnell
Verbrauch ok
50%
(zu) schnell
Verbrauch
nicht ok
Grundkurs Software-Engineering mit UML
Stephan Kleuker
505
Meilensteintrendanalyse zur erwarteten Fertigstellung
Grundkurs Software-Engineering mit UML
Stephan Kleuker
506
Burndown-Chart zur erwarteten Fertigstellung (Scrum)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
507
Aufwand oder Kosten ?
12.4
• Aufwand (costing):
–was getan werden muss,
Personenmonate für technische Ausführung,
Verwaltung, Management, Material
• Kosten (prizing):
–wie viel wird vom Kunden verlangt?
–Gewinnmaximierung vs. Ölfleck
Kosten können sich aus politischen Gründen
ändern,
der Aufwand für die gleiche Aufgabe nicht
Grundkurs Software-Engineering mit UML
Stephan Kleuker
508
Warum schätzt man?
• Aufwandsbestimmung am Anfang des Projekts
• Schätzung des verbleibenden Aufwands im laufenden
Projekt
• Gegenseitige Aufwandsschätzung bei
Geschäftspartnern
• Offenlegung der Aufwandsansetzung gegenüber dem
Kunden (Preisfindung)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
509
Zusammenfassung der Function Point Analyse
funktionale Anforderungen
Einflussfaktoren
Schätzung
Schätzung
ungewichtete Function-Points
Projekteinflüsse
Berechnung
gewichtete Function-Points
Ableitung
Aufwand Personenmonate
Grundkurs Software-Engineering mit UML
Stephan Kleuker
510
Function-Point-Methode (1/4) [Bal98]
Jede Anforderung (bzw. ermittelte Funktionalität) in eine der fünf
Kategorien einordnen
• Internal Logical Files (ILF, Datenbestand): Datenbestände, die
innerhalb des zu entwickelnden Systems bearbeitet werden, z.
B. die selbstentwickelten Klassen
• External Interface Files (EIF, Referenzdaten): Datenbestände
die von außerhalb des zu entwickelnden Systems kommen und
bearbeitet werden
• External Inputs (EI, Eingabe): Eingaben von außerhalb in das
zu entwickelnde System mit denen der Datenbestand
verändert wird, z. B. über Eingabemasken, Dateien in
bestimmten Eingabeformaten, Eingaben von externen
Systemen
• External Outputs (EO, Ausgabe): Ausgaben an außerhalb des
zu entwickelnden System liegende Komponente, z. B.
Ausgabemasken, Dateien in bestimmten Ausgabeformaten;
Ausgaben weden aus vorhandenen Daten berechnet
• External Inqueries (EQ, Abfrage): Abfragen von Informationen
des Datenbestands von außerhalb des Systems, z. B.
Abfragemasken, reines Anzeigen der verwalteten Daten
Grundkurs Software-Engineering mit UML
Stephan Kleuker
511
Function-Point-Methode (2/4)
Kategorie
Eingabedaten
Abfragen
Ausgaben
Datenbestände
Referenzdaten
Anzahl
Klassifizierung
Gewichtung
Zeilensumme
6
einfach
*3
18
4
mittel
*4
16
komplex
*6
einfach
*3
mittel
*4
komplex
*6
6
einfach
*4
24
9
mittel
*5
45
komplex
*7
einfach
*7
mittel
* 10
komplex
* 15
einfach
*5
mittel
*7
komplex
* 10
4
7
Summe ungewichteten Function-Points
Grundkurs Software-Engineering mit UML
12
49
164
Stephan Kleuker
512
Function-Point-Methode (3/4)
Summe unbewertete Function-Points
164
Verflechtung mit anderen
Anwendungssystemen (0-5)
1
Dezentrale Daten,
dezentrale Verarbeitung (0-5)
2
Transaktionsrate (0-5)
2
Verarbeitungslogik
Rechenoperationen (0-10)
1
Kontrollverfahren (0-5)
3
Ausnahmeregelungen (0-10)
0
Logik (0-5)
2
Wiederverwendbarkeit (0-5)
3
Datenbestandskonvertierungen (0-5)
2
Anpassbarkeit (0-5)
1
Summe der Einflussfaktoren (EF)
Faktor Einflussbewertung (FE) =
17
EF / 100 + 0,7
0,87
Gewichtete Function-Points = ungewichtete Functionpoints *FE
143
Grundkurs Software-Engineering mit UML
Stephan Kleuker
513
Function-Point-Methode (4/4)
1000
P ersonen m onate
X
X
X
X
X
X
o
X
o
o
X
X
X
U nternehm en 1
U nternehm en 2
o
X
X
0
0
Grundkurs Software-Engineering mit UML
Function P oints
Stephan Kleuker
5000
514
Fazit zur Function-Point Analyse
• Wissenschaftlich fundiert
• Schätzdetails nur von speziellen Schätzexperten beurteilbar
• firmenspezifische und methodenspezifische Optimierung
schwierig
• Wenn FPA eingesetzt werden soll, muss sie (evtl. rückwirkend)
für verschiedene Projekte evaluiert werden
• sinnvoll, wenn eigene Schätzabteilung zur Betreuung aller
Schätzungen aufgebaut wird
• wesentlich höherer Aufwand als später vorgestellte vereinfachte
Analogieschätzung, Schätzer fühlen sich nicht für
Schätzergebnis verantwortlich
Grundkurs Software-Engineering mit UML
Stephan Kleuker
515
Von CoCoMo81 zu CoCoMo II
Kostenschätzverfahren von Barry W. Boehm (ab 1981)
• Die Art der SW-Entwicklung hat sich in den Jahren wesentlich
verändert (Methodik)
• Die Programmiersprachen haben sich verändert (Aufkommen
von OO-Sprachen)
• Man kann weitere Einflussfaktoren auf den Aufwand feststellen
• Es ist interessant, eine Schätzung zu verschiedenen
Zeitpunkten des Projektfortschritts durchzuführen
• Mittlerweile viele Varianten für verschiedene Vorgehensmodelle
und Projektarten
-> führt zur Verbesserung von CoCoMo 81
Literatur: B. W. Boehm, C. Abts, A. W. Brown, Software Cost
Estimation with Cocomo II, Prentice Hall PTR, 2000
http://sunset.usc.edu/csse/research/COCOMOII/cocomo_main.html
Grundkurs Software-Engineering mit UML
Stephan Kleuker
516
CoCoMo II – zentrale Formel
• Personenmonat wird mit 152h gerechnet
• EM sind die einzelnen Kostentreiber
• für Early Design : n=7
• für Post Architecture: n=17
• A ist Produktionskonstante, kann für verschiedene IT-Sektoren
unterschiedlich sein (Default 2.45 in 1999)
• Size bezieht sich wieder auf KDSI (Kilo Lines of Documented
Source Instrctions)
• Hinweis: Alle Default-Werte von CoCoMo basieren auf einer
größeren Anzahl (>60) von Projekten
Grundkurs Software-Engineering mit UML
Stephan Kleuker
517
Variable E
• B hat Standardwert 0.91 (1999)
• Dazu kommen fünf Scaling Factors:
Sehr
gering
Geschäftstätigkeit im
PREC
Produktbereich
Entwicklungsfreiräume
FLEX
Ausgereiftheit des
RESL
Produktentwurfs
Einvernehmen zwischen
TEAM
Stakeholdern
Software-Prozessreife (nach
SEI-CMM[I])
PMAT
Grundkurs Software-Engineering mit UML
Gering
Normal
Hoch
Sehr
hoch
Extra
hoch
6.20
4.96
3.72
2.48
1.24
0
5.07
4.05
3.04
2.03
1.01
0
7.07
5.65
4.24
2.83
1.41
0
5.48
4.38
3.29
2.19
1.10
0
7.80
6.24
4.68
3.12
1.56
0
Stephan Kleuker
518
Kostentreiber EM (Early Design)
Einflussfaktor
Extra Sehr Gegering gering ring
Produktzuverlässigkeit
0.73
und -Komplexität
0.81
Normal
Hoch
Sehr Extra
hoch hoch
0.98 1
1.30 1.74 2.38
Angestrebte
Wiederverwendbarkeit
0.95 1
1.07 1.15 1.24
Zielplattformbesonder
heiten
0.87 1
1.29 1.81 2.61
Personalfähigkeit
2.12
1.62
1.26 1
0.83 0.63 0.50
Personalerfahrung
1.59
1.33
1.12 1
0.87 0.71 0.62
Qualität der Entwicklungsbedingungen
1.43
1.30
1.10 1
0.87 0.73 0.62
1.43
1.14 1
1
Entwicklungszeitrahmen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
1
519
CoCoMo im Überblick
Abschätzung der
Systemgröße (KDSI)
Produkt-, Prozess-, Plattformund Personal-Attribute
Wiederverwertbarkeits- und
Wartbarkeitsparameter
CoCoMo II
Abschätzung für
Entwicklungsund Wartungskosten
für verschiedene
Entwicklungsphasen
Daten bereits
abgeschlossener Projekte
Iterative
Aktualisierung
Kalibrierung auf eigene
Organisation
Grundkurs Software-Engineering mit UML
Stephan Kleuker
520
Vereinfachter Analogieschluss
Forderungen an das Schätzverfahren
• Erfahrungen aus anderen Projekten müssen
einfließen können
• Verfahren muss für alle Schätzbeteiligten
verständlich sein
• Einzelne Schätzfaktoren müssen verständlich sein
• Schätzfaktoren müssen an Projekteigenheiten
anpassbar sein
• Schätzergebnisse müssen an neue Projektsituationen
anpassbar sein
• Schätzergebnis muss dokumentierbar
(nachvollziehbar) sein
• Einbettung in weitere Geschäftsprozesse
Grundkurs Software-Engineering mit UML
Stephan Kleuker
521
Vorbereitung der Schätzung
Grundkurs Software-Engineering mit UML
O ptionseinstellungen
G raphikeinbindung
A nsichtenerstellung
2. vergleichbares
Projekt liegt mit
Aufwandsdaten und
vergleichbarer
Komponentenstruktur
vor
N utzer-Interface
T extbearbeitung
1. Projekt in
dokumentierte
Komponenten /SWEinheiten / Use Cases
zerlegt
B asisdienste
Stephan Kleuker
522
Umgang mit „Projektumfeldkosten“
• HW wird getrennt betrachtet
• Projektmanagement (PM), Qualitätsmanagement und
Konfigurationsmanagement wird analog zum
Vergleichsprojekt (Normierungsprojekt) behandelt
Wünschenswert: genannte Managementkosten in
Komponenten des Normierungsprojekts eingerechnet
Wenn nicht möglich: Aufwände aus bekannten
Aufwänden des Normierungsprojekts extrapolieren
Beispiel: Entwicklungsaufwand 100 PT
(Personentage), für PM 15 PT, dann später 15% für
PM auf berechneten Wert aufschlagen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
523
Aufbau des Schätzansatzes
Vorbereitung der Schätzung
Durchführung der Schätzung
Analogieschluss
Grundkurs Software-Engineering mit UML
Stephan Kleuker
524
Analogie-Schätzung (1/3): Vorbereitung
1. Festlegung der Schätzparameter
A: Wiederverwendung [1-3] (vollständig bis neu)
B: Funktionsumfang [1-8] (einfach bis hoch komplex)
C: Abhängigkeiten
[1-3] (gering bis stark)
D: Kritikalität
[1-2] (niedrig, mittel, hoch)
K-Faktor= A*B*C*D
2. gemeinsame Skalierung der Parameter durch Schätzer
(„B=4 heisst ...“)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
525
Schätzparameter- zwischen Erfahrung und Voodoo
Generell gilt: gezeigte Schätzparameter sind
Vorgabe, die sich häufig als sinnvoll herausgestellt
hat
Aber: Anpassungen der Wertebereiche und der
Anzahl der Schätzparameter erlaubt
Ansatz: mit Standardparametern anfangen, bei
unrealistischem Ergebnis modifizieren,
Änderungen dokumentieren
Grundkurs Software-Engineering mit UML
Stephan Kleuker
526
A: Wiederverwendung
1
1,3
1,6
1,9
3
Komponente besteht rein aus der Wiederverwendung
bereits existierender Ergebnisse, die nur neu
zusammengesetzt werden müssen
Hoher Grad der Wiederverwendung, es müssen nur
Anpassungen an relativ leicht zu identifizierenden Stellen
vorgenommen werden
Hoher Grad der Wiederverwendung, neben kleinen
Anpassungen müssen einige eigenständige Erweiterungen
vorgenommen werden, aus der vorliegenden
Dokumentation wird deutlich, wo Neuentwicklungen
eingebunden werden sollen
Einige Teile können wiederverwendet werden,
grundlegende Designideen sind übernehmbar
Neuentwicklung, bzw. alle existierenden Ergebnisse
müssen intensiv überprüft werden
Hinweis: Wiederverwendung kann sich auf selbst erstellte Software,
Freeware oder gekaufte SW beziehen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
527
B: Funktionalität
1-8
es muss festgehalten werden, wie groß der maximale
Unterschied in der Größe der Komponenten sein
kann, für einen oder mehrere Werte sollen konkrete
Beispielfunktionalitäten (Teilkomponenten) genannt
werden, es werden nur neue und zu modifizierende
Funktionalitäten betrachtet
1- sehr einfach
8 - hochkomplex
Hinweis: Funktionalität bezieht sich nur auf die
Komplexität der neu zu erstellenden SW (also B=0,
wenn nichts gemacht werden muss)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
528
C: Schnittstellen
1
keine oder geringe Abhängigkeiten von anderen
Komponenten
2
Kommunikationsaufwand mit verschiedenen
Komponenten
3
hoher Kommunikationsaufwand mit anderen
Komponenten, starke Abhängigkeit von anderen
Komponenten
Hinweis: Der C-Wert steigt, wenn es um Schnittstellen
über Firmengrenzen hinweg oder um Schnittstellen
noch zu entwickelnder Systeme geht
Grundkurs Software-Engineering mit UML
Stephan Kleuker
529
D: Kritikalität
1
niedrige Kritikalität
Projekt scheitert nicht, wenn Komponente
kleinere/ mittlere Fehler enthält
1,5
mittlere Kritikalität
Funktionalität und Kundenzufriedenheit wird bei
Fehlern eingeschränkt, System bleibt nutzbar
2
hohe Kritikalität
Projekt scheitert, wenn nur kleinere oder mittlere
Fehler in dieser Komponente sind
Hinweis: Kritikalität ist hier zunächst nach V-Modell
gegeben, Übersetzung für andere Modelle:
Projektrisiko, wenn Komponente nicht vollständig
oder „wie gewünscht“ funktioniert (-> Testaufwand)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
530
Skalierung der Schätzparameter
Alle Schätzer setzen sich an einen Tisch,
wählen eine Beispielkomponente, die jeder gut
verstanden hat
und legen beispielhaft Werte für A,B,C,D fest.
Achtung! Der resultierende Wert A*B*C*D hat zunächst
keine Bedeutung.
Technisches Ziel: Vermeidung, dass später zu häufig
B=1 auftritt
Gesamtziel: „Gleichschaltung“der Köpfe bzgl.
Parameterwerte
Grundkurs Software-Engineering mit UML
Stephan Kleuker
531
Analogie-Schätzung: Durchführung
1. Gemeinsame Schätzung einer
neuen Beispielteilaufgabe (evtl.
mehrere)
Teilaufgabe A
Neu1
B C D ABCD
1.9 5 2 2
38
2. Individuelle Schätzung mit
Konsolidierung durch
Schätzkonferenz
Teilaufgabe A
B C D
ABCD
Neu1
1.9 5 2 2
Neu2
3
4 2 1.5 32
Neu3
3
6 1 1.5 27
Neu4
3
2 3 2
36
Neu5
1.6 5 2 1
16
Grundkurs Software-Engineering mit UML
38
3. Individuelle Schätzung des
Altprojekts (Aufwand in Personentagen, PT, bekannt), mit Konsolidierung durch Schätzkonferenz
Teilaufgabe PT A
B C
D ABCD
Alt1
188 3
5 2
2
60
Alt2
62 1.9 5 2
1
19
Alt3
149 3
6 1.5 2
54
Alt4
54 3
2 3
18
Summe 453
1
151
4. Berechnung des Wertes eines
Aufwandspunktes 453/151 = 3
Stephan Kleuker
532
Analogie-Schätzung: Analogieschluss
5. Bestimmung des Aufwandes in PT des neuen
Projekts mit Analogieschluss
Teilaufgabe A
B
Neu1
1.9 5
Neu2
3
4
C
2
2
D
ABCD
2
38
1.5 32
Aufwand
114
96
Neu3
Neu4
Neu5
1
3
2
1.5 27
2
36
1
16
81
108
48
3
6
3
2
1.6 5
Grundkurs Software-Engineering mit UML
Stephan Kleuker
533
Kommentare zum Schätzverfahren
• Schätzendergebnis wird von allen Schätzern begutachtet, wenn
nicht plausibel, dann Parameter modifizieren
Beispiel: C=1,2,3 zu weit, Ansatz C=2, 2.5, 3
• Die Qualität steigt, wenn jeder Schätzer jede Komponente
schätzen kann, dies ist in der Realität meist nicht möglich
• Zur Normierung der Schätzer im Schritt 2 ist auch Komponente
des Vergleichsobjekts wählbar
• Vergleichsprojekt können Teilkomponenten aus einem
größeren System sein
• Der Begriff der mathematischen Unabhängigkeit (insbesondere
zwischen Funktionalität und Schnittstellen, sowie
Funktionalität und Kritikalität) muss den Schätzern klar sein
• Ergänzung um Vergleich der Projektrisiken der beiden Projekte
sinnvoll (Skalierungsfaktor), nächste Folie; falls große
Abweichung von Null Skalierungsprojekt evtl. nicht geeignet
Grundkurs Software-Engineering mit UML
Stephan Kleuker
534
Logische und psychologische Zahlen
• Diskussionspunkte sind häufig die Wertebereiche der einzelnen
Schätzfaktoren, dabei ist das Verständnis wichtig, dass von
C=1 zu C=1.5 der Aufwand um 50% steigt
• Der Wertebereich bei der Funktionalität wurde aus
„psychologischen Gründen“ sehr hoch angesetzt, da hier meist
der größte Klärungsbedarf im Verständnis besteht
• Man beachte: wird ein Wertebereich z.B. bei C von [1…3] auf
[1…9] erweitert und wird dann statt C=2 mit C=6 gerechnet,
ändert sich am Schätzwert nichts
AufwandN = AN*BN*CN*DN*(AufwandA/ (AA*BA*CA*DA))
= AN*BN*CN*3*DN*(AufwandA/ (AA*BA*CA*3*DA))
N = neu, A= alt
Grundkurs Software-Engineering mit UML
Stephan Kleuker
535
Variante Planning Poker
1
2
3
5
8
13
21
34
55
89
?
∞
• statt Schätzung von ABCD wird nur mit einer jeweils
verdeckt aufgelegten Karte geschätzt
• ? = keine Ahnung, ∞ = gibt zu wenig Informationen
• höchster und niedrigster Wert werden diskutiert
• solange wiederholen, bis konsolidiert
• wieder Analogieschluss mit vorherigen Projekten
oder bei Sprints mit vorherigen Sprints
Grundkurs Software-Engineering mit UML
Stephan Kleuker
536
Teufelsquadrat für IT-Projekte nach Sneed
12.5
Qualität
Funktionalität
Kosten
Zeit
• Konzentration auf ein Ziel erzwingt bei gleichen
Rahmenbedingungen Vernachlässigung mindestens eines
anderen Ziels (Verbesserung im Bild bedeutet ziehen des
Schwerpunkts in diese Richtung)
• generelle Verbesserung nur durch Verbesserung der
Rahmenbedingungen (z.B. der Prozesse)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
537
Definition Qualitätsmanagement (eine Variante)
Definition:
Umfasst »alle Tätigkeiten der Gesamtführungsaufgabe, welche
die Qualitätspolitik, Ziele und Verantwortungen festlegen sowie
diese durch Mittel wie Qualitätsplanung, Qualitätslenkung,
Qualitätssicherung und Qualitätsverbesserung im Rahmen des
Qualitätsmanagementsystems verwirklichen« (DlN EN ISO
8402).
Unterscheidung in:
• Produktorientiertes Qualitätsmanagement
(Produkt und Zwischenergebnisse auf festgelegte
Gütemerkmale prüfen)
• Prozessorientiertes Qualitätsmanagement
(Alle Mitarbeiter müssen ein Qualitätsbewusstsein entwickeln
permanente Adaptierung)
Grundkurs Software-Engineering mit UML
Stephan Kleuker
538
Zusammenhang der Q-Begriffe
Qualitätsmanagement
(Qualität aller Prozesse)
Prozess X
Prozess Y
Software-Entwicklungsprozess
Qualitätssicherung
konstruktiv
Grundkurs Software-Engineering mit UML
analytisch
Stephan Kleuker
539
Prozesse als Firmenqualitätsmaßstab: CMM[I]
• ursprünglich Capability Maturity Model (CMM)
• Auftrag durch das DoD
• Hilfsmittel zur Beurteilung der Leistungsfähigkeit von
Softwarelieferanten
• Reifegrad der Software-Entwicklungs5 Optimizing
prozesse ermitteln
• gezielte Prozessverbesserung
4 Quantitatively Managed
• CMM(I) definiert 5 Stufen der
Managed (CMM)
Reife einer Organisation
3 Defined
• aktuell: CMMI for
Development,
2 Managed
Version 1.2
Repeatable (CMM)
(CMMI-DEV)
1 Initial
Grundkurs Software-Engineering mit UML
Stephan Kleuker
540
Stufe 1: Initial
• Merkmal: Keine stabile Umgebung, ad-hoc
Durchführung
• Fokus: gute Mitarbeiter
• Unvorhersagbares Ergebnis: bei erneuter
Durchführung des Projektes würde alles ganz anders
laufen
• Brandbekämpfung statt Planung, Planabweichung in
Krisensituationen
• Gelingen des Projektes nur durch äußersten Einsatz
aller Beteiligter, hängt an Einzelpersonen
• Risikobehaftet, unplanbar und ineffizient
Grundkurs Software-Engineering mit UML
Stephan Kleuker
541
Stufe 2: Nachvollziehbar (managed)
• Merkmal: Gleiche Anforderungen ergeben gleiche
Resultate
• Fokus: Projektmanagement
– Richtlinien für Software-Projektmanagement
existieren und werden umgesetzt
– Überwachung von Zeit, Kosten, Produktqualität
• Basierend auf früheren Projekten
• Softwarestandards, Konfigurationsmanagement
• Stabiler Prozess
Grundkurs Software-Engineering mit UML
Stephan Kleuker
542
Stufe 3: Definiert (defined)
• Merkmal: Wohldokumentierte Prozesse
• Fokus: Organisationsunterstützung
– Stabile und wiederholbare SW-Entwicklungs- und
SW-Projektmanagement-Prozesse
– Abnahmekriterien, Standards, QS-Maßnahmen
definiert und dokumentiert
– Möglichkeit der Anpassung von Standards
• Rolle des Softwareprozess-Verantwortlichen
• Weiterbildungsmaßnahmen eingeplant
• Regelmäßige Expertenbegutachtung
Grundkurs Software-Engineering mit UML
Stephan Kleuker
543
Stufe 4: Beherrscht (quantatively managed)
• Merkmal: Quantitativ messbare Prozesse
• Fokus: Produkt- und Prozessqualität
– Leistungsmessung von Produktivität und Qualität
– Metriken für Software
• Messbare, vorhersagbare Prozesse in definierten
Grenzen
• Messbare, vorhersagbare Produktqualität
• Steuerungsmöglichkeit bei Schwankungen
Grundkurs Software-Engineering mit UML
Stephan Kleuker
544
Stufe 5: Optimierend (optimizing)
• Merkmal: Gesamte Organisation fokussiert auf
kontinuierliche Prozessverbesserung
• Fokus: Ständige Evaluation und Einführung neuer
Technologien und Verbesserungsmöglichkeiten
– Möglichkeit zur Stärken/Schwächenanalyse
– Proaktive Fehlervermeidung
– Dauernde Implementierungsmöglichkeit für
Verbesserungen der Softwareprozesse (direkte
Einbringung von Verbesserungsvorschlägen)
• Verbesserungen auf der Meta-Ebene
Grundkurs Software-Engineering mit UML
Stephan Kleuker
545
Überblick: Verbesserungen mit dem CMMI
S tu fe 5
O p tim iz in g
S ta rt
Ende
S ta rt
Ende
S tu fe 3
D e fin e d
S ta rt
Ende
S tu fe 2
M anaged
S ta rt
S tu fe 1
In itia l
S ta rt
S tu fe 4
Q u a n tita tiv e ly
M anaged
Grundkurs Software-Engineering mit UML
A n a ly s e
E n tw ic k lu n g
B e a rb e itu n g
Stephan Kleuker
Test
Ende
Ende
546
Skizze einer CMMI-Anpassung
alter
Firmenstandard
SP 1.1
des CMMI
Grundkurs Software-Engineering mit UML
nach CMMIÜberarbeitung
fehlen: Produkte,
Verantwortlichkeiten
Stephan Kleuker
547
Personal Software Process (PSP)
• CMMI gibt Rahmen für Unternehmensprozesse; nicht einfach
auf Individuum herunterbrechbar
• Ansatz: Entwickler durchlaufen Qualitätsentwicklung z. B.
durch Schulungen; Ansatz des PSP
in Programmierung ausgebildete Entwickler
definierten Prozess nutzen
Zeit erfassen
PSP 0
Defekte erfassen und analysieren
PSP 1
Arbeiten planen
Aufwände schätzen, Zeitpläne erstellen
Optimierungen analysieren
PSP 2
Qualitätsmanagement
Erstellung von Qualitätsplänen
Messung eigener Qualität
Entwickler mit garantierter Qualität und Schätzfähigkeit
Grundkurs Software-Engineering mit UML
Stephan Kleuker
548
Ganzheitliche Projektsicht
12.6
Arbeitsumfeld [schwarz]
Fähigkeiten (Know how) [blau]
soziale Ebene
[rot]
Grundkurs Software-Engineering mit UML
Prozessebene
[grün]
Stephan Kleuker
549
Ebenen des ganzheitlichen Projektmanagements
• Fähigkeiten: was können Projektmitglieder, welche
Erfahrungen haben sie
• Prozessebene: wie sind Arbeitsprozesse organisiert, sind
Rollen klar abgegrenzt
• Arbeitsumfeld: welche Werkzeuge gibt es, wie sind
Arbeitsplätze organisiert
• soziale Ebene: wer kann wie mit wem
Grundregel: Probleme der einen Ebene können nicht auf der
anderen Ebene gelöst werden
• wenn Leute nicht miteinander können, helfen
Prozessregelungen wenig
• fähige Mitarbeiter werden durch schlechte Werkzeuge, große
räumliche Trennung, unsaubere Toiletten ausgebremst
• neue Werkzeuge benötigen Schulungen und Einarbeitung
Grundkurs Software-Engineering mit UML
Stephan Kleuker
550
Teamrollen
• Es gibt einige psychologische Ansätze Menschen in ihrem
Verhalten zu kategorisieren
• Grobe Beschreiben, wie „eher extrovertiert“ oder „introvertiert“
sind möglich
• Es gibt Typen die typischerweise gut miteinander können und
andere, die zu Konflikten führen
• Selten, dass Menschen sehr gute Techniker und sehr gute
Verkäufer sind
• Für erfolgreiche Projekte werden unterschiedliche Typen
benötigt
• „zu einem Typ gehörig“ ist weder negativ noch positiv; Teams
müssen harmonisch zusammengesetzt werden
• vorgestellter Ansatz beruht auf Meredeth Belbin
• Achtung: Das Einteilen von Menschen in Typen mit bestimmten
Verhaltensweisen ist aus gutem Grund von vielen Seiten
angreifbar
Grundkurs Software-Engineering mit UML
Stephan Kleuker
551
Teamrollentypen nach Belbin (1/3)
• Specialist
– Experten, können sich neue Techniken erarbeiten, Stolz auf
eigene Fähigkeiten
– wenig Interesse an Anderen
• Completer Finisher
– sorgfältig bis ins Detail, beginnen nur Sachen, die sie
beenden können, arbeiten stark aus eigenem Antrieb
– delegieren ungern, undiplomatisch gegenüber Generalisten
• Implementer
– gute Pragmatiker (was ist wichtig und machbar),
systematisch im Umgang mit komplexen Aufgaben, loyal
zum Unternehmen, eher introvertiert, integer
– nicht spontan, steht sehr kreativen Ideen ablehnend
gegenüber
Grundkurs Software-Engineering mit UML
Stephan Kleuker
552
Teamrollentypen nach Belbin (2/3)
• Teamworker (ausgeglichen, extrovertiert, kaum dominant)
– guter Zuhörer, kommuniziert frei mit allen im Team, passt
sich neuen Situationen schnell an
– geht Konfrontationen aus dem Weg, überfordert mit
zentralen Entscheidungen
• Monitor Evaluator
– ausgeglichen, ernsthafter klarer Blick für die aktuelle
Situation, meist hohe Intelligenz, hohe Kreativität, entdeckt
schnell Fehler
– braucht lange für Entschlüsse, manchmal taktlos und
herabsetzend in Analysen, zu kritisch
• Shaper
– hoch motiviert, leitet und koordiniert Teams gerne, findet
Wege um Probleme, extrovertiert, besorgt, ob gewünschter
Fortschritt erreicht wird
– impulsiv, ungeduldig, manchmal leicht reizbar, gibt
vielleicht zu schnell auf
Grundkurs Software-Engineering mit UML
Stephan Kleuker
553
Teamrollentypen nach Belbin (3/3)
• Co-ordinator
– stabil, dominant, extrovertiert, diszipliniert, führt Team,
bemüht, externe Ziele und Vorgaben zu erreichen, guter
Kommunikator, gut in der Besetzung von Projektrollen
– eher kein kreativer Denker, geht (zu) ruhig an Aufgaben
heran
• Resource Investigator
– locker, kommunikativ, leicht zu interessieren, bringt Ideen
von Außen, Diplomat, Verkäufer, viele Außenkontakte
– neigt zu zu großem Enthusiasmus, lässt Sachen schnell
fallen, benötigt Anregungen von Außen
• Plant
– Quelle von originellen Ideen, Anregungen und Vorschlägen,
dominierend, meist hohe Intelligenz, konzentriert auf
Hauptaufgaben
– introvertiert, kann störend oder kränkend wirken, kein
Detailinteresse, wenig kritikfähig
Grundkurs Software-Engineering mit UML
Stephan Kleuker
554
Ermittlung des Teamrollentypen
• Möglichkeit mit Fragebogen, möglich zur Selbstbewertung und
Fremdbewertung
• Beispiel: Verteilen Sie 10 Punkte auf die folgenden Aussagen,
die auf Sie am Besten zutreffen (Häufung von Punkten auf
wenigen Aussagen gewünscht)
Wie verhalte ich mich, wenn ich mit anderen Leuten an einem
Projekt beteiligt bin:
– Ich besitze die Gabe jemanden zu beeinflussen, ohne ihn
unter Druck zu setzen
– Meine ständige Wachsamkeit verhindert Leichtsinnsfehler
und Versäumnisse
– Man kann sich darauf verlassen, dass ich originelle Ideen
habe
– Ich bin immer bereit, gute Vorschläge zu unterstützen, wenn
sie im allgemeinen Interesse sind
– Ich bin immer begierig, die allerneusten Ideen und
Entwicklungen zu entdecken
– ...
Grundkurs Software-Engineering mit UML
Stephan Kleuker
555
Kommunikation
• Paul Watzlawik: „Man kann nicht nicht kommunizieren“
• Versuch, eine gemeinsame Informationsbasis zu finden
• abhängig vom gemeinsamen Verständnis
Decodierung
Feedback
Codierung
Sender
Empfänger
Codierung
Nachricht
Decodierung
• wichtig: Hintergründe, was passiert wann bei wem wohl warum,
der Kommunikation erkennen
• Achtung! Überinterpretationen
• Kommunikationsverhalten kann/soll geschult werden, wobei
Authentizität erhalten bleiben muss
Grundkurs Software-Engineering mit UML
Stephan Kleuker
556
vierfache Gestalt einer Äußerung (1/4) [SRS03]
• Jeder Äußerung kann man vier Ebenen zuordnen
• Beispiel: Prof zum Studi, „Die Klasse sollten Sie endlich mal
kommentieren“
• Jede Äußerung enthält die vier genannten Botschaften
• für jede Botschaft kann es eine Interpretation des Senders und
des Empfängers geben
• bei mehreren Anwesenden vervielfacht sich die Interpretation
Grundkurs Software-Engineering mit UML
Stephan Kleuker
557
vierfache Gestalt einer Äußerung (2/4)
• Sachinhalt (worüber ich informiere)
– Beispiel: Klassen sind zu kommentieren
– kann aus Wahrheitsgehalt geprüft werden
– kann auf Relevanz geprüft werden
– kann auf Hinlänglichkeit geprüft werden (reicht Information
aus, verstehen beide das Gleiche)
– meist zentraler Bestandteil der Äußerung
• Selbstkundgabe (was ich von mir zu erkennen gebe)
– Beispiel: Prof ist verunsichert, ob zentrale Wünsche ernst
genommen werden, Studi meint, dass Prof schlechte Laune
hat
– was geht in mir vor, wofür stehe ich, wie sehe ich meine
Rolle
– individuelle Schnabelform: Selbstdarstellung, Authentizität
Grundkurs Software-Engineering mit UML
Stephan Kleuker
558
vierfache Gestalt einer Äußerung (3/4)
• Beziehung (was ich von dir halte und wie ich zu dir stehe)
– Beispiel: Prof glaubt, dass Studi Potenzial hat, seine
Schludrigkeit ihn aber von besseren Ergebnissen abhält,
Studi meint, dass Prof ihn für unfähig hält, selbst einfachste
Aufgaben zu lösen
– geprägt durch Tonfall, Formulierung und Kontext der
Äußerung
– meist ein sehr sensibles Ohr
– Beziehungsebene muss stabil sein, da sonst hier viele
unterschwellige Konflikte möglich
• wenn nicht: Uneinigkeit auf der Sachebene führt zu
Störung der Beziehungsebene
Grundkurs Software-Engineering mit UML
Stephan Kleuker
559
vierfache Gestalt einer Äußerung (4/4)
• Appell (was ich bei dir erreichen möchte)
• Beispiel: Prof möchte, dass der Studi systematischer arbeitet,
Studi (miss)-interpretiert, mach erstmal einfache Aufgaben
bevor du programmierst
• bei längeren Äußerungen kann der konkrete Appell verloren
gehen
• wenig erfolgreich, aber verbreitet: Appell mit negativer
Beziehungsbotschaft zu verknüpfen „können Sie endlich mal
...“
Literatur
• [SRS03] F. Schulz von Thun, J. Ruppel, R. Stratmann,
Miteinander Reden: Kommunikationspsychologie für
Führungskräfte, 2. Auflage, Rowohlt, Reinbek, 2003
Grundkurs Software-Engineering mit UML
Stephan Kleuker
560
Teufelskreis „Führung“ [SRS03]
• Kommunikationsproblem: „Verstärkung der
Ansichten und negativen Empfindungen“
Führungskräfte
machen:
planen ihre Entscheidungen
am „grünen Tisch“, tun seltene
Kritik ab „höre ich selten,
andere schaffen es auch“
fühlen:
Bestätigung,
dass der Kurs
stimmt
fühlen:
Druck, Angst
vor Positionsverlust
machen:
schweigen, dulden, antworten,
auf Nachfragen „Läuft alles
soweit gut“
Grundkurs Software-Engineering mit UML
Stephan Kleuker
Mitarbeiter
561
Metakommunikation
• Denken über Kreise, statt handeln in den Rechtecken
• Kommunikation über den Nachrichtenfluss
• Ausgangspunkt: Beschreibung des eigenen Fühlens und der
Wahrnehmung des Anderen
• persönliches Gespräch
• fördert offene Kommunikation
• Metakommunikation ist ein scharfes Schwert, dass mit Bedacht
eingesetzt werden muss
• Übungsaufgabe: Überlegen Sie Kommunikationsteufelskreise
in Ihrem momentanen Leben und ob Metakommunikation
helfen könnte
Grundkurs Software-Engineering mit UML
Stephan Kleuker
562
Descargar

Folie 1 - home.edvsz.hs