Implementierung hydrated
This commit is contained in:
parent
0469d41760
commit
cd79c0f4bd
Binary file not shown.
@ -914,17 +914,17 @@
|
|||||||
|
|
||||||
Objektorientierter Feinentwurf
|
Objektorientierter Feinentwurf
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Grobdefinition der Architektur, Zerlegung in Subsysteme (evtl. unter Verwendung von Standardarchitekturen)
|
\item Grobdefinition der Architektur, Zerlegung in Subsysteme (evtl. unter Verwendung von Standardarchitekturen)
|
||||||
\item OO-Modell für jedes Subsystem der Architektur
|
\item OO-Modell für jedes Subsystem der Architektur
|
||||||
\item OO-Modell für unterstützende Subsysteme unter Berücksichtigung gewählter Technologien
|
\item OO-Modell für unterstützende Subsysteme unter Berücksichtigung gewählter Technologien
|
||||||
\item Spezifikationen der Klassen
|
\item Spezifikationen der Klassen
|
||||||
\item Spezifikationen von externen Schnittstellen
|
\item Spezifikationen von externen Schnittstellen
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
\subsection{Klassen- und Objektentwurf}
|
\subsection{Klassen- und Objektentwurf}
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Klassen der Lösungsdomäne
|
\item Klassen der Lösungsdomäne
|
||||||
\item Klassen, die nicht durch objektorientierte Analyse der Anwendungsdomäne entstehen
|
\item Klassen, die nicht durch objektorientierte Analyse der Anwendungsdomäne entstehen
|
||||||
\item Entstehungsgründe
|
\item Entstehungsgründe
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Architektur von Software und System
|
\item Architektur von Software und System
|
||||||
@ -1002,7 +1002,7 @@
|
|||||||
\item Polymorphie
|
\item Polymorphie
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Reaktion auf eine Nachricht abhängig vom Typ des Objektes
|
\item Reaktion auf eine Nachricht abhängig vom Typ des Objektes
|
||||||
\item Variablen können Objekte verschiedener Klassen aufnehmen
|
\item Variablen können Objekte verschiedener Klassen aufnehmen
|
||||||
\item Überladen von Operationen
|
\item Überladen von Operationen
|
||||||
\item gleicher Operationsname, unterschiedliche Signatur
|
\item gleicher Operationsname, unterschiedliche Signatur
|
||||||
\item abstrakte Operationen: Virtuelle Operationen ohne Implementierung
|
\item abstrakte Operationen: Virtuelle Operationen ohne Implementierung
|
||||||
@ -1160,7 +1160,7 @@
|
|||||||
\item Ohne Sicht auf innere Implementierung
|
\item Ohne Sicht auf innere Implementierung
|
||||||
\item Protokoll = Kollaboration von Protokollrollen
|
\item Protokoll = Kollaboration von Protokollrollen
|
||||||
\item Modell: Zustandsautomat
|
\item Modell: Zustandsautomat
|
||||||
\item Beschreibung der Synchronisation von Objekten
|
\item Beschreibung der Synchronisation von Objekten
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
\subsection{Entwurfsmuster}
|
\subsection{Entwurfsmuster}
|
||||||
@ -1240,7 +1240,7 @@
|
|||||||
\item Numerische Routinen, Simulation, ...
|
\item Numerische Routinen, Simulation, ...
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
\item Wird in Anwendung eingebunden (importiert), API
|
\item Wird in Anwendung eingebunden (importiert), API
|
||||||
\item Objekte instanziieren oder Klassen ableiten
|
\item Objekte instanziieren oder Klassen ableiten
|
||||||
\item Meist passiv: Kontrollfluss wird von Anwendung gesteuert
|
\item Meist passiv: Kontrollfluss wird von Anwendung gesteuert
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
@ -1316,78 +1316,31 @@
|
|||||||
\item Untersuchung des Zeit- und Speicherbedarfs
|
\item Untersuchung des Zeit- und Speicherbedarfs
|
||||||
\item Test und Verifikation
|
\item Test und Verifikation
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
\item „Programmieren im Kleinen“
|
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
\subsection{Konventionen und Werkzeuge}
|
\subsection{Konventionen und Werkzeuge}
|
||||||
Konventionen beim Programmieren
|
\begin{description*}
|
||||||
\begin{itemize*}
|
\item[Klasse] (mit) Substantiv, „UpperCamelCase“
|
||||||
\item (Coding Rules, -conventions, -standards)
|
\item[Methode] (mit) Verb, Imperativ (Aufforderung), „lowerCamelCase“
|
||||||
\item Regeln für verständliche Programme
|
\item[Attribut, Variable] (mit) Substantiv, „lowerCamelCase“
|
||||||
\begin{itemize*}
|
\item[Konstante] Nur Großbuchstaben, Worte mit "\_" zusammengesetzt
|
||||||
\item „wie“ sollte Quellcode formal und strukturell gestaltet sein
|
\end{description*}
|
||||||
\item Bezeichner, Einrückungen, Dokumentation, Dateien, ...
|
|
||||||
\item Strukturierung: Block, Methode, Klasse, Package
|
|
||||||
\end{itemize*}
|
|
||||||
\item Firmenspezifische Regeln
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Festlegung Entwurfsprinzipien (z.B. keine Mehrfachvererbung)
|
|
||||||
\end{itemize*}
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
Namenskonventionen
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Klasse
|
|
||||||
\begin{itemize*}
|
|
||||||
\item (mit) Substantiv, „UpperCamelCase“
|
|
||||||
\item Beispiele: Account, StandardTemplate
|
|
||||||
\end{itemize*}
|
|
||||||
\item Methode
|
|
||||||
\begin{itemize*}
|
|
||||||
\item (mit) Verb, Imperativ (Aufforderung), „lowerCamelCase“
|
|
||||||
\item Beispiele: checkAvailability(), getDate()
|
|
||||||
\end{itemize*}
|
|
||||||
\item Attribut, Variable
|
|
||||||
\begin{itemize*}
|
|
||||||
\item (mit) Substantiv, „lowerCamelCase“
|
|
||||||
\item Beispiele: anzahlAutos, fensterBreite
|
|
||||||
\end{itemize*}
|
|
||||||
\item Konstante
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Nur Großbuchstaben, Worte mit "\_" zusammengesetzt
|
|
||||||
\item Standardpräfixe: "MIN\_", "MAX\_", "DEFAULT\_", ...
|
|
||||||
\item Beispiele: NORTH, BLUE, MIN\_WIDTH, DEFAULT\_SIZE
|
|
||||||
\end{itemize*}
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
Formatierungs-Richtlinien
|
Formatierungs-Richtlinien
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Entsprechend Schachtelungstiefe einrücken, aber nicht zu weit
|
\item Entsprechend Schachtelungstiefe einrücken, aber nicht zu weit
|
||||||
\item Einheitliche Verwendung von Leerzeilen und Leerzeichen
|
\item Einheitliche Verwendung von Leerzeilen und Leerzeichen
|
||||||
\item Einheitliche Dateistruktur verwenden
|
\item Einheitliche Dateistruktur verwenden
|
||||||
\begin{itemize*}
|
|
||||||
\item Eine .java-Datei pro Klasse
|
|
||||||
\item Ein Verzeichnis für jedes package
|
|
||||||
\end{itemize*}
|
|
||||||
\item Werkzeuge: source beautifier, oft in IDEs enthalten
|
\item Werkzeuge: source beautifier, oft in IDEs enthalten
|
||||||
\item Editor: syntax highlighting
|
\item Editor: syntax highlighting
|
||||||
\item Navigationswerkzeuge
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Auf- und Zuklappen, Inhaltsverzeichnis, tagging
|
|
||||||
\item doxygen, Eclipse etc.
|
|
||||||
\end{itemize*}
|
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
Änderungsfreundlicher Code
|
Änderungsfreundlicher Code
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Wahl von Variablen, Konstanten und Typen orientiert an der fachlichen Aufgabe, nicht an der Implementierung:
|
\item Wahl von Variablen, Konstanten und Typen orientiert an der fachlichen Aufgabe, nicht an der Implementierung
|
||||||
\begin{itemize*}
|
|
||||||
\item `typedef char name [NAME\_LENGTH]`
|
|
||||||
\item `typedef char firstName [FIRST\_NAME\_LENGTH]`
|
|
||||||
\end{itemize*}
|
|
||||||
\item Symbolische Konstanten statt literaler Werte verwenden, wenn spätere Änderung denkbar
|
\item Symbolische Konstanten statt literaler Werte verwenden, wenn spätere Änderung denkbar
|
||||||
\item Algorithmen, Formeln, Standardkonzepte in Methoden/Prozeduren kapseln
|
\item Algorithmen, Formeln, Standardkonzepte in Methoden/Prozeduren kapseln
|
||||||
\item Übersichtlichkeit: Zusammenhängende Einheit nicht größer als Editorfenster (40-60 Zeilen, 70 Zeichen breit)
|
\item Übersichtlichkeit: Zusammenhängende Einheit nicht größer als Editorfenster
|
||||||
\item Strukturierte Programmierung (Regeln je nach Schärfe)
|
\item Strukturierte Programmierung (Regeln je nach Schärfe)
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Kein goto verwenden (in anderen Sprachen als Java)
|
\item Kein goto verwenden (in anderen Sprachen als Java)
|
||||||
@ -1397,171 +1350,71 @@
|
|||||||
\item return nur am Ende zur Rückgabe des Werts
|
\item return nur am Ende zur Rückgabe des Werts
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
\item Übersichtliche Ausdrücke
|
\item Übersichtliche Ausdrücke
|
||||||
\begin{itemize*}
|
|
||||||
\item Seiteneffektfreie Ausdrücke, schlecht: y += 12*x++;
|
|
||||||
\end{itemize*}
|
|
||||||
\item Variablen möglichst lokal und immer private deklarieren
|
\item Variablen möglichst lokal und immer private deklarieren
|
||||||
\item Wiederverwendung "äußerer" Namen vermeiden
|
\item Wiederverwendung "äußerer" Namen vermeiden
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
Werkzeuge
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Integrated Development Environments (Eclipse, KDevelop)
|
|
||||||
\item Compiler, Linker; Build / Make; Versionskontrolle (git, svn)
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
\subsection{Code-Qualität}
|
\subsection{Code-Qualität}
|
||||||
Portierbarer Code
|
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Code, den man ohne Änderungen in ein anderes System (Compiler, Betriebssystem, Rechner) übertragen kann
|
\item Portierbarer Code: ohne Änderungen in anderes System (Compiler, Betriebssystem, Rechner) übertragen kann
|
||||||
|
\item Implementierungsabhängiges Verhalten
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Kein implementierungsabhängiges Verhalten!
|
\item Compiler übersetzen Sprachkonstrukte unterschiedlich
|
||||||
\end{itemize*}
|
\item Verhalten ist konsistent festgelegt und dokumentiert
|
||||||
\item ANSI C++ Standard ist nicht vollständig definiert
|
\item Kompilierung von standardkonformem Code ist erfolgreich
|
||||||
\begin{itemize*}
|
\item char kann signed oder unsigned sein: Nicht damit rechnen!
|
||||||
\item Ist das Verhalten nicht festgelegt, unterscheidet der ANSI C++ Standard zwischen:
|
|
||||||
\item Implementierungsabhängigem, unspezifiziertem oder undefiniertem Verhalten
|
|
||||||
\item Code, welcher auf implementierungsabhängigem, unspezifiziertem oder undefiniertem Verhalten basiert, ist
|
|
||||||
\item Nicht portabel und somit häufig verboten
|
|
||||||
\item Wird unter Umständen ungewollt wegoptimiert
|
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
\item Sicherer Code mit const
|
||||||
|
\begin{description*}
|
||||||
|
\item[Const Variable] Stellt sicher, dass sich der Wert nicht verändert
|
||||||
|
\item[Const Parameter] Übergabeparameter ändert sich nicht
|
||||||
|
\item[Const Operationen] Sicherstellen, dass Operation das Exemplar nicht ändert
|
||||||
|
\end{description*}
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
Implementierungsabhängiges Verhalten
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Compiler übersetzen bestimmte Sprachkonstrukte unterschiedlich, Ergebnis unterscheidet sich
|
|
||||||
\item Voraussetzung:
|
|
||||||
\item Verhalten ist konsistent festgelegt und dokumentiert
|
|
||||||
\item Kompilierung von standardkonformem Code ist erfolgreich
|
|
||||||
\item Beispiel: Speichergröße von Integer-Typen
|
|
||||||
\item char kann signed oder unsigned sein: Nicht damit rechnen!
|
|
||||||
\item 32 Bit System ist wie erwartet
|
|
||||||
\item 16 Bit System: Multiplikation wird mit int durchgeführt $\rightarrow$ Überlauf $\rightarrow$ undefiniertes Verhalten
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Unspezifiziertes Verhalten:
|
|
||||||
\item Wie implementierungsabhängiges Verhalten
|
|
||||||
\item Compiler muss sich für ein bestimmtes Verhalten entscheiden
|
|
||||||
\item Muss nicht dokumentiert sein
|
|
||||||
\item Beispiel: Evaluierungsreihenfolge von Funktionsargumenten `tuWas(zuerstDas(),oderDochLieberDas());`
|
|
||||||
\item Undefiniertes Verhalten:
|
|
||||||
\item Keinerlei Vorgaben
|
|
||||||
\item Compiler muss mögliches Problem nicht melden
|
|
||||||
\item Keine Voraussage welches Resultat eintritt
|
|
||||||
\item Bereits die Kompilierung kann fehlschlagen
|
|
||||||
\item Oder das laufende Programm kann falsche Resultate liefern.
|
|
||||||
\item Effekt: „Bei mir läuft es aber!?“
|
|
||||||
\item „undefiniertes Verhalten nutzen grenzt an Sabotage!“
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
Sicherer Code mit const
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Const Variable - Konstante
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Stellt sicher, dass sich der Wert nicht verändert
|
|
||||||
\end{itemize*}
|
|
||||||
\item Const Parameter
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Übergabeparameter ändert sich nicht innerhalb der Operation
|
|
||||||
\item Z.B. bei Übergabe komplexer Daten als Referenz bzw. Zeiger `long calcMeanValue(const image \&i){...}`
|
|
||||||
\end{itemize*}
|
|
||||||
\item Const Operationen
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Sicherstellen, dass Operation das Exemplar nicht ändert
|
|
||||||
\item Aufruf der const Operation bei const Variablen möglich
|
|
||||||
\end{itemize*}
|
|
||||||
\item Verwende const wenn möglich
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
|
|
||||||
\subsection{Dokumentation}
|
\subsection{Dokumentation}
|
||||||
\begin{itemize*}
|
\begin{description*}
|
||||||
\item Selbstdokumentierende Programme?
|
\item[Integrierte] Dokumentation
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item 2001 Int. Obfuscated C Code Contest Winner, Short Program
|
\item Verständlichkeit, Wartbarkeit - auch für Programmierer!
|
||||||
|
\item Code selbst sollte möglichst verständlich sein
|
||||||
|
\item Dokumentation in Programm schreiben und aktualisieren
|
||||||
|
\item Beschreibung der Bedeutung des Codes!
|
||||||
|
\item Als Konventionen festschreiben
|
||||||
|
\item Programmvorspann
|
||||||
|
\item Kurzbeschreibung Datei / Klasse / Funktion ...
|
||||||
|
\item Verwaltungsinformationen
|
||||||
|
\item Laufende Kommentare im Quellcode
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
\end{itemize*}
|
\item[Programmierer] Dokumentation
|
||||||
|
|
||||||
Integrierte Dokumentation
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Verständlichkeit, Wartbarkeit - auch für Programmierer!
|
|
||||||
\item Code selbst sollte möglichst verständlich sein
|
|
||||||
\item Dokumentation in Programm schreiben und aktualisieren
|
|
||||||
\item Beschreibung der Bedeutung des Codes!
|
|
||||||
\item Als Konventionen festschreiben
|
|
||||||
\item Programmvorspann
|
|
||||||
\item Kurzbeschreibung Datei / Klasse / Funktion ...
|
|
||||||
\item Verwaltungsinformationen
|
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Autor, Datum, Version, Projekt, ToDo, FixMe, ...
|
\item Als eigenes Dokument elektronisch oder gedruckt
|
||||||
\item Zustand: geplant, in Bearbeitung, vorgelegt, akzeptiert
|
\item Einstieg in Programmverständnis (z.B. Bachelor-Arbeit)
|
||||||
|
\item Konsistenz mit Quelltext? Verweise?
|
||||||
|
\item Technische Unterstützung: JavaDoc (Java), doxygen (C++)
|
||||||
|
\item Ergänztes Java-Programm: Dokumentation HTML, PDF,
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
\item Laufende Kommentare im Quellcode
|
\item[Benutzer] Dokumentation
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
Programmierer-Dokumentation
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Als eigenes Dokument elektronisch oder gedruckt
|
|
||||||
\item Einstieg in Programmverständnis (z.B. Bachelor-Arbeit)
|
|
||||||
\item Konsistenz mit Quelltext? Verweise?
|
|
||||||
\item Technische Unterstützung: JavaDoc (Java), doxygen (C++)
|
|
||||||
\item Ergänztes Java-Programm: Dokumentation HTML, PDF,
|
|
||||||
\end{itemize*}
|
|
||||||
% ```js
|
|
||||||
% /** @author name Mustermann */
|
|
||||||
% /** @param name description */
|
|
||||||
% /** @return description */
|
|
||||||
% ```
|
|
||||||
|
|
||||||
Benutzerdokumentation
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Benutzer-Handbuch, Online-Dokumentation
|
|
||||||
\item Unterstützung ohne Support?
|
|
||||||
\item Vollständige und fehlerfreie Beschreibung der Benutzung
|
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Beispiele, screen shots
|
\item Benutzer-Handbuch, Online-Dokumentation
|
||||||
|
\item Unterstützung ohne Support?
|
||||||
|
\item Vollständige und fehlerfreie Beschreibung der Benutzung
|
||||||
|
\item Arten: Tutorial, Beschreibung
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
\item Arten: Tutorial, Beschreibung,
|
\end{description*}
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
Benutzer-Unterstützungssysteme
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Integrierte Hilfe (Suchfunktion, balloon help / tool tips)
|
|
||||||
\item Assistenz-System (Zustandsabhängige Anleitung)
|
|
||||||
\item Tutor-System zum Erlernen
|
|
||||||
\item Bug-Listen, Mailinglisten, Diskussionsforen
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
\subsection{Codegenerierung}
|
\subsection{Codegenerierung}
|
||||||
Bezug zwischen Modell und Programmcode
|
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Vorwärtsmodellierung: Modell - Code
|
\item Vorwärtsmodellierung: Modell - Code
|
||||||
\item Rückwärtsmodellierung: Code - Modell
|
\item Rückwärtsmodellierung: Code - Modell
|
||||||
\begin{itemize*}
|
\item Modelltransformation, Refaktorisierung
|
||||||
\item Außerdem: Modelltransformation, Refaktorisierung
|
\item Idealfall: Automatische Übersetzung durch SW-Werkzeug
|
||||||
\end{itemize*}
|
\item Statisch: Quelltext der Klassen mit Beziehungen, Attributen...
|
||||||
\item Idealfall: Automatische Übersetzung durch SW-Werkzeug (in beiden Richtungen)
|
\item Dynamisch: Quelltext der Zustandssteuerung einer Klasse
|
||||||
\begin{itemize*}
|
|
||||||
\item „Modellbasierte Entwicklung“
|
|
||||||
\end{itemize*}
|
|
||||||
\item Statisch: Beispiel Klassendiagramm - Quelltext der Klassen mit allen Vererbungsbeziehungen, Attributen und Methodensignaturen (Klassen-Stümpfe mit leeren Methodenrümpfen zum Ausfüllen)
|
|
||||||
\item Dynamisch: Beispiel Zustandsdiagramm - Quelltext der Zustandssteuerung einer Klasse
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
%
|
|
||||||
|
|
||||||
Weitere statische Transformationen
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Abbildung von Assoziationen auf Sammlungen
|
|
||||||
\item Abbildung von Verträgen auf Ausnahmen
|
|
||||||
\item Abbildung von Objektmodellen auf Datenbankschemata
|
|
||||||
\item Abbildung von Entwurfsmustern auf Codefragmente
|
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
Optimierung des Entwurfsmodells
|
Optimierung des Entwurfsmodells
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Grund: nichtfunktionale Eigenschaften
|
|
||||||
\item Zugriffspfade
|
\item Zugriffspfade
|
||||||
\item Klassen in Attribute umwandeln
|
\item Klassen in Attribute umwandeln
|
||||||
\item Verzögerung von Berechnungen
|
\item Verzögerung von Berechnungen
|
||||||
@ -1572,41 +1425,18 @@
|
|||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Einfachste Möglichkeit: Switch (Case) Statement
|
\item Einfachste Möglichkeit: Switch (Case) Statement
|
||||||
\item Zustände werden durch Datenwerte repräsentiert
|
\item Zustände werden durch Datenwerte repräsentiert
|
||||||
\begin{itemize*}
|
|
||||||
\item Aktueller Zustand: einzelne skalare Variable
|
|
||||||
\end{itemize*}
|
|
||||||
\item Jedes Ereignis wird durch Methode implementiert
|
\item Jedes Ereignis wird durch Methode implementiert
|
||||||
\item Ausgehend von aktivem Zustand wird bei Eintreffen eines Ereignisses der entsprechende Programmcode ausgeführt
|
\item Ausgehend von aktivem Zustand wird bei Eintreffen eines Ereignisses der entsprechende Programmcode ausgeführt
|
||||||
\item Abhängig von Zustandsvariable wird Aktion ausgeführt und der Folgezustand eingestellt
|
\item Abhängig von Zustandsvariable wird Aktion ausgeführt und der Folgezustand eingestellt
|
||||||
\item Wird in einer Klasse realisiert
|
\item Wird in einer Klasse realisiert
|
||||||
\item Sinnvoll für einfache, “flache” Modelle
|
\item Sinnvoll für einfache, “flache” Modelle
|
||||||
\begin{itemize*}
|
|
||||||
\item Sonst Logik für Hierarchie nötig
|
|
||||||
\end{itemize*}
|
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
Anpassung der Generierung
|
Anpassung der Generierung
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Verschiedene Zielsprachen (Java, C++, ...)
|
\item Verschiedene Zielsprachen (Java, C++, ...)
|
||||||
\item Model2Text-Transformationen
|
\item Model2Text-Transformationen
|
||||||
\begin{itemize*}
|
|
||||||
\item Verschiedene Generatoren, z.B. Eclipse Modelling Project
|
|
||||||
\end{itemize*}
|
|
||||||
\item Generierung aus dem Modellierungswerkzeug
|
\item Generierung aus dem Modellierungswerkzeug
|
||||||
\begin{itemize*}
|
|
||||||
\item Parametrisierung der Codegenerierung
|
|
||||||
\item Generierungsvorlagen
|
|
||||||
\end{itemize*}
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
Weitere Werkzeuge
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Compiler-Compiler: Syntaxbeschreibung wird in lexikalische Analyse (tokenizer) und Syntaxanalyse-Programm transformiert (lex \& yacc / flex \& bison / antlr)
|
|
||||||
\item Codegenerierung für grafische Benutzungsoberflächen aus grafischer Beschreibung: GUI toolkits
|
|
||||||
\item XML-Parser
|
|
||||||
\begin{itemize*}
|
|
||||||
\item XSLT, DOM, SAX, ...
|
|
||||||
\end{itemize*}
|
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
\subsection{Implementierung aktiver Objekte}
|
\subsection{Implementierung aktiver Objekte}
|
||||||
@ -1617,15 +1447,12 @@
|
|||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
Arten von Programmabarbeitung
|
Arten von Programmabarbeitung
|
||||||
\begin{itemize*}
|
\begin{description*}
|
||||||
\item Sequentiell: es gibt immer genau einen nächsten Schritt, alle Schritte werden nacheinander ausgeführt
|
\item[Sequentiell] es gibt immer genau einen nächsten Schritt, alle Schritte werden nacheinander ausgeführt
|
||||||
\item Parallel: Spezielle Hardware bzw. Mehrkernprozessor, mehrere Befehlsfolgen werden echt parallel bearbeitet
|
\item[Parallel] Spezielle Hardware bzw. Mehrkernprozessor, mehrere Befehlsfolgen werden echt parallel bearbeitet
|
||||||
\item Quasi-parallel: Ein Prozessor arbeitet mehrere Befehlsfolgen in freier Einteilung ab
|
\item[Quasi-parallel] Ein Prozessor arbeitet mehrere Befehlsfolgen in freier Einteilung ab
|
||||||
\item Nebenläufig: Oberbegriff für Parallel und Quasi-parallel
|
\item[Nebenläufig] Oberbegriff für Parallel und Quasi-parallel (concurrent)
|
||||||
\begin{itemize*}
|
\end{description*}
|
||||||
\item concurrent
|
|
||||||
\end{itemize*}
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
Vorteile
|
Vorteile
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
@ -1640,71 +1467,7 @@
|
|||||||
\item Ein Programm, das bei gleichen Eingaben gleiche Ausgaben produziert, heißt determiniert (determined)
|
\item Ein Programm, das bei gleichen Eingaben gleiche Ausgaben produziert, heißt determiniert (determined)
|
||||||
\item Programme in üblichen Programmiersprachen sind sequentiell, deterministisch und determiniert
|
\item Programme in üblichen Programmiersprachen sind sequentiell, deterministisch und determiniert
|
||||||
\item Grund: Herkömmliche Programmiersprachen sind durch das von-Neumann-Modell geprägt
|
\item Grund: Herkömmliche Programmiersprachen sind durch das von-Neumann-Modell geprägt
|
||||||
\item Determinismus nicht notwendig für Determiniertheit!
|
\item Determiniertheit nebenläufiger Programme: Synchronisation
|
||||||
\begin{itemize*}
|
|
||||||
\item Determiniertheit nebenläufiger Programme: Synchronisation
|
|
||||||
\item Vermeidung von Schreib/Schreib und Schreib/Lese-Konflikten
|
|
||||||
\end{itemize*}
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
Java Threads
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Verwaltung durch die Java Virtuelle Maschine (JVM)
|
|
||||||
\item Realisierung der Threads ist je nach Implementierung der JVM unterschiedlich
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Abbildung auf Betriebssystem-Threads (z.B. unter Windows weitverbreitet)
|
|
||||||
\item Realisierung durch die JVM (z.B. unter Unix und in Java-fähigen Browsern)
|
|
||||||
\item Nachteile: Keine Ausnutzung von Multiprozessorsystemen durch die VM; Zuteilungsstrategie für Threads ist in derzeitigen Implementierungen unterschiedlich
|
|
||||||
\end{itemize*}
|
|
||||||
\item Threads arbeiten immer im Adressraum der JVM (eigener Prozess) und sind außerhalb dieser nicht sichtbar
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
Erzeugung eines Threads
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Unterklasse der Basisklasse „Thread“ bilden `class MyThread extends Thread`
|
|
||||||
\item Problem: keine Mehrfachvererbung, daher Alternative nötig (Beispiel: Applet):
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Schnittstelle „Runnable“ implementieren
|
|
||||||
\item `class MyThread implements Runnable`
|
|
||||||
\end{itemize*}
|
|
||||||
\item Die vordefinierte Schnittstelle Runnable ist definiert als
|
|
||||||
% ```java
|
|
||||||
% public interface Runnable
|
|
||||||
% { public abstract void run(); }
|
|
||||||
% ```
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
Starten eines Threads
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Eine Klasse, die Runnable implementiert, muss wie Unterklassen von Thread immer eine run()-Methode definieren
|
|
||||||
\item Seiteneffekt der Runnable-Schnittstelle
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Instanzen der Klasse werden nebenläufig zu den anderen laufenden Threads ausgeführt
|
|
||||||
\item Ausführung beginnt mit der Methode run ()
|
|
||||||
\end{itemize*}
|
|
||||||
\item Ablauf
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Thread-Objekt erzeugen
|
|
||||||
\item Thread starten mit t.start()
|
|
||||||
\item start() ruft implizit run() auf
|
|
||||||
\end{itemize*}
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
Synchronisation von Threads
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Gezielte Einschränkung der Nebenläufigkeit
|
|
||||||
\item Gründe
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Zugriffsbeschränkung, gegenseitiger Ausschluss
|
|
||||||
\item Abhängigkeiten, einseitige Synchronisation
|
|
||||||
\end{itemize*}
|
|
||||||
\item Methoden: Semaphore, Monitore, Schlossvariablen, ...
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
Java: Monitore
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Zugriffsoperationen werden in Klassen zusammengefasst
|
|
||||||
\item Gegenseitiger Ausschluss: Spezifikation der betroffenen Zugriffsoperation als synchronized
|
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
\subsection{Verifikation und Testen}
|
\subsection{Verifikation und Testen}
|
||||||
@ -1713,127 +1476,68 @@
|
|||||||
\item Wissen, Erfahrung und Methodenkompetenz der Programmierer
|
\item Wissen, Erfahrung und Methodenkompetenz der Programmierer
|
||||||
\item Projektstruktur, klare Verantwortlichkeiten
|
\item Projektstruktur, klare Verantwortlichkeiten
|
||||||
\item Kosten- und Zeitdruck? Änderungen?
|
\item Kosten- und Zeitdruck? Änderungen?
|
||||||
\item Programmier- und Testmethoden
|
\item Programmier- und Testmethoden (pair programming, code reading)
|
||||||
\begin{itemize*}
|
\item Technische Unterstützung (Versionierung, Dokumentation, Testen)
|
||||||
\item pair programming, code reading etc.
|
|
||||||
\item Qualitätsverantwortlicher, automatisiertes Testen
|
|
||||||
\end{itemize*}
|
|
||||||
\item Technische Unterstützung
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Z.B. Versionierung, Dokumentation, Testen, Entwicklungsumgebung
|
|
||||||
\end{itemize*}
|
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
Begriffe
|
Begriffe
|
||||||
\begin{itemize*}
|
\begin{description*}
|
||||||
\item Zuverlässigkeit: Maß für Übereinstimmung des Systemverhaltens mit Spezifikation
|
\item[Zuverlässigkeit] Maß für Übereinstimmung des Systemverhaltens mit Spezifikation
|
||||||
\item Grund für Unzuverlässigkeit:
|
\item[Unzuverlässigkeit] Fehler (bug, fault), fehlerhafter Programmcode
|
||||||
\begin{itemize*}
|
\item[Fehlerhafter Zustand (error)] Fehler hat zur Laufzeit zu einem internen fehlerhaften Zustand geführt, der möglicherweise zu einem Ausfall führt
|
||||||
\item Fehler (bug, fault): fehlerhafter Programmcode o.ä.
|
\item[Störfall, Ausfall (failure)] Abweichung vom spezifizierten Verhalten, meist mit negativen Folgen
|
||||||
\item Der Begriff „Bug“:
|
\end{description*}
|
||||||
\begin{itemize*}
|
|
||||||
\item Schon vor Computern als Begriff für Fehler benutzt
|
|
||||||
\item Motte im Relais des Computers Mark II Aiken (1947)
|
|
||||||
\end{itemize*}
|
|
||||||
\end{itemize*}
|
|
||||||
\item Fehlerhafter Zustand (error): Fehler hat zur Laufzeit zu einem internen fehlerhaften Zustand geführt, der möglicherweise zu einem Ausfall führt
|
|
||||||
\item Störfall, Ausfall (failure): Abweichung vom spezifizierten Verhalten, meist mit negativen Folgen
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
Vergleich System / Systemmodell
|
\paragraph{Verifikation}
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Anspruch guter Software: System entspricht Systemmodell (Korrektheit)
|
\item Mathematisch formaler Beweis genügt
|
||||||
\item Problem: System nicht vollständig automatisch erzeugbar!
|
|
||||||
\item Auswege
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Fehlervermeidung (Inspektion, pair programming, ...)
|
|
||||||
\item Nachweis, dass System dem Modell entspricht - Verifikation
|
|
||||||
\item Überprüfen, ob System dem Modell entspricht - Testen
|
|
||||||
\item Fehlertoleranz (durch Redundanz)
|
|
||||||
\end{itemize*}
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
Verifikation
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Mathematisch formaler Beweis, dass ein Programm einer Spezifikation genügt
|
|
||||||
\item Vorteil: wenn anwendbar, dann vollständiger Beweis
|
\item Vorteil: wenn anwendbar, dann vollständiger Beweis
|
||||||
\item Problem: für viele (realistisch große) Fälle nicht anwendbar
|
\item Problem: für viele (realistisch große) Fälle nicht anwendbar
|
||||||
\begin{itemize*}
|
\item Theoretische Informatik: Berechenbarkeitstheorie, Semantik
|
||||||
\item Zu aufwändig
|
|
||||||
\item Umgebung muss ebenfalls verifiziert werden
|
|
||||||
\item Auch in der Theorie nicht immer entscheidbar: Halteproblem, Gödelscher Unvollständigkeitssatz
|
|
||||||
\end{itemize*}
|
|
||||||
\item Theoretische Informatik: Berechenbarkeitstheorie, formale Semantik; aktives Forschungsgebiet
|
|
||||||
\begin{itemize*}
|
|
||||||
\item model checking
|
|
||||||
\end{itemize*}
|
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
Testen
|
Testen
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Systematischer Versuch, Defekte in der Software zu finden
|
\item Systematischer Versuch, Defekte in der Software zu finden
|
||||||
\item Ingenieurtechnik zur Erhöhung des Vertrauens in Softwaresysteme, aber: unvollständig!
|
\item Ingenieurtechnik zur Erhöhung des Vertrauens
|
||||||
\begin{itemize*}
|
|
||||||
\item Kann nur die Anwesenheit von Fehlern nachweisen, aber nicht Korrektheit (Abwesenheit von Fehlern)!
|
|
||||||
\end{itemize*}
|
|
||||||
\item Aufgabe: Unterschiede zwischen Modell und System finden
|
\item Aufgabe: Unterschiede zwischen Modell und System finden
|
||||||
\item Destruktiv im Gegensatz zu sonstigen SWE-Aufgaben
|
\item Destruktiv im Gegensatz zu sonstigen SWE-Aufgaben
|
||||||
\begin{itemize*}
|
|
||||||
\item Daher sollten nicht (nur) Entwickler selbst testen
|
|
||||||
\end{itemize*}
|
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
Testplanung
|
Testplanung
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Testen ist aufwändig, deshalb ist gute Planung nötig!
|
\item Testen ist aufwändig, deshalb ist gute Planung nötig!
|
||||||
\item Testplanung sollte bereits mit der Anforderungsanalyse beginnen und im Entwurf verfeinert werden (V-Modell, Test-First-Ansatz)!
|
\item Testplanung sollte bereits mit der Anforderungsanalyse beginnen
|
||||||
\item Typische Bestandteile einer Test-Spezifikation (Testdrehbuch)
|
\item Typische Bestandteile einer Test-Spezifikation (Testdrehbuch)
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Phasenmodell des Testprozesses
|
\item Phasenmodell des Testprozesses
|
||||||
\item Zusammenhang zur Anforderungsspezifikation, z.B. dort festgelegte Qualitätsziele
|
\item Zusammenhang zur Anforderungsspezifikation
|
||||||
\item Zu testende Produkte
|
\item Zu testende Produkte
|
||||||
\item Zeitplan für die Tests
|
\item Zeitplan für die Tests
|
||||||
\item Abhängigkeiten der Testphasen
|
\item Abhängigkeiten der Testphasen
|
||||||
\item Aufzeichnung der Testergebnisse
|
\item Aufzeichnung der Testergebnisse
|
||||||
\item Hardware\item und Softwareanforderungen
|
\item Hardware- und Softwareanforderungen
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
Arten von Tests
|
\begin{description*}
|
||||||
\begin{itemize*}
|
\item[Komponententest] Fehler in einzelnen Objekten oder Subsystemen, losgelöst vom umgebenden System
|
||||||
\item Komponententest: Fehler in einzelnen Objekten oder Subsystemen, losgelöst vom umgebenden System
|
\item[Integrationstest] Zusammenspiel von Komponenten
|
||||||
\begin{itemize*}
|
\item[Systemtest] Vollständiges System; Szenarios
|
||||||
\item Umgebung muss nachgebildet werden
|
\item[Strukturtest] innere Zustände, Interaktionen
|
||||||
\end{itemize*}
|
\item[Funktionstest] Anforderungen aus Lastenheft
|
||||||
\item Integrationstest: Zusammenspiel von Komponenten
|
\item[Leistungstest] nichtfunktionale Anforderungen
|
||||||
\begin{itemize*}
|
\item[Benutzbarkeitstest] Fehler in der Benutzungsschnittstelle, Verständlichkeit, Akzeptanz bei Anwendern
|
||||||
\item Vollständiges System: Systemtest; Szenarios
|
\item[Akzeptanztest, Installationstest]: Kunde, Abnahme
|
||||||
\end{itemize*}
|
\end{description*}
|
||||||
\item Strukturtest: innere Zustände, Interaktionen
|
|
||||||
\item Funktionstest: Anforderungen aus Lastenheft
|
|
||||||
\item Leistungstest: nichtfunktionale Anforderungen
|
|
||||||
\item Benutzbarkeitstest: Fehler in der Benutzungsschnittstelle, Verständlichkeit, Akzeptanz bei Anwendern
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Prototypen
|
|
||||||
\end{itemize*}
|
|
||||||
\item Akzeptanztest, Installationstest: Kunde, Abnahme
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
Komponententests
|
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Überprüft Verhalten einer Systemkomponenten im Vergleich zur Spezifikation
|
|
||||||
\item Da Tests bereits frühzeitig stattfinden sollten, ist Umgebung meist nicht vollständig implementiert
|
\item Da Tests bereits frühzeitig stattfinden sollten, ist Umgebung meist nicht vollständig implementiert
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Teststumpf (stub, dummy) simuliert aufgerufene Komponenten
|
\item Teststumpf simuliert aufgerufene Komponenten
|
||||||
\item Testtreiber simuliert aufrufende Komponenten
|
\item Testtreiber simuliert aufrufende Komponenten
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
\item Vorgehensweisen
|
\item Vorgehensweisen: Bottom-up, Top-down, Sandwich, Schichtenweise
|
||||||
\begin{itemize*}
|
|
||||||
\item Bottom-up
|
|
||||||
\item Top-down
|
|
||||||
\item Sandwich
|
|
||||||
\item Schichtenweises Testen
|
|
||||||
\end{itemize*}
|
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
Systematisches Testen
|
Systematisches Testen
|
||||||
@ -1849,7 +1553,7 @@
|
|||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
\item Weitere Begriffe
|
\item Weitere Begriffe
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Regressionstest: erneute Durchführung eines Tests anhand einer geänderten Version des Testgegenstands
|
\item Regressionstest: geänderte Version des Testgegenstands
|
||||||
\item Alphatest: Test eines Prototypen durch Benutzer
|
\item Alphatest: Test eines Prototypen durch Benutzer
|
||||||
\item Betatest: Test der vollständigen Software durch Benutzer
|
\item Betatest: Test der vollständigen Software durch Benutzer
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
@ -1862,48 +1566,18 @@
|
|||||||
\item E/A-Zusammenhang
|
\item E/A-Zusammenhang
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
Äquivalenzklassen im funktionalen Test
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Problem: alle Kombinationsmöglichkeiten der Eingangsdaten sind zu umfangreich für vollständigen Test
|
|
||||||
\item Mögliche Einschränkung: Bildung von Äquivalenzklassen der Eingangsdaten, für die ähnliches Verhalten erwartet wird
|
|
||||||
\item Basierend auf Anwendungsdomäne
|
|
||||||
\item Äquivalenzklasse = Teilmenge der möglichen Datenwerte der Eingabeparameter
|
|
||||||
\item Test je eines Repräsentanten jeder Äquivalenzklasse
|
|
||||||
\item Finden von Äquivalenzklassen
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Zulässige / unzulässige Teilbereiche der Datenwerte
|
|
||||||
\item Unterteilung der Bereiche nach erwarteten Ausgabewerten
|
|
||||||
\end{itemize*}
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
Grenztests
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Ergänzung von Äquivalenztests: Spezialfälle
|
|
||||||
\item Rand der Äquivalenzklasse
|
|
||||||
\item Außerdem: Sonderfälle, erwartete Problemfälle (technisch)
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
Strukturtest (white box test, glass box test)
|
Strukturtest (white box test, glass box test)
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Testfallauswahl beruht auf Programmstruktur
|
\item Testfallauswahl beruht auf Programmstruktur
|
||||||
\item Wie erreicht man möglichst vollständige Abdeckung?
|
\item Wie erreicht man möglichst vollständige Abdeckung?
|
||||||
\item Kontrollflussorientiert
|
\item Kontrollflussorientiert (Anweisungsüberdeckung anhand Quellcode)
|
||||||
\begin{itemize*}
|
\item Datenflussorientiert (Abarbeitungspfade von Definition)
|
||||||
\item Anweisungsüberdeckung anhand Quellcode
|
|
||||||
\item Zweigüberdeckung und
|
|
||||||
\item Pfadüberdeckung anhand des Flussgraphen reduzierte Variante: bounded interior Pfadtest
|
|
||||||
\end{itemize*}
|
|
||||||
\item Datenflussorientiert
|
|
||||||
\begin{itemize*}
|
|
||||||
\item defines / uses-Verfahren: Abarbeitungspfade von Definition zu jeder Verwendung von Variable oder Objekt durchlaufen
|
|
||||||
\end{itemize*}
|
|
||||||
\item Zustandsorientiert
|
\item Zustandsorientiert
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
\subsection{Testaktivitäten und Werkzeuge}
|
\subsection{Testaktivitäten und Werkzeuge}
|
||||||
Wann wird getestet?
|
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Während der Implementierung!
|
\item Wann wird getestet? Während der Implementierung!
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Auch wenn Schreiben von Tests scheinbar unproduktiv ist
|
\item Auch wenn Schreiben von Tests scheinbar unproduktiv ist
|
||||||
\item Tests sind unbeliebt, da Probleme aufgezeigt werden
|
\item Tests sind unbeliebt, da Probleme aufgezeigt werden
|
||||||
@ -1911,10 +1585,9 @@
|
|||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
\item Inkrementell, d.h. für jede überschaubare Änderung
|
\item Inkrementell, d.h. für jede überschaubare Änderung
|
||||||
\item Spezielle Vorgehensweise: test first-Ansatz
|
\item Spezielle Vorgehensweise: test first-Ansatz
|
||||||
|
\item Wie wird getestet? Geplant, systematisch, möglichst automatisiert, dokumentiert, wiederholbar
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
Wie wird getestet? Geplant, systematisch, möglichst automatisiert, dokumentiert, wiederholbar
|
|
||||||
|
|
||||||
Testplanung
|
Testplanung
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Iterative Erstellung eines Testplans / Testdrehbuchs
|
\item Iterative Erstellung eines Testplans / Testdrehbuchs
|
||||||
@ -1947,7 +1620,7 @@
|
|||||||
\item Festlegen und Erstellen der Eingabedaten
|
\item Festlegen und Erstellen der Eingabedaten
|
||||||
\item Festlegungen zum Testablauf und zur Testreihenfolge
|
\item Festlegungen zum Testablauf und zur Testreihenfolge
|
||||||
\item Festlegen Soll-Ergebnis
|
\item Festlegen Soll-Ergebnis
|
||||||
\item Festlegung der Bedingung(en) für 'Test erfüllt'; ...
|
\item Festlegung der Bedingung(en) für 'Test erfüllt'
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
@ -1960,19 +1633,15 @@
|
|||||||
\item Bereitstellen der Dokumente (Testspezifikation)
|
\item Bereitstellen der Dokumente (Testspezifikation)
|
||||||
\item Verfügbar machen von Werkzeugen (Fehlermanagement)
|
\item Verfügbar machen von Werkzeugen (Fehlermanagement)
|
||||||
\item Aufbauen der Testumgebung(en)
|
\item Aufbauen der Testumgebung(en)
|
||||||
\item Integration der Entwicklungsergebnisse in die Testumgebung (Software installieren, konfigurieren, ...)
|
\item Integration der Entwicklungsergebnisse
|
||||||
\item Bereitstellung von Testdaten bzw. Eingabedaten in die Testumgebung
|
\item Bereitstellung von Testdaten in die Testumgebung
|
||||||
\item Benutzer und Benutzerrechte anlegen
|
\item Benutzer und Benutzerrechte anlegen
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
Testdurchführung
|
Testdurchführung
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Durchführung der spezifizierten Tests
|
\item Durchführung der spezifizierten Tests (Manuell/Automatisiert)
|
||||||
\begin{itemize*}
|
|
||||||
\item Manuell
|
|
||||||
\item Automatisiert
|
|
||||||
\end{itemize*}
|
|
||||||
\item Aktivitäten
|
\item Aktivitäten
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Auswählen der zu testenden Testfälle
|
\item Auswählen der zu testenden Testfälle
|
||||||
@ -1993,9 +1662,8 @@
|
|||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Klassifizierung (z. B.: Fehlerursache, Fehlerschwere etc.)
|
\item Klassifizierung (z. B.: Fehlerursache, Fehlerschwere etc.)
|
||||||
\item Fehler reproduzieren!
|
\item Fehler reproduzieren!
|
||||||
\item Angemessene Fehlerbeschreibung und –erläuterung: Nur ausreichend dokumentierte Fehler sind gültig und können bearbeitet werden!
|
\item Angemessene Fehlerbeschreibung und -erläuterung
|
||||||
\item Fehler im Fehlermanagement eintragen (Bug report)
|
\item Fehler im Fehlermanagement eintragen (Bug report)
|
||||||
\item Testfall bleibt offen
|
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
@ -2005,37 +1673,29 @@
|
|||||||
\item Ziel ist die Reproduzierbarkeit des Fehlers
|
\item Ziel ist die Reproduzierbarkeit des Fehlers
|
||||||
\item Zuordnung zu Projektplan: Meilenstein, Version
|
\item Zuordnung zu Projektplan: Meilenstein, Version
|
||||||
\item Fehlerklassifikation
|
\item Fehlerklassifikation
|
||||||
\begin{itemize*}
|
\begin{description*}
|
||||||
\item defect: Fehler in einer bestehenden Funktionalität
|
\item[defect] Fehler in einer bestehenden Funktionalität
|
||||||
\item enhancement / feature: Funktionale Anforderung oder Erweiterung der bestehenden Funktionalität
|
\item[enhancement/feature] Funktionale Anforderung (Erweiterung)
|
||||||
\item task: Allgemeine Aufgabe
|
\item[task] Allgemeine Aufgabe
|
||||||
\end{itemize*}
|
\end{description*}
|
||||||
\item Priorität festlegen
|
\item Priorität festlegen
|
||||||
\begin{itemize*}
|
\begin{description*}
|
||||||
\item Unterschiedliche Stufen
|
\item[blocker] Schwerwiegender Fehler, führt zur Arbeitsunfähigkeit anderer
|
||||||
\item Festlegung innerhalb eines Unternehmens / Projektes
|
\item[critical] Schwerer Fehler, grundlegende Funktionalität des Systems nicht gegeben
|
||||||
\end{itemize*}
|
\item[major] normaler Fehler. System kann weiterhin verwendet werden
|
||||||
\item Prioritäten von Fehlern (bugs)
|
\item[minor] Kleiner Fehler, behindert nicht weiter die Funktionsfähigkeit des Systems
|
||||||
|
\item[trivial] Schönheitsfehler, stört während des Betrieb des Systems nicht.
|
||||||
|
\end{description*}
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
%| Stufe | Bedeutung | Verhalten |
|
|
||||||
%| -\item | -\item | -\item |
|
|
||||||
%| blocker | Schwerwiegender Fehler. Führt zur Arbeitsunfähigkeit anderer (Entwicklung, QA, Produktion,...). | Verdrängt alle anderen Aufgaben! Muss sofort gelöst werden, um Arbeitsfähigkeit wieder herzustellen. |
|
|
||||||
%| critical | Schwerer Fehler. Eine grundlegende Funktionalität des Systems ist nicht gegeben. Fehler muss bis zur nächsten Version behoben werden. System kann nicht verwendet werden. | Alle anderen Fehler (außer blocker) werden später gelöst. Bis zum nächsten Release muss dieser Bug gelöst sein. |
|
|
||||||
%| major | „normaler“ Fehler. Es tritt ein Fehler innerhalb einer Funktion des Systems auf. Das System kann jedoch weiterhin verwendet werden. | Fehler wird normal eingeplant. |
|
|
||||||
%| minor | Kleiner Fehler. Fehler behindert nicht weiter die Funktionsfähigkeit des Systems. Einfacher Work-Around vorhanden? | Je nach Aufwand und Zeitplanung erledigen. |
|
|
||||||
%| trivial | Schönheitsfehler. Fehler stört während des Betrieb des Systems nicht. | Je nach Aufwand „zwischendrin“ erledigen. Alle anderen Bugs bevorzugt lösen. |
|
|
||||||
|
|
||||||
Testabschluss
|
Testabschluss
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Zusammenfassen der Tests
|
\item Zusammenfassen der Tests dokumentieren und kommunizieren
|
||||||
\item Gesamtstatus dokumentieren und kommunizieren
|
\item Entscheidungen herbeiführen
|
||||||
\item Entscheidungen herbeiführen z.B.: Auslieferung?
|
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Ziele erreicht - nächste Schritte (Auslieferung)
|
\item Ziele erreicht - nächste Schritte (Auslieferung)
|
||||||
\item Tests vorzeitig beenden oder unterbrechen
|
\item Tests vorzeitig beenden oder unterbrechen
|
||||||
\item Gründe dokumentieren
|
\item Gründe dokumentieren
|
||||||
\item Vollständiger Nachtest oder Teiltest möglich?
|
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
\item Unterlagen archivieren
|
\item Unterlagen archivieren
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
@ -2043,11 +1703,8 @@
|
|||||||
Testautomatisierung
|
Testautomatisierung
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Automatische Code-Validierung
|
\item Automatische Code-Validierung
|
||||||
\begin{itemize*}
|
\item Statisch: lint (C), Compiler
|
||||||
\item Statisch: lint (C), Compiler
|
\item Dynamisch: run-time checking, memory leaks etc.
|
||||||
\item Dynamisch: run-time checking, memory leaks etc.
|
|
||||||
\end{itemize*}
|
|
||||||
\item Beispiel: Test-Framework JUnit
|
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
Behebung funktionaler Fehler
|
Behebung funktionaler Fehler
|
||||||
@ -2065,28 +1722,21 @@
|
|||||||
\item Aufrufe, Zeitverbrauch in Methoden usw.
|
\item Aufrufe, Zeitverbrauch in Methoden usw.
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
Memory Leaks, JProbe
|
Memory Leaks
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Runtime heap summary: Welche Objekte verbrauchen Speicher?
|
\item Runtime heap summary: Welche Objekte verbrauchen Speicher?
|
||||||
\item Reference graph: Wer referenziert diese Objekte, so dass sie nicht per garbage collection gelöscht werden?
|
\item Reference graph: Wer referenziert diese Objekte, so dass sie nicht per garbage collection gelöscht werden?
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
\subsection{Softwareverteilung}
|
\subsection{Softwareverteilung (deployment)}
|
||||||
Softwareverteilung (deployment)
|
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Prozess zur Installation von Software auf
|
\item Prozess zur Installation von Software auf PC‘s, Servern, Maschinen in Produktion
|
||||||
\begin{itemize*}
|
|
||||||
\item Anwender-PC‘s, Servern, Maschinen in Produktion ...
|
|
||||||
\end{itemize*}
|
|
||||||
\item Steuerung der Installation der Software
|
\item Steuerung der Installation der Software
|
||||||
\item Voraussetzungen für die Software schaffen
|
\item Voraussetzungen für die Software schaffen
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Schulungen planen und durchführen
|
\item Schulungen planen und durchführen
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
\item Softwareverteilung ist ein kritischer Prozess!
|
\item Softwareverteilung ist ein kritischer Prozess!
|
||||||
\begin{itemize*}
|
|
||||||
\item Fehler können zu vielen Störungen und Ausfällen führen
|
|
||||||
\end{itemize*}
|
|
||||||
\item Ziele
|
\item Ziele
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Automatische Installation, Konfiguration und Wartung einer großen Anzahl von Systemen mit geringem Aufwand
|
\item Automatische Installation, Konfiguration und Wartung einer großen Anzahl von Systemen mit geringem Aufwand
|
||||||
@ -2096,85 +1746,36 @@
|
|||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
Installationsarten
|
Installationsarten
|
||||||
\begin{itemize*}
|
\begin{description*}
|
||||||
\item Erstinstallation
|
\item[Erstinstallation]
|
||||||
\item Software-Update (Software-Aktualisierung)
|
\item[Software-Update] Aktualisierung der Software, Daten oder Konfiguration
|
||||||
\begin{itemize*}
|
\item[Hotfixes/Service Packs] Nur bestimmte Teile der Software werden aktualisiert; Meist nur Fehlerbehebung, keine neuen Features
|
||||||
\item Aktualisierung der Software, Daten oder Konfiguration
|
\item[Upgrade] Erweitert eine Software deutlich um neue Funktionen
|
||||||
\end{itemize*}
|
\item[Unbeaufsichtigte (automatische)] Installation
|
||||||
\item Hotfixes und Service Packs
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Nur bestimmte Teile der Software werden aktualisiert
|
|
||||||
\item Meist nur Fehlerbehebung, keine neuen Features
|
|
||||||
\end{itemize*}
|
|
||||||
\item Upgrade
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Erweitert eine Software deutlich um neue Funktionen
|
|
||||||
\end{itemize*}
|
|
||||||
\item Unbeaufsichtigte (automatische) Installation
|
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Installation erfolgt ohne Benutzereingriff
|
\item Installation erfolgt ohne Benutzereingriff
|
||||||
\item Periodisch, durch Aufruf des Anwenders, beim Programmstart
|
\item Periodisch, durch Aufruf des Anwenders, beim Programmstart
|
||||||
\item Einstellungen in einem Skript festgelegt oder werden als Parameter übergeben
|
\item Einstellungen in einem Skript festgelegt oder werden als Parameter übergeben
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
\end{itemize*}
|
\end{description*}
|
||||||
|
|
||||||
Installationshilfsmittel
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Installationsprogramm (Installer)
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Windows: Windows Installer, InstallShield
|
|
||||||
\item Linux: RPM, Port, APT
|
|
||||||
\item MAC-OS: Installer, WarpIn
|
|
||||||
\end{itemize*}
|
|
||||||
\item Installations-Script
|
|
||||||
\item Installationsanweisung
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
Software-Rollout
|
Software-Rollout
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Vorgang des Veröffentlichens und Verteilens von Softwareprodukten auf entsprechende Clients
|
\item Vorgang des Veröffentlichens und Verteilens
|
||||||
\item Anzahl der Clients kann weit über 10.000 liegen!
|
\item Rollout abhängig von verschiedenen Kriterien
|
||||||
\item Rollout abhängig von verschiedenen Kriterien (Vorherige Installation, Hardwarekonfiguration, Zeit, Kunde)
|
|
||||||
\item Rollout-Varianten
|
\item Rollout-Varianten
|
||||||
\begin{itemize*}
|
\begin{itemize*}
|
||||||
\item Zentral / Dezentral
|
\item Zentral / Dezentral
|
||||||
\item Manuell (Benutzer löst Installation aus)
|
\item Manuell (Benutzer löst Installation aus)
|
||||||
\item Automatisiert (ohne Benutzerinteraktion)
|
\item Automatisiert (ohne Benutzerinteraktion)
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
\end{itemize*}
|
\item Verteilungsarten
|
||||||
|
\begin{description}
|
||||||
Vollständige Verteilung (big bang)
|
\item[Vollständige Verteilung] (big bang) Alle Installationen werden mit einem Mal installiert (Sehr hohes Risiko)
|
||||||
\begin{itemize*}
|
\item[Rollback] Wiederherstellung des Ursprungszustands
|
||||||
\item Alle Installationen werden mit einem Mal installiert
|
\item[Pilot] Einführung für wenige ausgewählte Installationen (Sehr hohe Sicherheit)
|
||||||
\item Sehr hohes Risiko
|
\item[Iterativ (schrittweise)] mit definierten Anzahl von Installationen bessere Reproduzierbarkeit
|
||||||
\item Eventuelle Fehler führen zu vielen fehlerhaften Zuständen oder Störfällen - führt zu hohem Druck
|
\end{description}
|
||||||
\item Eventuelle Fehler müssen schnell gelöst werden (Provisorium)
|
|
||||||
\item Sehr kurze Einführungsphase
|
|
||||||
\item Rollback-Mechanismus sehr empfohlen
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
Rollback
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Wiederherstellung des Ursprungszustands
|
|
||||||
\item Technische Realisierung muss ermöglicht werden
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
Pilotierte Einführung
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Einführung für wenige ausgewählte Installationen
|
|
||||||
\item Sehr hohe Sicherheit
|
|
||||||
\item Festlegung der späteren Rollout-Schritte
|
|
||||||
\item Benötigt zusätzliche Zeit
|
|
||||||
\item Geringere Auftrittswahrscheinlichkeit von Fehlern
|
|
||||||
\end{itemize*}
|
|
||||||
|
|
||||||
Schrittweise (iterative) Einführung
|
|
||||||
\begin{itemize*}
|
|
||||||
\item Einführung erfolgt schrittweise mit einer definierten Anzahl
|
|
||||||
\item von Installationen (Rampe - ramp-up)
|
|
||||||
\item Höhere Fehlerwahrscheinlichkeit $\rightarrow$ Bessere Reproduzierbarkeit $\rightarrow$ schnelleres Finden von Fehlern $\rightarrow$ Erfahrungsgewinn
|
|
||||||
\item Begrenztes Risiko, mittlerer Zeitaufwand
|
|
||||||
\end{itemize*}
|
\end{itemize*}
|
||||||
|
|
||||||
\newpage
|
\newpage
|
||||||
|
|||||||
Loading…
Reference in New Issue
Block a user