Grundlagen des Software Engineering - Exam

Aufgabe 1)

Betrachte das Wasserfallmodell als Vorgehensmodell in der Softwareentwicklung. Es wird sequentiell von einer Phase zur nächsten übergegangen: Anforderungsanalyse, Entwurf, Implementierung, Testen, Einführung und Wartung. Jede Phase muss abgeschlossen sein, bevor die nächste beginnt, wobei Rücksprünge zwar möglich, aber teuer sind. Das Wasserfallmodell ist dokumentationsgetrieben und eignet sich gut für Projekte mit klaren und stabilen Anforderungen.

a)

(a) Nenne und beschreibe kurz jede der Phasen des Wasserfallmodells. Erläutere die Hauptaktivitäten und Ziele jeder Phase.

Lösung:

(a) Nenne und beschreibe kurz jede der Phasen des Wasserfallmodells. Erläutere die Hauptaktivitäten und Ziele jeder Phase.

• Anforderungsanalyse (Requirements Analysis): In dieser Phase werden die Anforderungen des Kunden oder Auftraggebers an die Software detailliert erfasst und dokumentiert. Die Hauptaktivitäten umfassen das Sammeln von Informationen, das Erstellen von Anforderungsdokumenten und das Einholen von Genehmigungen. Das Ziel ist es, ein klares Verständnis der Erwartungen und Anforderungen des Kunden zu erhalten.
• Entwurf (Design): Ziel dieser Phase ist es, auf Basis der gesammelten Anforderungen eine System- und Softwarearchitektur zu entwerfen. Die Hauptaktivitäten umfassen das Erstellen von Systemmodellen, Diagrammen und Spezifikationen, die die Struktur und das Verhalten des Systems beschreiben. Hier werden auch technische Details, Schnittstellen und Datenbanken spezifiziert.
• Implementierung (Implementation): In dieser Phase wird der eigentliche Code geschrieben. Die Entwickler programmieren die Software gemäß den in der Entwurfsphase erstellten Spezifikationen. Die Hauptaktivitäten umfassen das Schreiben von Code, das Erstellen von Modulen und Komponenten sowie das Zusammenfügen dieser Module zu einem funktionierenden System.
• Testen (Testing): Die Hauptaktivitäten in dieser Phase beinhalten das Testen der implementierten Software, um sicherzustellen, dass sie den Anforderungen entspricht und frei von Fehlern ist. Dies umfasst Einheitentests, Integrationstests, Systemtests und Abnahmetests. Das Ziel ist es, die Qualität und Funktionstüchtigkeit der Software zu prüfen und sicherzustellen.
• Einführung (Deployment): In dieser Phase wird die getestete Software an den Kunden ausgeliefert und in der Produktionsumgebung installiert. Die Hauptaktivitäten umfassen die Installation der Software, die Durchführung von Benutzertraining und die Erstellung der notwendigen Dokumentationen. Das Ziel ist es, die Software einsatzfähig zu machen und sicherzustellen, dass die Benutzer sie effektiv nutzen können.
• Wartung (Maintenance): Nach der Einführung wird die Software regelmäßig gewartet und bei Bedarf aktualisiert. Die Hauptaktivitäten umfassen das Beheben von Fehlern, das Hinzufügen neuer Funktionen und das Anpassen der Software an geänderte Anforderungen oder Umgebungen. Das Ziel ist es, die Software stabil und aktuell zu halten.

b)

(b) Ein Softwareprojekt hat während der Implementierungsphase signifikante Änderungen der Anforderungen erfahren. Diskutiere die Herausforderungen und Auswirkungen der Rücksprünge im Wasserfallmodell bei solchen Änderungen während der Implementierungsphase. Welche Kosten und Risiken sind damit verbunden?

Lösung:

(b) Ein Softwareprojekt hat während der Implementierungsphase signifikante Änderungen der Anforderungen erfahren. Diskutiere die Herausforderungen und Auswirkungen der Rücksprünge im Wasserfallmodell bei solchen Änderungen während der Implementierungsphase. Welche Kosten und Risiken sind damit verbunden?

• Herausforderungen und Auswirkungen der Rücksprünge:
  • Erheblicher Zeitverlust: Signifikante Änderungen der Anforderungen während der Implementierungsphase können dazu führen, dass die Arbeit bis zu diesem Punkt ist, zumindest teilweise, neu gemacht werden muss. Dies verursacht erhebliche Verzögerungen im Projektfortschritt.
  • Erhöhte Projektkosten: Durch den zusätzlichen Aufwand für die erneute Anforderungsanalyse, den Entwurf und die Implementierung steigen die Projektkosten. Es entstehen Kosten für zusätzliche Arbeitsstunden, Ressourcen und möglicherweise auch Werkzeuge.
  • Qualitätsrisiken: Durch die ständigen Änderungen kann die Qualität des Endproduktes leiden. Da Zeit und Ressourcen für die Umsetzung neuer Anforderungen aufgewendet werden, könnte die Zeit für gründliche Tests und Qualitätskontrollen reduziert werden. Dies erhöht das Risiko von Fehlern oder unvollständigen Funktionen.
  • Komplexitätsmanagement: Da das Wasserfallmodell ein sequentielles Modell ist, ist es schwierig, auf spätere Phasen zurückzukehren und Änderungen vorzunehmen, ohne die gesamte Struktur und Dokumentation zu überarbeiten.
  • Erschwerte Kommunikation: Veränderungen in Anforderungen während der Implementierungsphase können zu Missverständnissen zwischen Entwicklern, Kunden und anderen Stakeholdern führen. Es ist notwendig, eine effektive und ständige Kommunikation aufrechtzuerhalten, um sicherzustellen, dass alle Beteiligten über Änderungen informiert und einverstanden sind.
  • Motivationsverlust: Die Notwendigkeit, bereits abgeschlossene Arbeiten erneut durchzuführen, kann die Motivation und Moral des Projektteams beeinträchtigen.
• Kosten und Risiken:
  • Kosten: - Zusätzliche Personalkosten für die erneute Durchführung der Analyse, des Entwurfs und der Implementierung. - Höhere Testkosten, da alle Änderungen gründlich geprüft werden müssen. - Potenzielle Zusatzkosten für Werkzeuge oder externe Berater.
  • Risiken: - Projektzeitplan-Risiko: Es besteht ein hohes Risiko, den geplanten Zeitrahmen nicht einhalten zu können, was zu Verzögerungen bei der Einführung der Software führen kann. - Budgetüberschreitung: Aufgrund der unerwarteten Änderungen und des zusätzlichen Aufwands besteht eine hohe Wahrscheinlichkeit, dass das Projektbudget überschritten wird. - Risiko von Qualitätseinbußen: Die Notwendigkeit, Änderungen schnell umzusetzen, kann zu einer oberflächlichen Testphase führen und somit die Qualität des Endprodukts beeinträchtigen. - Stakeholder-Zufriedenheit: Häufige Änderungen und Verzögerungen können das Vertrauen und die Zufriedenheit der Stakeholder mindern und potenziell zu Konflikten führen.

Aufgabe 2)

Du arbeitest als Softwareentwickler in einem Team, das die Agile Methoden Scrum und Kanban verwendet, um Projekte effizient und flexibel zu gestalten. Dein Team hat kürzlich ein neues Softwareprojekt initiiert und es ist geplant, dass es innerhalb von sechs Monaten abgeschlossen wird. Es wird entschieden, Scrum für dieses Projekt zu verwenden.

a)

Beschreibe die verschiedenen Rollen innerhalb des Scrum-Teams und erläutere die Verantwortlichkeiten jeder Rolle. Veranschauliche Deine Beschreibung mit Beispielen aus dem Projektkontext.

Lösung:

In Scrum gibt es drei Hauptrollen: Product Owner, Scrum Master und Entwicklungs-Team. Jede dieser Rollen hat spezifische Verantwortlichkeiten:

• Product Owner:
  • Verantwortlichkeiten: Der Product Owner ist verantwortlich für das Produkt-Backlog, die Priorisierung der Aufgaben und die Sicherstellung, dass das Team an den wertvollsten Features arbeitet. Er vertritt die Interessen der Stakeholder und des Kunden.
  • Beispiel im Projektkontext: In Deinem neuen Softwareprojekt würde der Product Owner die Anforderungen und Wünsche der Stakeholder sammeln und die Aufgaben im Produkt-Backlog priorisieren. Er sorgt dafür, dass das Team sich zunächst auf die wichtigsten Features konzentriert, wie z.B. die Benutzerregistrierung und Authentifizierung, bevor es sich anderen Aufgaben wie der Implementierung der Benachrichtigungsfunktionen widmet.
• Scrum Master:
  • Verantwortlichkeiten: Der Scrum Master unterstützt das Team dabei, den Scrum-Prozess zu befolgen und Hindernisse zu beseitigen, die den Fortschritt behindern könnten. Er fördert die Zusammenarbeit und sorgt für ein Umfeld, in dem das Team effizient arbeiten kann.
  • Beispiel im Projektkontext: Wenn das Team auf technische Schwierigkeiten stößt, wie beispielsweise Integrationsprobleme mit einem externen API, würde der Scrum Master eingreifen, um dieses Hindernis zu beseitigen. Zudem würde er regelmäßig Retrospektiven abhalten, um kontinuierliche Verbesserungen im Entwicklungsprozess zu ermöglichen.
• Entwicklungs-Team:
  • Verantwortlichkeiten: Das Entwicklungs-Team ist für die praktische Umsetzung der Aufgaben im Produkt-Backlog verantwortlich. Das Team plant und führt die Sprints durch, erstellt und testet die Software-Inkremente.
  • Beispiel im Projektkontext: Innerhalb eines Sprints könnte das Entwicklungs-Team Aufgaben wie das Design der Benutzeroberfläche, das Schreiben von Backend-Code oder das Testen neuer Features übernehmen. Beispielsweise könnten sie in einem Sprint die Benutzerregistrierung implementieren und in einem nächsten Sprint die Authentifizierungslogik hinzufügen und testen.

b)

Im ersten Monat des Projekts fanden vier Sprints statt. Beschreibe die wichtigsten Scrum Events, die in jedem Sprint durchgeführt wurden, inklusive Ziele und Ergebnisse von jedem Event.

Lösung:

In Scrum gibt es mehrere wichtige Events, die in jedem Sprint durchgeführt werden. Diese Events sind essenziell für den reibungslosen Ablauf und den Erfolg des Scrum-Prozesses. Hier sind die wichtigsten Scrum-Events sowie deren Ziele und erwartete Ergebnisse:

• Sprint Planning:
  • Ziel: Das Ziel des Sprint Planning-Meetings ist es, die Arbeit für den nächsten Sprint zu planen. Das gesamte Team, einschließlich des Product Owners, des Scrum Masters und des Entwicklungsteams, nimmt daran teil.
  • Ergebnisse: Das Team erstellt ein Sprint-Ziel und wählt die Aufgaben aus dem Produkt-Backlog aus, die im nächsten Sprint abgeschlossen werden sollen. Ein klarer Plan für die Durchführung der Aufgaben wird aufgestellt.
  • Beispiel Erster Sprint: Im ersten Sprint könnte das Ziel sein, die grundlegende Infrastruktur der Software aufzubauen, einschließlich der Einrichtung der Entwicklungsumgebung und des Versionskontrollsystems.
• Daily Scrum:
  • Ziel: Tägliche Synchronisationsmeeting, bei dem jedes Teammitglied berichtet, was es seit dem letzten Daily Scrum getan hat, was es bis zum nächsten tun wird und welche Hindernisse es gibt.
  • Ergebnisse: Transparenz im Team, Erkennen und Beseitigen von Hindernissen, Anpassung des Plans, falls notwendig.
  • Beispiel: Ein Entwickler könnte berichten, dass er Probleme mit einer API-Integration hat, woraufhin der Scrum Master Unterstützung organisiert, um das Hindernis zu beseitigen.
• Sprint Review:
  • Ziel: Überprüfung der während des Sprints geleisteten Arbeit. Das Team stellt die fertigen Features dem Product Owner und anderen Stakeholdern vor.
  • Ergebnisse: Feedback von den Stakeholdern, Validierung der fertigen Arbeit, mögliche Anpassungen des Produkt-Backlogs.
  • Beispiel Dritter Sprint: Nach Abschluss des dritten Sprints könnte das Team eine funktionsfähige Benutzerregistrierung und eine grundlegende Authentifizierungslogik präsentieren.
• Sprint Retrospective:
  • Ziel: Reflexion über den letzten Sprint, Identifikation von Verbesserungsmöglichkeiten und Erstellung eines Aktionsplans für den nächsten Sprint.
  • Ergebnisse: Konkrete Maßnahmen zur Prozessverbesserung, gestärktes Teamverständnis und besserer Workflow.
  • Beispiel Vierter Sprint: Während der Retrospektive nach dem vierten Sprint könnte das Team beschließen, die Kommunikation im Daily Scrum zu verbessern und die Code-Review-Prozesse zu optimieren.

c)

Erkläre, wie das Product Backlog und das Sprint Backlog in Deinem Projekt verwaltet werden. Wie können diese Backlogs effektiv genutzt werden, um den Projektfortschritt zu verfolgen und Änderungen flexibel zu integrieren?

Lösung:

Das Product Backlog und das Sprint Backlog sind zentrale Elemente im Scrum-Framework. Sie dienen dazu, alle Anforderungen und Aufgaben des Projekts zu verwalten und den Fortschritt zu verfolgen.

• Product Backlog:
  • Definition: Eine priorisierte Liste von Features, Verbesserungen, Fehlerbehebungen und weiteren Arbeiten, die im Projekt erledigt werden müssen. Der Product Owner ist für die Pflege des Product Backlogs verantwortlich.
  • Verwaltung:
    • Der Product Owner sammelt Anforderungen von Stakeholdern und fügt sie dem Product Backlog hinzu.
    • Jede Eintragung wird nach Priorität sortiert, sodass die wichtigsten Aufgaben ganz oben stehen.
    • Jede Aufgabe wird detailliert beschrieben, um dem Entwicklungsteam eine klare Vorstellung zu geben.
    • Das Backlog wird kontinuierlich aktualisiert, basierend auf Feedback und neuen Erkenntnissen.
    • Beispiel: Bei Deinem neuen Softwareprojekt könnten wichtige Punkte im Product Backlog die Benutzerregistrierung, Authentifizierungslogik, und Benachrichtigungsfunktionen sein.
  • Effektive Nutzung:
    • Regelmäßige Grooming- bzw. Refinement-Sitzungen sicherstellen, dass das Product Backlog stets aktuell und gut strukturiert ist.
    • Transparente Kommunikation zwischen Product Owner und Entwicklungsteam, um Missverständnisse zu vermeiden.
• Sprint Backlog:
  • Definition: Eine Liste von Aufgaben, die das Team in einem bestimmten Sprint bearbeiten will. Es wird aus dem Product Backlog abgeleitet.
  • Verwaltung:
    • Während des Sprint Planning Meetings wählt das Team die Aufgaben aus dem Product Backlog aus, die sie im nächsten Sprint bearbeiten wollen.
    • Diese Aufgaben werden in kleinere, ausführbare Schritte unterteilt und dem Sprint Backlog hinzugefügt.
    • Das Team verfolgt täglich den Fortschritt, z.B. durch Burndown Charts und Task Boards.
    • Beispiel: Wenn das Ziel des ersten Sprints die Implementierung der Benutzerregistrierung ist, enthält das Sprint Backlog alle dafür notwendigen Aufgaben, wie Design der Datenbank, Implementierung des Front- und Backends, sowie Testen der Funktionalität.
  • Effektive Nutzung:
    • Tägliche Updates im Daily Scrum, um den Fortschritt zu überwachen und Anpassungen vorzunehmen.
    • Aufgaben bei Bedarf umpriorisieren oder den Arbeitsumfang eines Sprints anpassen, um flexibel auf auftretende Probleme oder Änderungen zu reagieren.
• Projektfortschritt verfolgen und Änderungen integrieren:
  • Regelmäßige Überprüfung: Sprint Reviews und Retrospektiven bieten Raum zur Bewertung des Fortschritts und zur Anpassung bei Bedarf.
  • Feedback Loop: Kontinuierliches Feedback von Stakeholdern und Kunden hilft, den Product Backlog entsprechend anzupassen und das Sprint Backlog flexibel zu gestalten.
  • Transparenz: Klare Kommunikation und Dokumentation aller Änderungen und Fortschritte sorgt dafür, dass das gesamte Team informiert bleibt und effizient arbeitet.

d)

Das Team überlegt, neben Scrum auch Kanban-Praktiken zu integrieren. Diskutiere, wie Kanban-Elemente wie die Visualisierung des Workflows und die Limitierung der Work-in-Progress (WIP) in das bestehende Scrum-System integriert werden könnten. Welche Vorteile und Herausforderungen ergeben sich daraus?

Lösung:

Die Integration von Kanban-Praktiken in ein Scrum-System kann viele Vorteile bieten, aber auch einige Herausforderungen mit sich bringen. Hier sind einige Möglichkeiten, wie Kanban-Elemente wie die Visualisierung des Workflows und die Limitierung der Work-in-Progress (WIP) in das bestehende Scrum-System integriert werden könnten:

• Visualisierung des Workflows:
  • Scrum-Teams können ein Kanban-Board verwenden, um den Fortschritt der Aufgaben in einem Sprint visuell darzustellen. Ein typisches Kanban-Board hat Spalten wie „To Do“, „In Progress“ und „Done“.
  • Nutzen: Dies ermöglicht dem Team, den Status jeder Aufgabe auf einen Blick zu sehen und den Fortschritt der Arbeit transparent zu halten. Es erleichtert die tägliche Zusammenarbeit und hilft bei der Identifikation von Engpässen.
  • Implementierung: Das vorhandene Task-Board in Scrum kann durch ein detaillierteres Kanban-Board ersetzt oder ergänzt werden. Beispielsweise kann das Team für jede Aufgabe im Sprint Backlog ein Ticket erstellen und diese durch das Board bewegen, während sie daran arbeiten.
  • Beispiel: In Deinem Softwareprojekt kann das Team Aufgaben wie „Datenbankdesign“, „Backend-Implementierung“, und „Testen der Registrierung“ auf dem Board visualisieren.
• Limitierung der Work-in-Progress (WIP):
  • WIP-Limits setzen eine maximale Anzahl von Aufgaben fest, die gleichzeitig in einer bestimmten Spalte des Kanban-Boards sein können. Dies verhindert, dass das Team zu viele Aufgaben gleichzeitig beginnt, was die Effizienz und den Fokus erhöht.
  • Nutzen: Durch die Begrenzung der WIP kann das Team sicherstellen, dass Aufgaben eher abgeschlossen werden, bevor neue gestartet werden. Das führt zu einer besseren Qualität der Arbeit und schnelleren Durchlaufzeiten.
  • Implementierung: Das Team könnte für die „In Progress“-Spalte ein WIP-Limit festlegen, zum Beispiel maximal 3 Aufgaben gleichzeitig.
  • Beispiel: Das Team könnte festlegen, dass bei der Implementierung der Benutzerregistrierung und Authentifizierungslogik nie mehr als drei Tasks gleichzeitig in Bearbeitung sind.
• Vorteile der Integration von Kanban in Scrum:
  • Erhöhte Transparenz und bessere Visualisierung des Arbeitsflusses.
  • Reduzierung von Multitasking und Verbesserung des Fokus durch WIP-Limits.
  • Schnellere Identifikation von Engpässen und Problemen im Workflow.
  • Verbesserte Zusammenarbeit und Kommunikation im Team.
• Herausforderungen bei der Integration von Kanban in Scrum:
  • Die Notwendigkeit der kontinuierlichen Schulung und Adaptation, um sicherzustellen, dass das gesamte Team die neuen Praktiken versteht und unterstützt.
  • Erhöhte Komplexität im Management der Arbeit, da sowohl Scrum- als auch Kanban-Praktiken angewendet werden müssen.
  • Erste Verwirrung und Anpassungsprobleme, besonders in Teams, die mit einem rein Scrum-basierten Ansatz vertraut sind.

Durch die sorgfältige Einführung und Integration von Kanban-Praktiken in ein bestehendes Scrum-System können die genannten Vorteile realisiert und die genannten Herausforderungen überwunden werden.

Aufgabe 3)

Du arbeitest an einem Softwareentwicklungsprojekt, das durch den gesamten Projektlebenszyklus geht, von der Initialisierungsphase bis zur Wartungsphase. Das Projektziel ist es, eine mobile App zu entwickeln, die den Nutzern hilft, ihre täglichen Aufgaben und Termine zu verwalten. Nutze die Kenntnisse über Projektlebenszyklusphasen, um die folgenden Fragen zu beantworten.

a)

Beschreibe detailliert die Schritte und Aktivitäten, die während der Initialisierungsphase dieses Projekts durchgeführt würden. Welche Ergebnisse würden am Ende dieser Phase erwartet werden?

Lösung:

Initialisierungsphase des Softwareentwicklungsprojekts:

• Projektidee und Zielsetzung: In dieser Phase wird die Idee zur Entwicklung einer mobilen App zur Aufgaben- und Terminverwaltung formuliert. Die Hauptzielsetzung des Projekts wird festgelegt, beispielsweise die Verbesserung der Organisation des täglichen Lebens der Nutzer.
• Stakeholder-Analyse: Identifikation und Analyse der Stakeholder, die an dem Projekt interessiert sind. Mögliche Stakeholder könnten die Endnutzer, Auftraggeber, Entwicklerteam und gegebenenfalls weitere Interessengruppen sein. Ihre Anforderungen und Erwartungen werden dokumentiert.
• Machbarkeitsstudie: Eine Machbarkeitsstudie wird durchgeführt, um zu prüfen, ob das Projekt technisch und wirtschaftlich durchführbar ist. Dabei werden verschiedene Aspekte wie technologische Infrastruktur, Kosten, Zeitrahmen und Risiken analysiert.
• Projektauftrag und -ziele: Formulierung eines klaren Projektauftrags, der die Ziele des Projekts und die erwarteten Ergebnisse festlegt. Diese Dokumentation dient als Grundlage für alle weiteren Projektaktivitäten.
• Projektorganisation und Rollenverteilung: Bestimmung der Projektorganisation und Zuweisung der Rollen und Verantwortlichkeiten. Dazu gehören die Auswahl des Projektleiters, des Entwicklerteams und weiterer Schlüsselpersonen.
• Ressourcenplanung: Identifikation der benötigten Ressourcen (Personal, Technik, Budget) und Erstellung eines ersten Ressourcenplans.
• Risikoanalyse: Durchführung einer ersten Risikoanalyse, um potenzielle Risiken zu identifizieren und Maßnahmen zur Risikominderung zu planen.
• Projektzeitplan: Erstellung eines groben Zeitplans für das Projekt, der die wichtigsten Meilensteine und Deadlines enthält.
• Abschluss der Initialisierungsphase: Am Ende der Initialisierungsphase wird ein Kick-off-Meeting abgehalten, um das Projekt offiziell zu starten und alle Beteiligten über den aktuellen Stand und die nächsten Schritte zu informieren.

• Projektauftrag: Ein dokumentiertes Dokument, das die Ziele, den Umfang und die erwarteten Ergebnisse des Projekts beschreibt.
• Stakeholder-Liste und Anforderungen: Eine Liste der identifizierten Stakeholder und eine Dokumentation ihrer Anforderungen.
• Machbarkeitsstudie: Ein Abschlussbericht, der die Ergebnisse der Machbarkeitsanalyse zusammenfasst.
• Rollen- und Verantwortlichkeitsmatrix: Ein Dokument, das die zugewiesenen Rollen und Verantwortlichkeiten im Projektteam beschreibt.
• Ressourcenplan: Ein erster Plan, der die erforderlichen Ressourcen und deren Verfügbarkeit darstellt.
• Risikoanalyse: Eine Dokumentation der identifizierten Risiken und der vorgesehenen Maßnahmen zur Risikoabwehr.
• Projektzeitplan: Ein vorläufiger Zeitplan mit wichtigen Meilensteinen und Deadlines.
• Kick-off-Meeting : Durchführung eines Meetings zur offiziellen Projektstart.

b)

Erstelle einen detaillierten Projektplan für die Planungsphase dieses Softwareprojekts. Der Plan sollte Zeitrahmen, wichtige Meilensteine sowie Ressourcenanforderungen enthalten. Welche Techniken würdest Du verwenden, um die Aufgaben zu schätzen, und wie würdest Du die Risiken identifizieren und bewältigen?

Lösung:

Projektplan für die Planungsphase des Softwareentwicklungsprojekts:

• Zeitrahmen:
  • Kick-off-Meeting (1 Woche)
  • Anforderungsanalyse und -dokumentation (2 Wochen)
  • Design und Architekturplanung (3 Wochen)
  • Erstellung des Projektzeitplans und der Meilensteine (1 Woche)
  • Ressourcenplanung und Ressourcenzuordnung (2 Wochen)
  • Risikomanagement-Planung (1 Woche)
  • Projektplan-Genehmigung (1 Woche)
• Wichtige Meilensteine:
  • Projekt-Kick-off
  • Abschluss der Anforderungsanalyse
  • Fertigstellung des Design- und Architekturplans
  • Erstellung des detaillierten Projektzeitplans
  • Ressourcen- und Budgetzuordnung
  • Fertigstellung des Risikomanagementplans
  • Genehmigung des Gesamtprojektplans
• Ressourcenanforderungen:
  • Projektleiter
  • Systemarchitekt
  • Business Analyst
  • Entwicklerteam
  • Tester
  • UX/UI-Designer
  • Infrastrukturressourcen (Server, Entwicklungsumgebung, Software-Tools)
  • Budget für externe Berater und Schulungen
• Techniken zur Aufgabenabschätzung:
  • Expertenschätzung: Befragung erfahrener Teammitglieder zur Schätzung der Aufgabenaufwände.
  • Analogiemethode: Vergleich mit ähnlichen, abgeschlossenen Projekten, um die Aufwände abzuschätzen.
  • Delphi-Methode: Anonyme Schätzungen durch Experten, aus denen ein Mittelwert gebildet wird.
  • COCOMO (Constructive Cost Model): Einsatz eines quantitativen Modells zur Schätzung der Softwareentwicklungskosten basierend auf verschiedenen Parametern.
• Risikomanagement:
  • Risikoidendifizierung:
    • Brainstorming-Sitzungen mit dem Projektteam und Stakeholdern.
    • Analyse früherer Projekte, um potenzielle Risiken zu identifizieren.
    • Erstellung einer Risikomatrix, die mögliche Risiken und ihre Eintrittswahrscheinlichkeit sowie Auswirkungen beschreibt.
  • Risikobewältigung:
    • Entwicklung von Vermeidungsstrategien, um das Eintreten bestimmter Risiken zu verhindern.
    • Erstellung von Reaktionsplänen, um schnell auf eingetretene Risiken reagieren zu können.
    • Regelmäßige Überwachung und Bewertung der identifizierten Risiken während des gesamten Projektverlaufs.

c)

Während der Umsetzungsphase stellen sich einige Herausforderungen beim Testen des Codes heraus. Beschreibe einen strukturierten Testansatz, den Du anwenden würdest, um sicherzustellen, dass die App robust und fehlerfrei ist. Welche Arten von Tests würdest Du durchführen, und wie würdest Du die Ergebnisse dokumentieren?

Lösung:

Strukturierter Testansatz für die Umsetzungsphase:

• Teststrategie definieren: Die Teststrategie legt die allgemeinen Prinzipien und Ansätze fest, die zur Sicherstellung der Qualität der App verwendet werden. Sie umfasst die Testziele, Testumfänge und die eingesetzten Testmethoden.
• Testplanung: Erstellung eines detaillierten Testplans, der die zu testenden Funktionen, Testziele, Testressourcen, Testzeitpläne und die Testumgebung beschreibt.
• Testarten und -verfahren:
  • Unit-Tests: Testen einzelner Komponenten oder Module der Anwendung, um sicherzustellen, dass sie wie erwartet funktionieren. Verwendung von automatisierten Tests zur Effizienzsteigerung.
  • Integrationstests: Überprüfung der Zusammenarbeit und Interoperabilität verschiedener Module und Komponenten. Sicherstellung, dass Schnittstellen korrekt funktionieren.
  • Systemtests: Gesamtheitliche Tests der kompletten Anwendung in einer simulierten Produktionsumgebung. Überprüfung, ob die Anforderungen und Spezifikationen erfüllt werden.
  • Akzeptanztests: Durchführung von Tests mit Endbenutzern oder Stakeholdern, um sicherzustellen, dass die App den Erwartungen und Anforderungen entspricht.
  • Funktionale Tests: Überprüfung, ob alle spezifizierten Funktionen der App korrekt implementiert und funktionsfähig sind.
  • Nicht-funktionale Tests: Tests zur Überprüfung von Aspekten wie Performance, Sicherheit, Usability und Kompatibilität.
  • Regressionstests: Sicherstellung, dass neue Änderungen oder Upgrades keine bestehenden Funktionen oder Module brechen.
• Testdurchführung: Ausführung der geplanten Tests gemäß dem Testplan. Jede Testausführung wird dokumentiert, und bei Entdeckung von Fehlern werden diese protokolliert und den entsprechenden Entwicklern zur Behebung zugewiesen.
• Ergebnisdokumentation: Systematische Dokumentation der Testergebnisse. Diese umfasst:
  • Testprotokolle: Detaillierte Aufzeichnungen über die durchgeführten Tests, einschließlich Datum, Uhrzeit, Tester und Testumgebung.
  • Fehlerberichte: Ausführliche Beschreibungen der gefundenen Fehler, deren Schweregrad, Reproduzierbarkeit und Status der Behebung.
  • Testmetriken: Statistiken und Metriken zur Testabdeckung, Fehlerhäufigkeit, Behebungsrate und Testfortschritt.
  • Zusammenfassende Testberichte: Regelmäßige Berichte an das Projektteam und die Stakeholder mit einer Übersicht der Testergebnisse, identifizierten Risiken und Empfehlungen für Verbesserungen.
• Fehlerbehebungs- und Nachtestphase: Behebung der identifizierten Fehler durch die Entwickler. Anschließend werden Nachtests durchgeführt, um zu überprüfen, ob die Fehler erfolgreich behoben wurden und keine neuen Probleme entstanden sind.

• Unit-Tests:

   'def test_add_task(): 
        task_manager = TaskManager() 
        task_manager.add_task('Meeting') 
        assert 'Meeting' in task_manager.tasks' 

• Integrationstests: Beispiel: Sicherstellen, dass die App nach der Integration mit einem Cloud-Speicher-Dienst korrekt synchronisiert wird.
• Systemtests: Beispiel: Durchführen von End-to-End-Tests, bei denen ein vollständiger Workflow von Start bis Abschluss überprüft wird.
• Akzeptanztests: Beispiel: Durchführung von Tests mit einer Gruppe von Endbenutzern, um ihre Akzeptanz der App zu evaluieren.
• Nicht-funktionale Tests: Beispiel: Lasttest, um die Performance der App unter hohen Nutzungsbedingungen zu überprüfen.

d)

Nach der Veröffentlichung der App tritt sie in die Wartungsphase ein. Ein Benutzer meldet einen kritischen Fehler, der die Nutzung der App erheblich beeinträchtigt. Beschreibe den Prozess zur Fehlerbehebung, einschließlich der Schritte zur Problemidentifikation, Fehleranalyse, Implementierung der Lösung und Tests der Korrekturen. Welche Maßnahmen würdest Du ergreifen, um sicherzustellen, dass ähnliche Fehler in Zukunft vermieden werden?

Lösung:

Prozess zur Fehlerbehebung in der Wartungsphase:

• Problemidentifikation:
  • Fehlerbericht aufnehmen: Eine detaillierte Fehlermeldung vom Benutzer erhalten, die Informationen wie die Umstände des Auftretens, die genaue Fehlermeldung und die Auswirkungen auf die Nutzung der App enthält.
  • Gesamte Vorgeschichte dokumentieren: Sammeln aller relevanten Informationen und Berichte, um ein umfassendes Bild des Problems zu erhalten.
  • Reproduktion des Fehlers: Nachstellen des Fehlers in einer Testumgebung, um das Problem zu bestätigen und zu verstehen.
• Fehleranalyse:
  • Log-Analyse: Untersuchung der Protokolldateien der App, um Hinweise auf die Ursache des Fehlers zu finden.
  • Code-Durchsicht: Überprüfung des Quellcodes durch das Developer-Team, insbesondere der Bereiche, die mit dem gemeldeten Fehler in Zusammenhang stehen.
  • Systemdiagnose: Analyse der Gesamtsystemumgebung, um herauszufinden, ob externe Faktoren (z.B. Serverprobleme, Netzwerkverbindungen) eine Rolle spielen.
• Implementierung der Lösung:
  • Entwicklung einer Lösung: Entwickeln und Implementieren von Codeänderungen, um den identifizierten Fehler zu beheben.
  • Peer-Review: Durchführung eines Peer-Reviews der vorgenommenen Änderungen durch andere Entwickler, um sicherzustellen, dass der Fix korrekt ist.
  • Build-Erstellung: Erstellung eines neuen Builds der App, der die Fehlerbehebung enthält.
• Tests der Korrekturen:
  • Unit- und Integrationstests: Sicherstellen, dass die Änderung keine negativen Auswirkungen auf andere Teile der App hat.
  • Regressionstests: Durchführung umfassender Tests, um sicherzustellen, dass der Fix keine neuen Fehler verursacht und dass das Gesamtsystem weiterhin wie erwartet funktioniert.
  • Benutzertests: Bereitstellen des neuen Builds für den betroffenen Benutzer zur Verifizierung, dass das Problem aus seiner Perspektive behoben wurde.
• Langfristige Maßnahmen zur Fehlervermeidung:
  • Rückmeldung analysieren: Analyse der Benutzerfeedbacks und -berichte, um Muster zu identifizieren und um früher auf ähnliche Probleme reagieren zu können.
  • Verbesserung der Tests: Überarbeitung und Erweiterung der Testfälle basierend auf den Fehlern, um ähnliche Probleme in Zukunft zu vermeiden.
  • Schulung und Weiterbildung: Regelmäßige Schulungen des Entwicklerteams zu Best Practices in der Softwareentwicklung und Fehlervermeidung.
  • Dokumentation: Ergänzung und Verbesserung der Projektdokumentation, insbesondere der Bereiche, in denen Fehler aufgetreten sind, um sicherzustellen, dass ähnliche Probleme in Zukunft besser verstanden und vermieden werden können.
  • Code-Reviews und Audits: Regelmäßige Code-Reviews und Sicherheits-Audits, um potenzielle Schwachstellen frühzeitig zu erkennen und zu beheben.

Aufgabe 4)

In einem Softwareentwicklungsprojekt wird eine webbasierte Anwendung entwickelt, die zur Verwaltung von studentischen Kursanmeldungen dienen soll. Die Anwendung umfasst verschiedene Module wie die Benutzerverwaltung, Kursverwaltung und Anmeldeverwaltung. Deine Aufgabe ist es, sicherzustellen, dass die Anwendung durch umfassende Softwaretests auf Funktionalität und Qualität geprüft wird.

a)

Erkläre den grundlegenden Zweck und die Ziele von Unit Tests und gib ein konkretes Beispiel für einen Unit Test der Funktion zur Anmeldung eines Benutzers zu einem Kurs in der Anwendung. Formatiere den Beispielcode in Python.

Lösung:

Grundlegender Zweck und Ziele von Unit Tests

Unit Tests sind eine Art von Softwaretests, die darauf abzielen, einzelne Einheiten oder Komponenten einer Anwendung isoliert zu testen. Das Hauptziel von Unit Tests ist es, sicherzustellen, dass jede kleinste funktionale Einheit des Codes wie erwartet arbeitet. Hier sind einige der Hauptziele:

• Verifizierung der Korrektheit: Sicherstellen, dass die logischen Einheiten des Codes korrekt funktionieren.
• Frühzeitiges Erkennen von Fehlern: Fehler werden früh im Entwicklungszyklus erkannt, was die Kosten ihrer Behebung verringert.
• Dokumentation: Unit Tests dienen auch als Dokumentation, die zeigt, wie der Code verwendet werden sollte.
• Unterstützung der Refaktorisierung: Bei Änderungen oder Optimierungen des Codes stellen Unit Tests sicher, dass bestehende Funktionalitäten weiterhin korrekt arbeiten.
• Erhöhte Zuverlässigkeit und Wartbarkeit: Gut getestete Einheiten verbessern die Gesamtwartbarkeit und Zuverlässigkeit der Software.

Konkretes Beispiel für einen Unit Test in Python

Im Folgenden findest Du ein Beispiel für einen Unit Test der Funktion zur Anmeldung eines Benutzers zu einem Kurs in der Anwendung. Wir verwenden die Bibliothek unittest in Python.

 import unittest  class User:      def __init__(self, user_id):          self.user_id = user_id          self.courses = []       def register_course(self, course_id):          if course_id not in self.courses:              self.courses.append(course_id)          return self.courses   class TestUserRegistration(unittest.TestCase):       def setUp(self):          self.user = User(user_id=1)       def test_register_course(self):          self.user.register_course('Math101')          self.assertIn('Math101', self.user.courses)       def test_register_existing_course(self):          self.user.register_course('Math101')          self.user.register_course('Math101')          self.assertEqual(1, self.user.courses.count('Math101'))   if __name__ == '__main__':      unittest.main()  

• setUp: Diese Methode wird vor jedem Test aufgerufen, um sicherzustellen, dass wir immer mit einem neuen Benutzerobjekt beginnen.
• test_register_course: Testet, ob die Methode register_course einen Kurs richtig hinzufügt.
• test_register_existing_course: Testet, ob der Kurs nicht doppelt hinzugefügt wird, wenn derselbe Kurs wiederholt registriert wird.

b)

Beschreibe den Ablauf eines Integrationstests für das Zusammenspiel zwischen der Benutzerverwaltung und der Kursverwaltung. Welche Aspekte müssen besonders beachtet werden und wie kann man sicherstellen, dass die beiden Module reibungslos zusammenarbeiten?

Lösung:

Ablauf eines Integrationstests für das Zusammenspiel zwischen der Benutzer- und Kursverwaltung

Integrationstests zielen darauf ab, verschiedene Komponenten oder Module einer Anwendung als ein zusammenhängendes System zu testen. Im Kontext der Benutzer- und Kursverwaltung einer webbasierten Anwendung geht es darum, sicherzustellen, dass diese beiden Module korrekt zusammenarbeiten. Hier ist eine Schritt-für-Schritt-Anleitung für den Ablauf eines Integrationstests:

• 1. Initialisierung: Erstelle eine Testumgebung, die beide Module (Benutzerverwaltung und Kursverwaltung) enthält. Stelle sicher, dass alle Abhängigkeiten und Datenbanken korrekt eingerichtet sind.
• 2. Benutzererstellung testen: Erstelle einen neuen Benutzer über die Benutzerverwaltung. Stelle sicher, dass die Benutzerid korrekt generiert und gespeichert wird.
• 3. Kurs erstellen: Erstelle einen neuen Kurs über die Kursverwaltung. Stelle sicher, dass der Kurs korrekt in der Datenbank gespeichert wird und eine eindeutige Kursid besitzt.
• 4. Benutzer zu Kurs anmelden: Benutze die von der Benutzerverwaltung zur Verfügung gestellte Funktion, um den Benutzer zu dem neu erstellten Kurs anzumelden. Überprüfe, dass die Anmeldung sowohl in der Benutzer- als auch in der Kursdatenbank korrekt gespeichert wird.
• 5. Überprüfung: Stelle sicher, dass der Benutzer in der Kursliste des Kurses erscheint und der Kurs in der Kursliste des Benutzers erscheint. Dies garantiert die beidseitige Sichtbarkeit und Konsistenz der Daten.
• 6. Randfälle testen: Teste Szenarien wie die Anmeldung zu einem nicht existierenden Kurs, doppelte Anmeldungen oder die Anmeldung von mehreren Benutzern zu demselben Kurs. Stelle sicher, dass alle Fehlermeldungen und Ausnahmen korrekt gehandhabt werden.
• 7. Säuberung: Bereinige die Testumgebung, indem du Testdaten aus der Datenbank löschst und sicherstellst, dass keine Datenlecks oder -korruptionen auftreten.

Besondere Aspekte, die beachtet werden müssen

• Datenkonsistenz: Stelle sicher, dass die Daten in beiden Modulen konsistent sind. Änderungen in einem Modul müssen sich korrekt im anderen Modul widerspiegeln.
• Fehler- und Ausnahmebehandlung: Vergewissere dich, dass alle Fehler und Ausnahmesituationen ordnungsgemäß behandelt werden, insbesondere bei der Interaktion zwischen den Modulen.
• Transaktionsmanagement: Verwende Transaktionen, um sicherzustellen, dass Datenbankänderungen entweder vollständig oder gar nicht durchgeführt werden. Dies verhindert Inkonsistenzen bei Fehlern während des Testprozesses.
• Schnittstellen und APIs: Überprüfe, ob die APIs korrekt definiert sind und dass die Kommunikation zwischen den Modulen reibungslos funktioniert.

Sicherstellung der reibungslosen Zusammenarbeit

• Automatisierung: Setze auf automatisierte Testwerkzeuge und Frameworks, um Integrationstests regelmäßig und effizient durchzuführen.
• Continuous Integration (CI): Integriere die Integrationstests in den CI-Prozess, um sicherzustellen, dass bei jedem Build alle Module korrekt zusammenarbeiten.
• Monitoring: Implementiere Monitoring- und Logging-Mechanismen, um Probleme schnell zu erkennen und zu beheben.

Durch sorgfältige Planung und Durchführung der Integrationstests kann sichergestellt werden, dass die Benutzer- und Kursverwaltungmodule der Anwendung korrekt und reibungslos zusammenarbeiten.

c)

Angenommen, es gibt ein Problem in der Anmeldeverwaltung, das nur unter hoher Last auftritt. Beschreibe, wie Du ein Systemtest-Szenario entwerfen würdest, um dieses Problem zu identifizieren. Welche Werkzeuge und Methoden würdest Du verwenden, um die Nutzerlast zu simulieren?

Lösung:

Entwurf eines Systemtest-Szenarios zur Identifizierung von Problemen unter hoher Last

Um ein Systemtest-Szenario zu entwerfen, das speziell darauf abzielt, Probleme in der Anmeldeverwaltung unter hoher Last zu identifizieren, müssen wir eine Reihe von Schritten durchlaufen. Diese Schritte umfassen die Vorbereitung der Testumgebung, die Erstellung von Testdaten, die Simulation einer hohen Benutzerlast und schließlich die Analyse der Ergebnisse.

Schritte zur Durchführung des Systemtests

• 1. Vorbereitung der Testumgebung:
  • Stelle sicher, dass die Testumgebung die Produktionsumgebung so genau wie möglich widerspiegelt. Dies umfasst die Infrastruktur, Datenbanken und Netzwerkbedingungen.
  • Richte Monitoring- und Logging-Tools ein, um die Leistung und das Verhalten des Systems während des Tests zu überwachen.
• 2. Erstellung von Testdaten:
  • Erstelle eine große Anzahl an Benutzerkonten und Kursen, um realistische Testdaten zu haben.
  • Bereite Scripts oder Tools vor, um automatisierte Anmeldungen durchzuführen.
• 3. Simulation der Benutzerlast:
  • Verwende Lasttest-Tools wie Apache JMeter, Locust, Gatling oder BlazeMeter zur Simulation einer hohen Benutzerlast.
  • Erstelle Szenarien, die das Verhalten echter Benutzer simulieren, wie z.B. das Durchsuchen von Kursen, das Anmelden zu Kursen und das Verwalten von Benutzerkonten.
  • Plane einen schrittweisen Lastanstieg, um das Systemverhalten bei zunehmender Benutzerzahl zu beobachten.
• 4. Durchführung des Tests:
  • Führe die vorbereiteten Lasttests durch und überwache dabei die Systemleistung.
  • Verwende Monitoring-Tools wie Grafana, Prometheus, New Relic oder Datadog, um Metriken wie CPU-Auslastung, Speicherverbrauch, Antwortzeiten und Durchsatz zu überwachen.
• 5. Analyse der Ergebnisse:
  • Analysiere die gesammelten Daten und Logfiles, um Engpässe, Fehler und andere Anomalien zu identifizieren.
  • Suche nach Mustern und wiederkehrenden Problemen, die unter hoher Last auftreten.
  • Erstelle einen Bericht mit den gefundenen Problemen und möglichen Handlungsempfehlungen.

Werkzeuge und Methoden zur Simulation von Nutzerlast

• Apache JMeter: Ein weit verbreitetes Open-Source-Tool für Lasttests, das HTTP-, HTTPS-Anfragen sowie Datenbanken und andere Dienste testen kann.
• Locust: Ein einfach zu bedienendes Lasttest-Tool, das in Python geschrieben ist und auf der Erstellung von benutzerdefinierten Testfällen basiert.
• Gatling: Ein leistungsstarkes Tool für Lasttests, das auf der JVM läuft und Scala-basierte Testskripte verwendet.
• BlazeMeter: Eine kommerzielle Lösung, die auf JMeter basiert und zusätzliche Funktionen sowie eine Cloud-basierte Infrastruktur für Lasttests bietet.

Durch den gezielten Einsatz dieser Werkzeuge und Methoden kann sichergestellt werden, dass potenzielle Probleme in der Anmeldeverwaltung unter hoher Last identifiziert und behoben werden, bevor sie in der Produktionsumgebung auftauchen.

d)

Setze voraus, dass während des Systemtestings ein schwerwiegender Fehler gefunden wurde, der die Anmeldung neuer Benutzer verhindert. Erkläre in einem strukturierten Ansatz, wie Du das Problem analysieren und beheben würdest. Welche Schritte würdest Du unternehmen, um sicherzustellen, dass dieser Fehler in zukünftigen Versionen nicht mehr auftritt?

Lösung:

Analyse und Behebung eines schwerwiegenden Fehlers während des Systemtests

Wenn während des Systemtestings ein schwerwiegender Fehler gefunden wird, der die Anmeldung neuer Benutzer verhindert, ist es wichtig, einen strukturierten Ansatz zur Analyse und Behebung des Problems zu verfolgen. Hier sind die Schritte, die ich unternehmen würde:

1. Sofortige Fehleranalyse

• Fehlerreproduktion: Versuche, den Fehler zu reproduzieren, um sicherzustellen, dass er konsistent und nachvollziehbar ist. Dokumentiere die genauen Schritte, die zum Auftreten des Fehlers führen.
• Log-Analyse: Untersuche die Logdateien der Anwendung, um Hinweise auf die genaue Ursache des Fehlers zu finden. Achte auf Fehlermeldungen, Ausnahmen und ungewöhnliche Einträge.
• Monitoring-Daten prüfen: Analysiere Monitoring-Daten (z.B. CPU-Auslastung, Speicherverbrauch, Datenbankzugriffe) während des Fehlers, um systemweite Anomalien zu identifizieren.
• Code-Review: Führe eine gezielte Code-Überprüfung der Anmeldefunktion durch, um mögliche Fehlerquellen und Schwachstellen zu identifizieren.

2. Fehlerbehebung

• Ursachenanalyse: Identifiziere die genaue Ursache des Fehlers, sei es ein Logikfehler im Code, ein Problem mit der Datenbank oder ein anderes technisches Problem.
• Bugfixing: Nimm die notwendigen Änderungen am Code vor, um den Fehler zu beheben. Dokumentiere alle vorgenommenen Änderungen und füge erklärende Kommentare hinzu.
• Überprüfung durch Peer Review: Lasse den Bugfix von einem anderen Entwickler überprüfen, um sicherzustellen, dass keine neuen Fehler eingeführt wurden und der Fix korrekt ist.

3. Validierung und Verifikation

• Erneutes Testen: Führe die Tests erneut durch, um sicherzustellen, dass der Fehler behoben wurde und keine neuen Probleme entstanden sind.
• Regressionstests: Führe Regressionstests durch, um zu überprüfen, dass andere Teile des Systems weiterhin korrekt arbeiten.
• Integrationstests: Führe integrierte Tests der Benutzerverwaltungs- und Anmeldefunktionen durch, um sicherzustellen, dass sie einwandfrei zusammenarbeiten.

4. Maßnahmen für zukünftige Versionen

• Erweiterte Unit Tests: Erstelle zusätzliche Unit Tests, um die Anmeldefunktion gründlicher zu überprüfen und sicherzustellen, dass ähnliche Fehler in Zukunft nicht mehr auftreten.
• Integrationstests: Erweitere die Integrationstests, um die Interaktionen zwischen den Modulen genauer zu prüfen.
• Load- und Stress Tests: Führe regelmäßige Last- und Stresstests durch, um sicherzustellen, dass das System unter hoher Last stabil bleibt.
• Code Reviews und Pair Programming: Förderer regelmäßige Code Reviews und Pair Programming, um die Codequalität zu verbessern und potenzielle Fehler frühzeitig zu erkennen.

5. Dokumentation und Wissensaustausch

• Dokumentation: Dokumentiere die aufgetretenen Fehler, deren Ursachen und die durchgeführten Korrekturmaßnahmen ausführlich. Dies hilft, zukünftige ähnliche Probleme schneller zu erkennen und zu beheben.
• Wissensaustausch: Teile die Erfahrungen und Erkenntnisse aus dem Fehlerbehebungsprozess mit dem gesamten Entwicklungsteam, um das Bewusstsein für potenzielle Fehlerquellen zu erhöhen.

Durch einen systematischen und gründlichen Ansatz zur Fehleranalyse und -behebung kann sichergestellt werden, dass die Anwendung stabiler und robuster wird und ähnliche Probleme in zukünftigen Versionen vermieden werden.