kramann.info
© Guido Kramann

Login: Passwort:










Robuste Systemintegration
1 Grundlagen
..1.1 Newton
....1.1.1 LinearSchwinger
....1.1.2 Daempfung
....1.1.4 ODE
....1.1.5 Saaluebung
..1.2 NewtonEuler
....1.2.1 Traegheitsmomente
....1.2.2 Modellgleichungen
....1.2.3 Einfachpendel
..1.3 Scilab
....1.3.1 Erste_Schritte
....1.3.2 Skripte
....1.3.3 Funktionen
..1.4 Laplace
....1.4.1 Eigenwerte
....1.4.2 PT1
..1.5 Regleroptimierung
....1.5.1 Guetefunktion
....1.5.2 Heuristiken
....1.5.3 Scilab
..1.6 Einstellregeln
....1.6.1 Totzeit
....1.6.2 Methode1
....1.6.3 Methode2
....1.6.4 Scilab
..1.7 Zustandsregler
..1.8 Polvorgabe
..1.8 Polvorgabe_alt
..1.9 Beobachter
....1.9.1 Haengependel
..1.10 Daempfungsgrad
..1.11 Processing
....1.11.1 Installation
....1.11.2 Erste_Schritte
....1.11.3 Mechatronik
....1.11.4 Bibliotheken
....1.11.5 Uebung
....1.11.6 Snippets
......1.11.6.1 Dateioperationen
......1.11.6.2 Bilder
......1.11.6.3 GUI
......1.11.6.4 Text
......1.11.6.5 PDF
......1.11.6.8 Maus
......1.11.6.10 Zeit
......1.11.6.13 Animation
......1.11.6.15 Simulation
....1.11.7 Referenzen
..1.12 Breakout
2 Beispiel
3 Beispielloesung
4 Praxis
5 javasci
6 Fehlertoleranz1
7 Reglerentwurf
..7.1 Sprungantwort
..7.2 Messdaten
..7.3 Systemidentifikation
..7.4 Polvorgabe
..7.5 Beobachter
..7.6 Robuster_Entwurf
..7.7 SIL
8 Systementwicklung
9 Arduino
..9.1 Lauflicht
..9.2 Taster
..9.3 Sensor
..9.12 Motor_PWM1
..9.13 Motor_PWM2_seriell
..9.14 Motor_PWM3_analogWrite
..9.15 Scheduler
..9.20 AV
..9.21 Mikrofon
..9.22 Universal
....9.22.1 Laborplatine
....9.22.2 LED_Leiste
....9.22.3 Motortreiber
....9.22.4 Sensoreingaenge
....9.22.5 Taster
....9.22.6 Tests
....9.22.7 Mikrofon
....9.22.8 Lautsprecher
....9.22.9 Fahrgestell
..9.23 Zauberkiste
..9.24 OOP
....9.24.1 Uebungen
..9.25 AVneu
....9.25.1 Tests
..9.26 DA_Wandler
..9.27 CompBoard
....9.27.1 Tastenmatrix
....9.27.2 ASCIIDisplay
..9.28 CTC
..9.29 Tonerzeugung
10 EvoFuzzy
..10.1 Fuzzy
....10.1.1 Fuzzylogik
....10.1.2 FuzzyRegler
....10.1.3 Uebung9
....10.1.5 Softwareentwicklung
......10.1.5.1 AgileSoftwareentwicklung
......10.1.5.2 FuzzyRegler
......10.1.5.3 Uebung
....10.1.6 Umsetzung
......10.1.6.1 FuzzyRegler
......10.1.6.2 Simulation
......10.1.6.3 Optimierung
......10.1.6.4 Uebung
....10.1.7 Haengependel
......10.1.7.1 Haengependel
......10.1.7.2 Simulation
......10.1.7.3 FuzzyRegler
......10.1.7.4 Optimierer
......10.1.7.5 Genetisch
....10.1.8 Information
....10.1.9 Energie
..10.2 Optimierung
....10.2.1 Gradientenverfahren
....10.2.2 Heuristiken
....10.2.3 ModifizierteG
....10.2.4 optim
..10.3 Genalgorithmus
..10.4 NeuronaleNetze
....10.4.1 Neuron
....10.4.2 Backpropagation
....10.4.3 Umsetzung
....10.4.4 Winkelerkennung
..10.5 RiccatiRegler
11 Agentensysteme
12 Simulation
20 Massnahmen
21 Kalmanfilter
..21.1 Vorarbeit
..21.2 Minimalversion
..21.3 Beispiel
30 Dreirad
31 Gleiter
..31.1 Fehlertoleranz
80 Vorlesung_2014_10_01
81 Vorlesung_2014_10_08
82 Vorlesung_2014_10_15
83 Vorlesung_2014_10_22
84 Vorlesung_2014_10_29
10.1.5.1 Agile Softwareentwicklung

Das folgende Kapitel entstand aufgrund eines Fachgespräches mit Dr.-Ing. Dipl. Inform. Uwe Gühl, der gerade in Zusammenarbeit mit Dipl. Volkswirt Daud Alam ein Buch zu Projektmanagement erstellt. Das Buch soll unter dem Titel "Projektmanagement praxisnah" veröffentlicht werden.

Ein großes Problem in der Softwareentwicklung ist die Bewältigung der hohen Komplexität der zu entwickelnden Software. Bleiben auf dem Weg zum Endprodukt Tests von Einzelkomponenten aus, so passiert es häufig, dass nach einer längeren Entwicklungszeit das Projekt erfolglos abgebrochen werden muss.

Das Wesentliche bei der Agilen Softwareentwicklung sind deshalb zwei Dinge:

  1. Die Verwendung von Timeboxen (Sprints) - das sind quasi fix vorgegebene äquidistante Meilensteine,
  2. die Vereinbarung auf jeder Entwicklungsstufe der Software einen prinzipiell auslieferbaren Stand zu haben.

Insbesondere durch die Vereinbarung, auf jeder Entwicklungsstufe der Software funktionstüchtigen Code zu generieren wird die oben beschriebene "Komplexitätsfalle" gemieden.

Scrum

Eine weit verbreitete Spielart für "Agile Softwareentwicklung" ist die Scrum-Methode. Der Begriff Scrum kommt aus dem amerikanischen Football und stellt die Situation dar, in der sich die Manschaften bei Beginn des Spiels gegenüberstehen. Am einfachsten ist sie durch Spezifizierung der verschiedenen Rollen zu verstehen, die von den Projektteilnehmern eingenommen werden.

Product owner
  • Sie/Er formuliert und priorisiert so genannte "User stories".
  • Diese nehmen den Platz der Meilensteine ein und definieren einen Mehrwert für den Kunden, der am Ende der nächsten Timebox durch eine Implementierung vorhanden sein soll.
  • Beispiel: "Wenn diese User story umgesetzt ist, kann ich mich als User im System registrieren, um Kontodaten zu sehen."
  • Die Abnahme einer User story erfolgt durch den Product owner.
Scrum-Master
  • Sie/Er stellt den Prozess sicher.
  • Sie/Er sorgt dafür dass das Team arbeiten kann und moderiert den Scrum-Prozess.
Das Entwicklerteam
  • Das Entwicklerteam leitet gemeinsam Tasks (Aufgaben) aus den "User stories" ab.
  • Das Entwicklerteam setzt die Tasks um.
Rollen beim Software-Entwicklungsprozeß nach der Scrum-Methode.

Bild 10.1.5.1-1: Rollen beim Software-Entwicklungsprozeß nach der Scrum-Methode (T1..Tn: Tasks/Aufgaben).

Ablauf eines Scrum basierten Projektes:

Vorarbeit
  • Der Product owner formuliert alle User stories. Diese Gesamtheit der User stories wird Backlog genannt.
Sprint Planung
  • Der Product Owner priorisiert/identifiziert User stories aus dem Backlog heraus, die im aktuellen Sprint umgesetzt werden sollten.
  • Der Product Owner legt zu jeder User story Abnahmekriterien fest (definition of done).
  • Das Team nennt seine freie Zeit für den aktuellen Sprint.
  • Die für den aktuellen Sprint ausgewählten User stories werden in Tasks aufgegliedert, deren Gesamtdauer abgeschätzt wird (planing poker).
  • Es werden soviele User stories für einen Sprint geplant, wie in die aktuelle Timebox hineinpassen.
Sprint Abschluß
  • Vorstellung des lauffähigen Codes
  • Abnahme der User stories durch den Product owner anhand der vereinbarten Abnahmekriterien
  • Thematisierung dessen, was gegenüber dem vorangehenden Sprint verbessert wurde (lessons learned)
daily scrum
  • Ziel: sich gegenseitig über den Stand der Arbeiten zu informieren und ggf. zusätzlich notwendige Aktivitäten zu definieren (ev. Vereinbarung nachfolgender bilateraler Gespräche).
  • Umhängen der Tasks am Task planungs board.
  • Ablauf des Treffens: Alle stehen und jedes Teammitglied äußert sich zu den Punkten:
  • - Wie geht es mir?
  • - Was habe ich getan (seit gestern)?
  • - Was werde ich tun (bis morgen)?
Taskplanungs-Board: Beim daily scrum werden die Tasks durchgesprochen und umgehangen von

Bild 10.1.5.1-2: Taskplanungs-Board: Beim daily scrum werden die Tasks durchgesprochen und umgehangen von "initial" nach "in Arbeit", oder von "in Arbeit" nach "fertig".

Besonderheiten der Scrum-Methode

  • Primäres Ziel bei Scrum ist es die innerhalb eines Sprints vereinbarten User stories umzusetzen.
  • Stellt sich im Sprint-Abschlussmeeting heraus, dass einige User stories nicht oder unvollständig umgesetzt wurden, so fließt dies in die Planung des nächsten Sprints ein.
  • Jedes Teammitglied sollte jeden Task bearbeiten können, jeder sollte alles können.
  • Jeder gibt bei der Sprint Planung an, wieviel Zeit er hat.
  • Während eines Sprints wird nur an den vereinbarten Tasks gearbeitet. Korrekturen an der Verteilung der User stories auf die Timeboxes erfolgen nur in den Sprint Abschlußmeetings.

Mock

Nicht immer kann die Entwicklung so geplant werden, dass immer "User stories" formuliert werden können, die direkt produktiv einsetzbare Softwaremodule repräsentieren. Um dennoch das Paradigma der Agilen Softwareentwicklung an den Meilensteinen stets funktionierende Software vorliegen zu haben einzuhalten, wird oft die Anwendung des aktuell entwickelten Moduls simuliert.

Soll beispielsweise der zu entwickelnde Fuzzy-Regler für den Antrieb einer Laufkatze eingesetzt werden, so kann der "Mock" in einer Simulation der Laufkatze bestehen. Oft werden Mocks aber wesentlich einfacher konzipiert, als die reale Anwenderseite. So kann es in diesem Beispiel genügen, definierte Signale an den Regler zu geben, auf die die zu erwartende Reaktion bekannt ist.

Äquivalenzklassen

Auf einer viel niedrigen Ebene speziell für prozedurale Programme, gibt es die Testmethode der Äquivalenzklassen. Hier wird ein Softwaretest so durchgeführt, dass sämtliche Programmzweige des untersuchten Programms durchlaufen werden.

Testunit

Im Zeitalter der Objektorientierung würde man zum Testen einzelner Klassen Testunits generieren. Ganz im Sinne der Äquivalenzklassen sollten auch hier alle möglichen auftretenden Fälle für die Art und Weise, wie die Objkte der Klasse benutzt werden können getestet werden.

In unserem Fall (Java) bietet es sich an innerhalb der zu testenden Klasse eine main-Methode einzubauen, die Objekte der Klasse erzeugt und austestet.