Einführung in die Softwaretechnik - Exam.pdf

Aufgabe 1)

Betrachte zwei sequentielle Entwicklungsprozesse in der Softwaretechnik: das Wasserfallmodell und das V-Modell. Im Wasserfallmodell muss jede der folgenden Phasen abgeschlossen sein, bevor die nächste beginnt: Anforderungsanalyse, Entwurf, Implementierung, Test und Wartung. Das V-Modell erweitert das Wasserfallmodell um eine parallele Struktur, bei der die Phasen der Spezifikation und des Entwurfs auf der linken Seite angeordnet sind und den entsprechenden Testphasen auf der rechten Seite gegenüberstehen. Dabei sind Verifikation und Validierung im V-Modell integriert.

a)

1. Beschreibe das Vorgehen im V-Modell anhand der Spezifikations- und Testphasen, und erläutere wie Verifikation und Validierung dabei integriert werden. Kläre insbesondere, welche Tests den jeweiligen Entwicklungsphasen gegenüberstehen und wie diese durchgeführt werden.

Lösung:

Das V-Modell ist ein sequentielles Modell der Softwareentwicklung, das die Phasen der Spezifikation und des Entwurfs auf der linken Seite und die entsprechenden Testphasen auf der rechten Seite anordnet. Dies soll ein klar strukturiertes Vorgehen ermöglichen. Insbesondere sind in diesem Modell Verifikation und Validierung integriert, um die Qualität des Endprodukts zu gewährleisten.

• Anforderungsanalyse: In dieser Phase werden die Anforderungen an das System gesammelt und spezifiziert. Diese Anforderungen bilden die Grundlage für alle weiteren Entwicklungsaktivitäten.
• Systementwurf: Auf Basis der Anforderungen wird das Gesamtsystem in Hochentwurfs- und Niedrigentwurfphasen zerlegt.
• Implementierung: Hier wird der eigentliche Code geschrieben. Die einzelnen Module werden basierend auf den Entwurfsdokumenten programmiert.
• Modultests: Auf der gegenüberliegenden Seite des V-Modells befinden sich die Testphasen. Für die Implementierung stehen die Modultests direkt gegenüber, bei denen einzelne Programmkomponenten isoliert getestet werden.
• Integrationstests: Diese Tests stehen dem Niedrigentwurf gegenüber. Hier werden mehrere Module zusammengeführt und deren Zusammenspiel getestet.
• Systemtests: Diese Phase steht dem Hochentwurf gegenüber und testet das gesamte System end-to-end gegen die ursprünglichen Anforderungen.
• Abnahmetests: Diese Tests stehen der Anforderungsanalyse gegenüber und überprüfen, ob das endgültige System die Anforderungen erfüllt. In dieser Phase ist die Validierung besonders wichtig, um sicherzustellen, dass das System die Bedürfnisse der Benutzer erfüllt.

Verifikation: Verifikation ist der Prozess der Überprüfung, ob die Software die spezifizierten Anforderungen korrekt umgesetzt wurde. Im V-Modell wird dies durch die Dokumentationen und Spezifikationen in jeder Phase gewährleistet und durchgeführte Tests vor dem nächsten Schritt abgewertet.

Validierung: Validierung ist der Prozess der Bestätigung, dass das gesamte System tatsächlich den erwarteten Nutzen liefert und die Anforderungen des Benutzers erfüllt. Diese findet hauptsächlich in den Abnahmetests statt, wird aber auch durch kontinuierliche Feedback-Schleifen während der gesamten Entwicklung unterstützt.

b)

2. Angenommen, Du möchtest ein mathematisches Modul zur Lösung von quadratischen Gleichungen implementieren. Beschreibe, wie Du das Modul im Rahmen des Wasserfallmodells entwickeln würdest. Folgende Punkte sollen betrachtet werden: Anforderungsanalyse, Entwurf, Implementierung, Test und Wartung. Nenne für jede Phase spezifische Aufgaben und Maßnahmen, die Du durchführen würdest.

Lösung:

Im Wasserfallmodell wird jede Phase vollständig abgeschlossen, bevor die nächste Phase beginnt. Für die Entwicklung eines mathematischen Moduls zur Lösung von quadratischen Gleichungen folgen die Phasen Anforderungsanalyse, Entwurf, Implementierung, Test und Wartung. Hier sind die spezifischen Aufgaben und Maßnahmen, die ich für jede Phase durchführen würde:

• Anforderungsanalyse:
  • Ermittlung und Dokumentation der Anforderungen: Das Modul muss quadratische Gleichungen der Form \(ax^2 + bx + c = 0\) lösen können.
  • Definition der Eingabeparameter: \(a\), \(b\), und \(c\) sollten als Eingabe akzeptiert werden.
  • Festlegung der Ausgabewerte: Die Lösungen der Gleichung (\(x_1\), \(x_2\)) sollen als Ausgabe zurückgegeben werden.
  • Anforderungen an die Fehlerbehandlung: Das Modul muss Fälle berücksichtigen, in denen keine reale Lösung existiert oder \(a = 0\).
• Entwurf:
  • Hochentwurf: Definition der Modularchitektur und Schnittstellen. Festlegung, welche Bibliotheken oder Algorithmen verwendet werden.
  • Niedrigentwurf: Detaillierter Entwurf der Funktionen und Klassen. Implementierung der quadratischen Formel \( x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a} \).
• Implementierung:
  • Codierung der Funktionen und Klassen gemäß dem Entwurf.
  • Schreiben von Unit-Tests für die Implementierung.
  • Dokumentation des Codes für zukünftige Entwickler.
• Test:
  • Unit-Tests: Testen der einzelnen Komponenten, um sicherzustellen, dass sie korrekt funktionieren. Beispiele: Gleichungen mit zwei reellen Lösungen, eine doppelte Lösung und keine reelle Lösung.
  • Integrationstests: Sicherstellen, dass das Modul als Ganzes korrekt funktioniert, wenn es in ein größeres System integriert wird.
  • Systemtests: Testen des gesamten Systems, um sicherzustellen, dass alle Anforderungen an das Modul erfüllt sind.
  • Abnahmetests: Validierung, dass das Modul die Benutzeranforderungen erfüllt.
• Wartung:
  • Behebung von Fehlern: Fehler, die während des Betriebs entdeckt werden, müssen behoben werden.
  • Anpassungen und Verbesserungen: Basierend auf Benutzerfeedback oder neuen Anforderungen könnten Anpassungen und Verbesserungen am Modul vorgenommen werden.
  • Aktualisierung der Dokumentation: Sicherstellen, dass alle Änderungen am Modul auch in der Dokumentation reflektiert sind.

Aufgabe 2)

Betrachten wir eine Software zur Verwaltung einer Bibliothek. In dieser Software gibt es eine Klasse 'Buch', die die Attribute 'Titel', 'Autor' und 'ISBN' sowie die Methode 'anzeigen' enthält, um die Informationen des Buches darzustellen. Zusätzlich gibt es eine Klasse 'Bibliothek', die eine Liste von 'Buch'-Objekten enthält und Methoden zur Verwaltung dieser Liste, wie 'buch_hinzufügen', 'buch_entfernen', und 'alle_buecher_anzeigen'.

a)

Implementiere in Python die Klasse 'Buch' mit den oben beschriebenen Attributen und der Methode 'anzeigen'. Der Konstruktor der Klasse sollte drei Parameter (Titel, Autor und ISBN) entgegennehmen und die entsprechenden Attribute initialisieren.

Lösung:

Hier ist eine mögliche Implementierung der Klasse Buch in Python:

class Buch:    def __init__(self, titel, autor, isbn):        self.titel = titel        self.autor = autor        self.isbn = isbn    def anzeigen(self):        print(f'Titel: {self.titel}')        print(f'Autor: {self.autor}')        print(f'ISBN: {self.isbn}')# Beispiel zur Überprüfung der Funktionalitätbuch = Buch('Der Zauberberg', 'Thomas Mann', '978-3-596-29433-1')buch.anzeigen()

In diesem Code:

• Die Methode __init__ ist der Konstruktor der Klasse. Sie nimmt drei Parameter entgegen: titel, autor und isbn und initialisiert die entsprechenden Attribute der Klasse.
• Die Methode anzeigen gibt die Informationen des Buches in einem lesbaren Format aus.

b)

Implementiere die Klasse 'Bibliothek' in Python. Die Klasse soll eine Liste von 'Buch'-Objekten als Attribut enthalten und die Methoden 'buch_hinzufügen', 'buch_entfernen' und 'alle_buecher_anzeigen' bereitstellen. Stelle sicher, dass die Methode 'buch_hinzufügen' ein Buch-Objekt zur Liste hinzufügt und die Methode 'buch_entfernen' ein Buch-Objekt anhand der ISBN entfernt.

Lösung:

Hier ist eine mögliche Implementierung der Klasse Bibliothek in Python:

class Bibliothek:    def __init__(self):        self.buecher = []    def buch_hinzufügen(self, buch):        self.buecher.append(buch)        print(f'{buch.titel} wurde hinzugefügt.')    def buch_entfernen(self, isbn):        for buch in self.buecher:            if buch.isbn == isbn:                self.buecher.remove(buch)                print(f'{buch.titel} wurde entfernt.')                return        print('Buch mit der angegebenen ISBN nicht gefunden.')    def alle_buecher_anzeigen(self):        if not self.buecher:            print('Es sind keine Bücher in der Bibliothek.')        else:            for buch in self.buecher:                buch.anzeigen()# Beispiel zur Überprüfung der Funktionalitätbuch1 = Buch('Der Zauberberg', 'Thomas Mann', '978-3-596-29433-1')buch2 = Buch('Die Verwandlung', 'Franz Kafka', '978-3-518-32271-4')bibliothek = Bibliothek()bibliothek.buch_hinzufügen(buch1)bibliothek.buch_hinzufügen(buch2)bibliothek.alle_buecher_anzeigen()bibliothek.buch_entfernen('978-3-596-29433-1')bibliothek.alle_buecher_anzeigen()

In diesem Code:

• Die Methode __init__ initialisiert eine leere Liste buecher, die die Buch-Objekte enthält.
• Die Methode buch_hinzufügen fügt das übergebene Buch-Objekt zur Liste hinzu und gibt eine Bestätigung aus.
• Die Methode buch_entfernen entfernt ein Buch-Objekt anhand der angegebenen ISBN aus der Liste. Wenn kein Buch mit der angegebenen ISBN gefunden wird, wird eine entsprechende Nachricht ausgegeben.
• Die Methode alle_buecher_anzeigen gibt alle Bücher in der Bibliothek aus. Wenn keine Bücher vorhanden sind, wird eine entsprechende Nachricht ausgegeben.

c)

Erweitere die Klasse 'Buch' um eine private Methode '__aendern_buch_info', die die Informationen des Buches ändert. Implementiere auch eine öffentliche Methode 'aendern_info', die als Schnittstelle zu dieser privaten Methode dient und die Attribute 'Titel', 'Autor' und 'ISBN' aktualisiert.

Lösung:

Hier ist eine mögliche Erweiterung der Klasse Buch in Python:

class Buch:    def __init__(self, titel, autor, isbn):        self.titel = titel        self.autor = autor        self.isbn = isbn    def anzeigen(self):        print(f'Titel: {self.titel}')        print(f'Autor: {self.autor}')        print(f'ISBN: {self.isbn}')    def __aendern_buch_info(self, titel, autor, isbn):        self.titel = titel        self.autor = autor        self.isbn = isbn    def aendern_info(self, titel, autor, isbn):        self.__aendern_buch_info(titel, autor, isbn)        print('Buchinformationen wurden aktualisiert.')# Beispiel zur Überprüfung der Funktionalitätdas_buch = Buch('Der Zauberberg', 'Thomas Mann', '978-3-596-29433-1')das_buch.anzeigen()das_buch.aendern_info('Eine neue Welt', 'Ein neuer Autor', '123-4-567-89012-3')das_buch.anzeigen()

In diesem Code:

• Die Methode __aendern_buch_info ist eine private Methode, die die Attribute titel, autor und isbn des Buches aktualisiert.
• Die Methode aendern_info dient als öffentliche Schnittstelle zur privaten Methode __aendern_buch_info und ruft diese auf, um die Buchinformationen zu aktualisieren. Sie gibt zudem eine Bestätigungsmeldung aus.

d)

Erstelle eine Unterklasse von 'Buch' namens 'EBook', die ein zusätzliches Attribut 'Dateiformat' enthält und die Methode 'anzeigen' überschreibt, um das Dateiformat mit anzuzeigen. Veranschauliche das Konzept des Polymorphismus, indem Du ein Beispiel erstellst, das zeigt, wie eine Liste von 'Buch'-Objekten, die sowohl 'Buch' als auch 'EBook'-Objekte enthält, durchlaufen und die Methode 'anzeigen' für jedes Objekt aufgerufen wird.

Lösung:

Hier ist eine mögliche Implementierung der Unterklasse EBook und ein Beispiel zur Veranschaulichung des Konzepts des Polymorphismus:

class Buch:    def __init__(self, titel, autor, isbn):        self.titel = titel        self.autor = autor        self.isbn = isbn    def anzeigen(self):        print(f'Titel: {self.titel}')        print(f'Autor: {self.autor}')        print(f'ISBN: {self.isbn}')class EBook(Buch):    def __init__(self, titel, autor, isbn, dateiformat):        super().__init__(titel, autor, isbn)        self.dateiformat = dateiformat    def anzeigen(self):        super().anzeigen()        print(f'Dateiformat: {self.dateiformat}')# Beispiel zur Überprüfung der Funktionalitätbuch1 = Buch('Der Zauberberg', 'Thomas Mann', '978-3-596-29433-1')buch2 = EBook('Die Verwandlung', 'Franz Kafka', '978-3-518-32271-4', 'PDF')buch3 = EBook('1984', 'George Orwell', '978-0-452-28423-4', 'EPUB')# Liste von Buch-Objekten, die sowohl Buch- als auch EBook-Objekte enthältbuecher_liste = [buch1, buch2, buch3]for buch in buecher_liste:    buch.anzeigen()    print('---')

In diesem Code:

• Die Klasse EBook erbt von der Klasse Buch und fügt ein zusätzliches Attribut dateiformat hinzu.
• Die Methode anzeigen wird in der Klasse EBook überschrieben, sodass sie auch das Dateiformat anzeigt.
• Es wird eine Liste von Buch-Objekten erstellt, die sowohl Buch- als auch EBook-Objekte enthält.
• Durch das Konzept des Polymorphismus wird für jedes Objekt in der Liste die Methode anzeigen aufgerufen. Die spezifische Implementierung der Methode anzeigen (entweder von Buch oder EBook) wird entsprechend aufgerufen.

Aufgabe 3)

Unittest und Integrationstest sind zwei häufig eingesetzte Testmethoden in der Softwaretechnik, um die Funktionalität und das Zusammenspiel von Softwarekomponenten sicherzustellen.

• Unit Tests: Testen einzelne, isolierte Softwareeinheiten (Funktionen, Methoden)
• Häufig durch Nutzung von Mock-Objekten
• Tests sollen deterministisch und schnell ausführbar sein
• Beispiele: JUnit für Java, pytest für Python
• Integrationstests: Testen das Zusammenspiel mehrerer, bereits als einzelne Einheiten getesteter Komponenten
• Überprüfen Schnittstellen und Interaktionen zwischen Modulen
• Tests können komplexer und zeitaufwendiger sein
• Beispiel: Verwenden eines bestimmten Frameworks wie Maven Surefire für Java

a)

Betrachte eine Java-Klasse Calculator mit den Methoden add(int a, int b) und divide(int a, int b). Schreibe Unit Tests für diese beiden Methoden unter Verwendung von JUnit. Achte darauf, besondere Fälle wie Division durch Null zu berücksichtigen. Implementiere auch Mock-Objekte, falls sie notwendig sind. Erkläre dabei, wie Unit Tests zur Qualitätssicherung beitragen.

Lösung:

Kontext:Unittest und Integrationstest sind zwei häufig eingesetzte Testmethoden in der Softwaretechnik, um die Funktionalität und das Zusammenspiel von Softwarekomponenten sicherzustellen.

• Unit Tests: Testen einzelne, isolierte Softwareeinheiten (Funktionen, Methoden)
• Häufig durch Nutzung von Mock-Objekten
• Tests sollen deterministisch und schnell ausführbar sein
• Beispiele: JUnit für Java, pytest für Python
• Integrationstests: Testen das Zusammenspiel mehrerer, bereits als einzelne Einheiten getesteter Komponenten
• Überprüfen Schnittstellen und Interaktionen zwischen Modulen
• Tests können komplexer und zeitaufwendiger sein
• Beispiel: Verwenden eines bestimmten Frameworks wie Maven Surefire für Java

Subexercise:Betrachte eine Java-Klasse Calculator mit den Methoden add(int a, int b) und divide(int a, int b). Schreibe Unit Tests für diese beiden Methoden unter Verwendung von JUnit. Achte darauf, besondere Fälle wie Division durch Null zu berücksichtigen. Implementiere auch Mock-Objekte, falls sie notwendig sind. Erkläre dabei, wie Unit Tests zur Qualitätssicherung beitragen. Lösung:

• Definition der Calculator-Klasse:

   public class Calculator {    public int add(int a, int b) {        return a + b;    }    public int divide(int a, int b) throws ArithmeticException {       if (b == 0) {          throw new ArithmeticException('Division durch Null ist nicht erlaubt');       }       return a / b;    } } 

• JUnit Tests für die Calculator-Klasse:

   import static org.junit.jupiter.api.Assertions.*; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test;  public class CalculatorTest {     private Calculator calculator;     @BeforeEach    void setUp() {       calculator = new Calculator();    }      @Test    void testAdd() {       assertEquals(5, calculator.add(2, 3));       assertEquals(0, calculator.add(-2, 2));       assertEquals(-5, calculator.add(-3, -2));    }     @Test    void testDivide() {       assertEquals(2, calculator.divide(4, 2));       assertEquals(-2, calculator.divide(4, -2));       assertEquals(0, calculator.divide(0, 1));    }     @Test    void testDivideByZero() {       assertThrows(ArithmeticException.class, () -> calculator.divide(1, 0));    } } 

• Erklärung zur Qualitätssicherung:
  • Unit Tests helfen dabei, Fehler frühzeitig im Entwicklungsprozess zu erkennen und zu beheben.
  • Sie stellen sicher, dass einzelne Module der Anwendung korrekt funktionieren.
  • Deterministische und schnelle Ausführung der Tests tragen zu einer effizienten Entwicklungs- und Testkultur bei.
  • Besondere Fälle, wie z.B. Division durch Null, werden eigenständig und isoliert überprüft

b)

Projekt XYZ besteht aus drei Modulen: A, B, und C. Modul A ist verantwortlich für Dateneingabe, Modul B führt komplexe Berechnungen durch, und Modul C verwaltet die Ausgabe dieser Daten. Beschreibe, wie Du einen Integrationstest planst, der das Zusammenspiel dieser Module überprüft. Erläutere auch, welche Herausforderungen und Erwartungen dabei berücksichtigt werden müssen, und wie die Tests mithilfe eines Frameworks wie Maven Surefire durchgeführt werden können.

Lösung:

Kontext:Unittest und Integrationstest sind zwei häufig eingesetzte Testmethoden in der Softwaretechnik, um die Funktionalität und das Zusammenspiel von Softwarekomponenten sicherzustellen.

• Unit Tests: Testen einzelne, isolierte Softwareeinheiten (Funktionen, Methoden)
• Häufig durch Nutzung von Mock-Objekten
• Tests sollen deterministisch und schnell ausführbar sein
• Beispiele: JUnit für Java, pytest für Python
• Integrationstests: Testen das Zusammenspiel mehrerer, bereits als einzelne Einheiten getesteter Komponenten
• Überprüfen Schnittstellen und Interaktionen zwischen Modulen
• Tests können komplexer und zeitaufwendiger sein
• Beispiel: Verwenden eines bestimmten Frameworks wie Maven Surefire für Java

Subexercise:Projekt XYZ besteht aus drei Modulen: A, B, und C. Modul A ist verantwortlich für Dateneingabe, Modul B führt komplexe Berechnungen durch, und Modul C verwaltet die Ausgabe dieser Daten. Beschreibe, wie Du einen Integrationstest planst, der das Zusammenspiel dieser Module überprüft. Erläutere auch, welche Herausforderungen und Erwartungen dabei berücksichtigt werden müssen, und wie die Tests mithilfe eines Frameworks wie Maven Surefire durchgeführt werden können. Lösung:

• Planung eines Integrationstests:
  • Alle drei Module (A, B, C) müssen in einer Testumgebung zusammengeführt und ihre Interaktionen überprüft werden.
  • Es wird eine Testreihenfolge festgelegt: Zuerst muss Modul A die Daten eingeben, dann führt Modul B die Berechnungen durch, und schließlich verarbeitet Modul C die Ausgabe.
  • Testfälle müssen entwickelt werden, die sowohl Standard als auch Grenzfälle abdecken (z.B. ungültige Eingaben, extreme Werte).
  • Es sollte klare Kriterien für den Erfolg und Fehler des Tests festgelegt werden.
• Herausforderungen und Erwartungen:
  • Komplexität: Da alle Module zusammen getestet werden, kann es schwierig sein herauszufinden, welche Komponente fehlerhaft ist, wenn etwas schiefgeht.
  • Timing und Synchronisation: Stellen sicher, dass die Module in der richtigen Reihenfolge und zeitlich koordiniert arbeiten.
  • Umgebungseinflüsse: Stellen sicher, dass die Testumgebung die Produktionsumgebung so gut wie möglich simuliert.
  • Erwartung: Alle Module sollten fehlerfrei und effizient zusammenarbeiten.
Maven Surefire zur Durchführung der Integrationstests verwenden:
• Maven Surefire Plugin in der `pom.xml` Konfigurationsdatei einfügen:

   <build>    <plugins>       <plugin>         <groupId>org.apache.maven.plugins</groupId>         <artifactId>maven-surefire-plugin</artifactId>         <version>2.22.2</version>       </plugin>    </plugins> </build> 

• Integrationstests mit JUnit schreiben:

   import static org.junit.jupiter.api.Assertions.*; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test;  public class IntegrationTest {     private ModulA a;    private ModulB b;    private ModulC c;     @BeforeEach    void setUp() {       a = new ModulA();       b = new ModulB();       c = new ModulC();        // Abhängigkeiten konfigurieren und initialisieren    }      @Test    void testIntegration() {       String input = 'Eingabedaten';       String datenA = a.verarbeiten(input);       Ergebnis result = b.berechnen(datenA);       String ausgabe = c.ausgeben(result);        assertNotNull(ausgabe);       assertEquals('Erwartete Ausgabe', ausgabe);    } } 

• Maven Surefire Tests ausführen:

   mvn test

• Erklärung zur Qualitätssicherung: Integrationstests überprüfen das Zusammenspiel verschiedener Module und decken so potenzielle Fehler bei Schnittstellen und Interaktionen auf. Sie sind komplexer als Unit Tests, tragen aber entscheidend zur systemweiten Qualitätssicherung bei.

Aufgabe 4)

Angenommen, Du arbeitest als Softwareentwickler in einem agilen Team, das Scrum als Framework verwendet. Dein Team besteht aus einem Product Owner, einem Scrum Master und dem Entwicklungsteam. Euer aktuelles Projekt erfordert die Implementierung einer neuen Benutzeroberfläche für eine Bankanwendung. Ihr habt beschlossen, zusätzlich einige Prinzipien aus Kanban zu nutzen, um die Arbeit noch effizienter zu gestalten.

a)

a) Erläutere die Hauptaufgaben jeder der drei Scrum-Rollen (Product Owner, Scrum Master, Entwicklungsteam) und analysiere, wie jede Rolle zur Erreichung der Projektziele beiträgt.

Lösung:

Hauptaufgaben und Beitrag der Scrum-Rollen zur Erreichung der Projektziele:

• Product Owner:
  • Hauptaufgaben:
    • Definiert und priorisiert die Produktanforderungen (Product Backlog).
    • Sorgt dafür, dass das Entwicklungsteam genau versteht, was entwickelt werden soll.
    • Trifft Entscheidungen über Produktfunktionen und Release-Daten.
    • Ist das Bindeglied zwischen Stakeholdern und dem Entwicklungsteam.
  • Beitrag zur Erreichung der Projektziele:
    • Stellt sicher, dass das Team an den wichtigsten und wertvollsten Funktionen arbeitet.
    • Verhindert Missverständnisse durch klare Kommunikation der Anforderungen.
• Scrum Master:
  • Hauptaufgaben:
    • Moderiert Scrum-Zeremonien (Daily Standup, Sprint Planning, Sprint Review, Sprint Retrospective).
    • Entfernt Hindernisse, die das Entwicklungsteam beim Arbeiten behindern könnten.
    • Schützt das Team vor unzulässigen Eingriffen von außen.
    • Fördere kontinuierliche Verbesserung der Prozesse im Team.
  • Beitrag zur Erreichung der Projektziele:
    • Ermöglicht dem Team einen reibungslosen und ungestörten Arbeitsprozess.
    • Stellt sicher, dass das Team seine volle Leistung entfalten kann.
    • Fördert eine Kultur der kontinuierlichen Verbesserung.
• Entwicklungsteam:
  • Hauptaufgaben:
    • Entwickelt und testet die neuen Funktionen für das Produkt.
    • Erstellt den benötigten Code und führt Integrationen und Tests durch.
    • Arbeitet selbstorganisiert und eigenverantwortlich.
  • Beitrag zur Erreichung der Projektziele:
    • Setzt die vom Product Owner definierten Anforderungen um.
    • Sorgt für die technische Qualität des Produkts.
    • Reagiert flexibel auf Änderungen und Anforderungen.

b)

b) Beschreibe die verschiedenen Scrum-Ereignisse und ihre Bedeutung für den Projektfortschritt. Wie könnte das Team die Sprint Retrospective nutzen, um Prinzipien aus Kanban zu integrieren?

Lösung:

Scrum-Ereignisse und ihre Bedeutung für den Projektfortschritt:

• Sprint Planning:
  • Bedeutung: Während des Sprint Planning Meetings planen Product Owner und das Entwicklungsteam gemeinsam die Aufgaben, die im nächsten Sprint erledigt werden sollen. Das Team erstellt ein Sprint-Ziel und entscheidet, welche Product Backlog Items (PBIs) in den Sprint Backlog aufgenommen werden.
  • Beitrag zum Projektfortschritt: Dieses Ereignis sorgt für Klarheit über die zu bearbeitenden Aufgaben und stellt sicher, dass das Team auf die wichtigsten Prioritäten fokussiert ist.
• Daily Scrum:
  • Bedeutung: Das Daily Scrum ist ein kurzes tägliches Meeting, in dem das Team den aktuellen Fortschritt bespricht und Hindernisse identifiziert.
  • Beitrag zum Projektfortschritt: Durch die tägliche Abstimmung wird sichergestellt, dass das Team synchron bleibt und schnell auf Probleme reagieren kann.
• Sprint Review:
  • Bedeutung: Am Ende des Sprints präsentiert das Team die abgeschlossene Arbeit den Stakeholdern. Dies bietet die Möglichkeit für Feedback und Anpassungen.
  • Beitrag zum Projektfortschritt: Das Sprint Review stellt sicher, dass das Produkt kontinuierlich verbessert wird und dass alle Stakeholder auf dem Laufenden gehalten werden.
• Sprint Retrospective:
  • Bedeutung: Während der Sprint Retrospective reflektiert das Team über den vergangenen Sprint und identifiziert Verbesserungsmöglichkeiten für den nächsten Sprint.
  • Beitrag zum Projektfortschritt: Feedback und kontinuierliche Verbesserung sind essentiell, um die Effektivität und Effizienz des Teams zu steigern.

Integration von Kanban-Prinzipien in der Sprint Retrospective:

• Während der Sprint Retrospective kann das Team überlegen, wie Kanban-Prinzipien wie die Visualisierung von Arbeitsabläufen oder Work-in-Progress (WIP) Limits in die aktuelle Scrum-Arbeitsweise integriert werden können.
• Visualisierung des Workflows: Das Team könnte beispielsweise ein Kanban-Board nutzen, um den aktuellen Stand der Aufgaben im Sprint sichtbar zu machen.
• Work-in-Progress (WIP) Limits: Durch die Einführung von WIP Limits kann das Team sicherstellen, dass es nicht zu viele Aufgaben gleichzeitig bearbeitet, was die Qualität und Fokussierung verbessern kann.
• Kontinuierliche Verbesserung: In der Retrospective kann das Team auch diskutieren, wie es kontinuierlich Engpässe identifizieren und beseitigen kann, ähnlich wie im Kanban-Ansatz.

c)

c) Da Ihr Elemente von Kanban nutzt, erklärt, wie die Visualisierung der Arbeit mithilfe eines Kanban-Boards funktionieren würde. Diskutiere, wie die Begrenzung des WIP (Work in Progress) die Effizienz des Teams beeinflussen könnte.

Lösung:

Visualisierung der Arbeit mit einem Kanban-Board:

• Ein Kanban-Board ist ein visuelles Hilfsmittel, das den Arbeitsfluss darstellt. Es besteht typischerweise aus Spalten, die verschiedene Phasen des Arbeitsablaufs repräsentieren, z.B., „Zu erledigen“, „In Arbeit“ und „Erledigt“.
• Jedes Arbeitselement oder jede Aufgabe wird als eine Karte auf dem Kanban-Board dargestellt. Diese Karten bewegen sich von links nach rechts durch die verschiedenen Phasen, wenn die Arbeit fortschreitet.
• Zusätzliche Informationen wie Priorität, Verantwortliche Person oder Fälligkeitsdatum können auf den Karten vermerkt werden, um Klarheit zu schaffen.

Begrenzung des Work in Progress (WIP) und deren Effekte auf die Effizienz des Teams:

• WIP Limits festlegen: Das Team setzt Grenzen für die maximale Anzahl der Aufgaben, die gleichzeitig in einer bestimmten Phase des Arbeitsflusses bearbeitet werden dürfen.
• Fokussierung und Priorisierung: WIP Limits zwingen das Team, sich auf eine geringere Anzahl von Aufgaben zu konzentrieren, wodurch die Priorisierung und die Vollendung bestehender Arbeiten vor der Annahme neuer Aufgaben gefördert werden.
• Minimierung des Kontextwechsels: Da weniger Aufgaben gleichzeitig bearbeitet werden, kann jeder Teammitglied seine Energie auf weniger Aufgaben konzentrieren. Dies reduziert den Zeit- und Energieaufwand für den Wechsel zwischen Aufgaben.
• Verbesserte Problemerkennung: Wenn zu viele Aufgaben „In Arbeit“ stagnieren, wird dies auf dem Kanban-Board schnell sichtbar. Das Team kann dann mögliche Engpässe oder Blockaden identifizieren und adressieren.
• Erhöhte Durchlaufzeiten: Mit WIP Limits wird die Zeit, die eine Aufgabe benötigt, um von „Zu erledigen“ zu “Erledigt“ zu wechseln, kürzer. Dies führt zu einer schnelleren und konstante Lieferung von Arbeitsergebnissen.
• Kontinuierliche Verbesserung: Das regelmäßige Überprüfen und Anpassen von WIP Limits basierend auf den Erfahrungen des Teams kann dazu führen, dass der Arbeitsfluss kontinuierlich optimiert wird.

d)

d) Angenommen, das Team möchte eine kontinuierliche Verbesserung sicherstellen. Entwickle eine mathematische Methode zur Messung der Effizienz des Arbeitsflusses im Projekt. Nutze dabei Konzepte wie ‘Durchsatz’ (Anzahl der abgeschlossenen Aufgaben pro Zeiteinheit) und ‘Cycle Time’ (Zeit von Beginn bis zur Fertigstellung einer Aufgabe). Formuliere Deine Antwort mit entsprechenden Formeln.

Lösung:

Entwicklung einer mathematischen Methode zur Messung der Effizienz des Arbeitsflusses:

Um die Effizienz des Arbeitsflusses im Projekt zu messen, können wir folgende Metriken verwenden:

• Durchsatz (Throughput):
  • Der Durchsatz misst die Anzahl der abgeschlossenen Aufgaben pro Zeiteinheit (z.B. pro Woche).
  • Formel:
  • \[ Durchsatz = \frac{Anzahl\ der\ abgeschlossenen\ Aufgaben}{Zeiteinheit} \]
• Zykluszeit (Cycle Time):
  • Die Zykluszeit misst die Zeitspanne, die eine Aufgabe benötigt, um von Beginn bis zur Fertigstellung zu gelangen.
  • Formel:
  • \[ Zykluszeit = Endzeitpunkt\ der\ Aufgabe - Startzeitpunkt\ der\ Aufgabe \]

Verwendung von Little’s Law

Das Little’s Law beschreibt eine grundlegende Beziehung zwischen der Anzahl der Aufgaben (WIP - Work in Progress), dem Durchsatz und der Zykluszeit:

• • \[ WIP = Durchsatz \times Zykluszeit \]

Diese Beziehung hilft zu verstehen, wie Änderungen in einer Variablen die anderen Variablen beeinflussen.

Ansätze zur kontinuierlichen Verbesserung:

• Mittelwert der Zykluszeit: Berechne den Durchschnitt der Zykluszeiten aller abgeschlossenen Aufgaben:
• \[ Durchschnittliche\ Zykluszeit = \frac{Summe\ aller\ Zykluszeiten}{Anzahl\ der\ abgeschlossenen\ Aufgaben} \]
• Varianz der Zykluszeit: Um die Streuung und Unstetigkeiten im Arbeitsablauf zu erkennen, kann die Varianz der Zykluszeiten berechnet werden:
• \[ Varianz = \frac{1}{N} \sum_{i=1}^{N} (Zykluszeit_i - Durchschnittliche\ Zykluszeit)^2 \]

Mit diesen Metriken kann das Team die Effizienz seines Arbeitsflusses regelmäßig überwachen und kontinuierliche Verbesserungen vornehmen. Ziel ist es, den Durchsatz zu erhöhen und die Zykluszeit zu verringern, um eine schnellere und effektivere Bearbeitung der Aufgaben zu gewährleisten.