Lösungen

Aufgabe 1: Theoretische Fragen

Erkläre die Bedeutung der Fehlerbehebung in der Softwareentwicklung. Warum ist sie für die Qualität und Zuverlässigkeit von Software entscheidend?
Antwort: Fehlerbehebung ist entscheidend, um die Funktionalität, Zuverlässigkeit und Sicherheit von Software zu gewährleisten. Durch systematisches Debugging werden Fehler identifiziert und behoben, bevor sie in die Produktion gelangen, was die Benutzerzufriedenheit erhöht und potenzielle Sicherheitsrisiken minimiert. Fehlerhafte Software kann zu Datenverlust, Sicherheitslücken und unzuverlässiger Leistung führen, was das Vertrauen der Benutzer beeinträchtigt.
Nenne und beschreibe die drei Hauptarten von Fehlern in der Softwareentwicklung.
Antwort:
- Syntaxfehler: Fehler, die durch Verstöße gegen die Regeln der Programmiersprache entstehen, z.B. fehlende Semikolons oder falsch platzierte Klammern. Diese Fehler verhindern, dass das Programm kompiliert oder ausgeführt wird.
- Laufzeitfehler: Fehler, die während der Ausführung des Programms auftreten, z.B. Division durch Null oder Zugriff auf nicht existierende Speicherbereiche. Diese Fehler führen oft zu Programmabstürzen oder unerwartetem Verhalten.
- Logische Fehler: Fehler, bei denen das Programm zwar läuft, aber nicht wie beabsichtigt funktioniert, z.B. falsche Berechnungen oder fehlerhafte Bedingungen in Schleifen.
Was versteht man unter Root Cause Analysis (RCA) und welche Techniken werden dabei eingesetzt?
Antwort: Root Cause Analysis (RCA) ist ein systematischer Ansatz zur Identifikation der grundlegenden Ursachen eines Problems. Techniken, die dabei eingesetzt werden, umfassen:
- 5-Why-Methode: Durch wiederholtes Fragen „Warum?“ wird die zugrunde liegende Ursache eines Problems identifiziert.
- Ishikawa-Diagramm (Fischgräten-Diagramm): Strukturiert mögliche Ursachen eines Problems in Kategorien wie Menschen, Maschinen, Methoden und Materialien.
- Pareto-Analyse: Identifikation der häufigsten Ursachen von Fehlern basierend auf der 80/20-Regel, die besagt, dass 80% der Probleme durch 20% der Ursachen entstehen.

Aufgabe 2: Debugging-Werkzeuge und Techniken

Debugging-Werkzeuge verwenden:
- Schritte zur Fehlererkennung mit einem Debugger:
  1. Programm erstellen: Ein einfaches Programm mit einem absichtlichen Fehler (z.B. Division durch Null).
  2. Debugger konfigurieren: Debugger wie GDB, Visual Studio Debugger oder Eclipse Debugger einrichten.
  3. Breakpoints setzen: Haltepunkte an relevanten Stellen im Code setzen.
  4. Schrittweise Ausführung: Den Code Schritt für Schritt ausführen, um die Fehlerstelle zu identifizieren.
  5. Variablen überwachen: Den Zustand der Variablen während der Ausführung überprüfen.
- Dokumentation der Schritte:
  - Beispiel in Visual Studio:

Code mit Copy-Button


1. Programm erstellt mit absichtlichem Fehler (Division durch Null).
2. Visual Studio Debugger eingerichtet.
3. Breakpoint in der Funktion `divide` gesetzt.
4. Schrittweise Ausführung durchgeführt, bis der Fehler auftrat.
5. Überwachung der Variablen zeigte, dass der Divisor Null war.
6. Fehler behoben durch Hinzufügen einer Überprüfung auf Null.

Logging verwenden:

Schritte zur Implementierung von Logging:
1. Programm erstellen: Programm mit Logging (z.B. Log4j in Java, Logging-Modul in Python).
2. Log-Meldungen hinzufügen: Log-Meldungen auf verschiedenen Ebenen (INFO, DEBUG, ERROR) einfügen.
3. Fehler simulieren: Einen Fehler im Programm simulieren und die Log-Meldungen überprüfen.
Dokumentation der Schritte:
- Beispiel in Python:

Code mit Copy-Button


import logging

logging.basicConfig(level=logging.DEBUG)

def divide(a, b):
    logging.info("Divide function called with a=%d, b=%d", a, b)
    if b == 0:
        logging.error("Division durch Null!")
        return None
    return a / b

result = divide(10, 0)

Log-Meldungen:

Code mit Copy-Button


INFO:root:Divide function called with a=10, b=0
ERROR:root:Division durch Null!

Aufgabe 3: Fehleranalyse und Diagnose

Analyse eines Stack Traces:
- Schritte zur Fehleranalyse:
  1. Programm mit Laufzeitfehler erstellen: z.B. Division durch Null.
  2. Programm ausführen: Fehler tritt auf und Stack Trace wird generiert.
  3. Stack Trace analysieren: Überprüfung der Funktionsaufrufe im Stack Trace.
- Dokumentation der Analyse

Code mit Copy-Button


1. Programm erstellt, das eine Division durch Null durchführt.
2. Programm ausgeführt, Fehler trat auf, Stack Trace generiert.
3. Stack Trace analysiert:

Exception in thread „main“ java.lang.ArithmeticException: / by zero at Calculator.divide(Calculator.java:5) at Main.main(Main.java:10)

Code mit Copy-Button


Ursache: Division durch Null in der `divide`-Methode der `Calculator`-Klasse.

Logdateien analysieren:

Schritte zur Analyse von Logdateien:
1. Programm erstellen, das Logdateien generiert.
2. Logdateien durchsuchen: Spezifische Fehlermeldungen extrahieren.
3. Fehler beheben: Identifizierte Fehler analysieren und beheben.
Dokumentation der Analyse:

Code mit Copy-Button


1. Programm erstellt, das umfangreiche Logdateien generiert.
2. Logdateien durchsucht mit `grep`:

grep „ERROR“ application.log

Code mit Copy-Button


3. Fehlermeldung gefunden:

ERROR: Division durch Null in Funktion divide.

Code mit Copy-Button


4. Fehler analysiert und durch Überprüfung auf Null behoben.

Aufgabe 4: Korrekturmaßnahmen und Verifikation

Fehlerbehebung und Regressionstests:
- Schritte zur Fehlerbehebung:
  1. Fehlerhaften Test identifizieren: Unit-Tests ausführen und fehlerhafte Tests identifizieren.
  2. Fehler im Code beheben: Code ändern, um den Fehler zu beheben.
  3. Regressionstests ausführen: Alle Unit-Tests erneut ausführen, um sicherzustellen, dass keine neuen Fehler eingeführt wurden.
- Dokumentation der Schritte:

Code mit Copy-Button


1. Fehlerhaften Test identifiziert: Test für Division durch Null schlug fehl.
2. Fehler im Code behoben: Überprüfung auf Null hinzugefügt.
3. Regressionstests durchgeführt: Alle Tests bestanden.

Code Reviews:

Schritte zur Durchführung von Code Reviews:
1. Code-Review-Sitzung mit Partner durchführen: Code austauschen und gegenseitig überprüfen.
2. Verbesserungsvorschläge notieren: Mindestens drei Verbesserungsvorschläge oder gefundene Fehler notieren.
3. Änderungen implementieren: Vorschläge umsetzen und den Code erneut überprüfen.
Dokumentation der Schritte

Code mit Copy-Button


1. Code-Review-Sitzung mit Partner durchgeführt.
2. Verbesserungsvorschläge:
   - Redundanter Code entfernt.
   - Kommentare hinzugefügt.
   - Variablennamen verbessert.
3. Änderungen implementiert und erneut überprüft.

Aufgabe 5: Präventive Maßnahmen

Test Driven Development (TDD):
- Schritte zur Umsetzung von TDD:
  1. Tests zuerst schreiben: Tests für eine Funktion zur Berechnung der Fakultät schreiben.
  2. Funktion implementieren: Funktion so implementieren, dass alle Tests bestehen.
  3. Refaktorisierung: Code verbessern, während alle Tests bestehen bleiben.
- Dokumentation des TDD-Prozesses

Code mit Copy-Button


1. Tests geschrieben für Funktion factorial.
2. Funktion implementiert, bis alle Tests bestanden.
3. Code refaktoriert, Tests weiterhin bestanden.

Einsatz von Code-Qualitätswerkzeugen:

Schritte zur Analyse mit Code-Qualitätswerkzeugen:
1. Projekt analysieren: Bestehendes Projekt mit einem Code-Qualitätswerkzeug analysieren (z.B. SonarQube).
2. Probleme beheben: Gefundene Probleme im Code beheben.
3. Erneute Analyse: Projekt erneut analysieren, um sicherzustellen, dass die Probleme behoben sind.

Lösungen

Aufgabe 1: Theoretische Fragen

Aufgabe 2: Debugging-Werkzeuge und Techniken

Aufgabe 3: Fehleranalyse und Diagnose

Aufgabe 4: Korrekturmaßnahmen und Verifikation

Aufgabe 5: Präventive Maßnahmen

Anmelden

Account Registrieren und Fortschritt Speichern!

Modal title