Informatik 8: Programmfehler suchen und korrigieren

← Zurück zur 8. Klasse

Worum geht es? Die Lerninhalte verknüpfen Fehlertypen, Diagnosemethoden, Teststrategien und bewusste Korrekturen, damit Fehlersuche als geordneter Denkprozess verstanden wird und nicht als hektisches Probieren ohne Plan, Kontrolle und nachvollziehbare Begründung.

Lernziele

Nach diesem Kapitel kannst du:

• Fehlerarten erkennen, Unterschiede benennen.
• Meldungen lesen, Hinweise nutzen.
• Ursachen vermuten, Prüfschritte planen.
• Code prüfen, Logik kontrollieren.
• Eingaben testen, Ausgaben vergleichen.
• Teilprogramme isolieren, Fehler eingrenzen.
• Debugging nutzen, Werte beobachten.
• Korrekturen vornehmen, Wirkungen prüfen.
• Testfälle anwenden, Ergebnisse sichern.
• Lösungswege erklären, Verbesserungen begründen.

Anschluss an die 7. Klasse

Testen und Debugging gehören bereits zu deinen Programmierprojekten. Jetzt wird die Fehlersuche selbst zum Schwerpunkt: Fehlerbilder eingrenzen, Ursachen vermuten, Werkzeuge nutzen, korrigieren und erneut testen.

Lerninhalte

Kompaktüberblick

Teilbereich	Kerngedanke
Programmfehler als normaler Teil der Entwicklung	Ein tragfähiges Verständnis entsteht dann, wenn Fehler nicht als Scheitern, sondern als gewöhnlicher Teil von Programmierung betrachtet werden, weil gerade an ihnen sichtbar wird, wie genau Abläufe, Bedingungen und Daten in einem Programm zusammenwirken.
Häufige Fehlerarten unterscheiden	Gezielte Fehlersuche gelingt deutlich besser, wenn verschiedene Fehlerarten unterschieden werden, weil dadurch klarer wird, ob eher Schreibweise, Ablauf, Datenwerte oder unvollständige Bedingungen geprüft werden müssen.
Fehlermeldungen lesen und deuten	Erfolgreiches Debugging beginnt oft mit genauer Aufmerksamkeit für Rückmeldungen des Systems, weil Fehlermeldungen, Markierungen und Warnhinweise meist schon erste Informationen darüber geben, wo und warum ein Programm nicht wie erwartet arbeitet.
Fehler systematisch eingrenzen	Gezielte Korrektur wird erst dann möglich, wenn ein Problem Schritt für Schritt verkleinert wird, weil große Programme oder längere Abläufe sonst zu unübersichtlich bleiben und zufälliges Herumprobieren oft neue Fehler erzeugt.
Testen mit konkreten Beispielen	Fehler werden oft schneller sichtbar, wenn Programme nicht allgemein, sondern mit gezielt ausgewählten Eingaben überprüft werden, weil dadurch Erwartungen klar formuliert und Abweichungen leichter erkannt werden können.
Variablen, Bedingungen und Abläufe prüfen	Viele Programmfehler entstehen dort, wo Werte gespeichert, verglichen oder in bestimmter Reihenfolge verarbeitet werden, weshalb Variablen, Bedingungen und Ablaufstrukturen besonders sorgfältig kontrolliert werden sollten.
Debugging-Werkzeuge nutzen	Die Fehlersuche wird deutlich präziser, wenn Werkzeuge wie Schritt-Ausführung, Ausgabefenster oder Kontrollanzeigen eingesetzt werden, weil dadurch unsichtbare Zustände und Veränderungen im Programmverlauf besser beobachtbar werden.
Korrekturen prüfen und absichern	Eine Änderung ist erst dann sinnvoll abgeschlossen, wenn nach der Korrektur erneut getestet wird, weil eine schnelle Reparatur sonst unbemerkt neue Fehler erzeugen oder frühere Funktionen beeinträchtigen kann.
Typische Strategien für erfolgreiche Fehlersuche	Nachhaltige Debugging-Kompetenz wächst, wenn Schülerinnen und Schüler nicht nur einzelne Fehler beheben, sondern verlässliche Strategien entwickeln, die sich auf neue Programme und unbekannte Probleme übertragen lassen.

Merke: Debugging ist keine zufällige Fehlersuche, sondern ein kontrollierter Zyklus aus Beobachten, Vermuten, Prüfen, Korrigieren und erneutem Testen.

Programmfehler als normaler Teil der Entwicklung

Ein tragfähiges Verständnis entsteht dann, wenn Fehler nicht als Scheitern, sondern als gewöhnlicher Teil von Programmierung betrachtet werden, weil gerade an ihnen sichtbar wird, wie genau Abläufe, Bedingungen und Daten in einem Programm zusammenwirken.

Programmfehler gehören zu jedem Entwicklungsprozess. Fast jedes Programm enthält in frühen Versionen Unklarheiten, unvollständige Bedingungen, falsche Bezüge oder unpassende Eingaben. Entscheidend ist deshalb nicht, Fehler völlig zu vermeiden, sondern sie gezielt zu finden, zu verstehen und systematisch zu korrigieren.

Fehler, Normalfall

Entwicklung, Lernchance

Ursache, Wirkung

Suche, Korrektur

Kontrolle, Verbesserung

Prozess, Verständnis

Beispiele:

Ein Spiel reagiert nicht auf einen Tastendruck.

Eine Figur bewegt sich falsch.

Ein Punktestand zählt doppelt.

Ein Formular speichert Eingaben nicht wie erwartet.

Eine Berechnung liefert ein falsches Ergebnis.

Häufige Fehlerarten unterscheiden

Gezielte Fehlersuche gelingt deutlich besser, wenn verschiedene Fehlerarten unterschieden werden, weil dadurch klarer wird, ob eher Schreibweise, Ablauf, Datenwerte oder unvollständige Bedingungen geprüft werden müssen.

Nicht jeder Fehler ist gleich. Manche Programme starten gar nicht, andere laufen, liefern aber falsche Ergebnisse. Wieder andere funktionieren nur in manchen Situationen falsch. Für die Fehlersuche ist es deshalb hilfreich, grundlegende Fehlerarten zu unterscheiden.

Syntaxfehler, Schreibfehler

Logikfehler, Denkfehler

Laufzeitfehler, Abbruch

Eingabefehler, Datenfehler

Bedingungsfehler, Reihenfolgefehler

Darstellungsfehler, Ausgabeprobleme

Beispiele:

Ein fehlendes Zeichen verhindert den Start eines Programms.

Eine falsche Bedingung lässt eine Figur endlos laufen.

Eine Division durch null führt zum Abbruch.

Ein leeres Eingabefeld erzeugt ein unerwartetes Verhalten.

Ein Wert wird richtig berechnet, aber falsch angezeigt.

Fehlermeldungen lesen und deuten

Erfolgreiches Debugging beginnt oft mit genauer Aufmerksamkeit für Rückmeldungen des Systems, weil Fehlermeldungen, Markierungen und Warnhinweise meist schon erste Informationen darüber geben, wo und warum ein Programm nicht wie erwartet arbeitet.

Entwicklungsumgebungen helfen häufig bei der Fehlersuche. Sie markieren problematische Stellen, zeigen Zeilennummern an oder geben kurze Hinweise zur Art des Problems. Diese Meldungen müssen gelesen, übersetzt und mit dem eigenen Code in Verbindung gebracht werden.

Meldung, Hinweis

Zeile, Position

Warnung, Markierung

Startfehler, Laufzeitfehler

Symbol, Text

Deutung, Prüfung

Beispiele:

Eine rote Markierung zeigt eine fehlerhafte Zeile.

Eine Meldung weist auf ein unbekanntes Zeichen hin.

Ein Hinweis nennt eine Variable, die nicht definiert wurde.

Ein Blockprogramm markiert einen unverbundenen Baustein.

Eine Konsole zeigt einen unerwarteten Wert.

Orientierung auf einen Blick

Als Nächstes	Kurz erklärt
Fehler systematisch eingrenzen	Gezielte Korrektur wird erst dann möglich, wenn ein Problem Schritt für Schritt verkleinert wird, weil große Programme oder längere Abläufe sonst zu unübersichtlich bleiben und zufälliges Herumprobieren oft neue Fehler erzeugt.
Testen mit konkreten Beispielen	Fehler werden oft schneller sichtbar, wenn Programme nicht allgemein, sondern mit gezielt ausgewählten Eingaben überprüft werden, weil dadurch Erwartungen klar formuliert und Abweichungen leichter erkannt werden können.
Variablen, Bedingungen und Abläufe prüfen	Viele Programmfehler entstehen dort, wo Werte gespeichert, verglichen oder in bestimmter Reihenfolge verarbeitet werden, weshalb Variablen, Bedingungen und Ablaufstrukturen besonders sorgfältig kontrolliert werden sollten.

Merke: Achte beim Weiterlesen darauf, wie die nächsten Teilaspekte mit den bereits behandelten Grundlagen zusammenhängen.

Fehler systematisch eingrenzen

Gezielte Korrektur wird erst dann möglich, wenn ein Problem Schritt für Schritt verkleinert wird, weil große Programme oder längere Abläufe sonst zu unübersichtlich bleiben und zufälliges Herumprobieren oft neue Fehler erzeugt.

Eine wichtige Strategie besteht darin, den Fehlerbereich einzugrenzen. Dazu wird geprüft, welcher Teil noch korrekt funktioniert und ab welcher Stelle das Problem auftritt. So wird aus einem unklaren Gesamtfehler ein bearbeitbares Teilproblem.

Eingrenzen, Zerlegen

Teilprogramm, Abschnitt

Vorher, Nachher

Funktion, Störung

Testschritt, Vergleich

Bereich, Fokus

Beispiele:

Zuerst wird geprüft, ob die Eingabe erkannt wird.

Danach wird kontrolliert, ob die Verarbeitung stimmt.

Am Ende wird die Ausgabe untersucht.

Bei einem Spiel wird erst die Bewegung, dann die Kollision geprüft.

Bei einem Formular wird zuerst die Eingabe, dann die Speicherung getestet.

Testen mit konkreten Beispielen

Fehler werden oft schneller sichtbar, wenn Programme nicht allgemein, sondern mit gezielt ausgewählten Eingaben überprüft werden, weil dadurch Erwartungen klar formuliert und Abweichungen leichter erkannt werden können.

Testen bedeutet, ein Programm mit bestimmten Fällen bewusst zu überprüfen. Gute Testfälle zeigen nicht nur, dass etwas funktioniert, sondern auch, wo es unter besonderen Bedingungen versagt. Deshalb sollten einfache, typische und schwierige Eingaben kombiniert werden.

Testfall, Beispiel

Eingabe, Erwartung

Normalfall, Grenzfall

Leerwert, Sonderfall

Prüfung, Vergleich

Ergebnis, Abweichung

Beispiele:

Eine Rechenfunktion wird mit positiven, negativen und null-Werten getestet.

Ein Quiz wird mit richtiger und falscher Antwort geprüft.

Ein Formular wird mit leerem Namen und doppelter Eingabe ausprobiert.

Ein Spiel wird mit schneller und langsamer Tasteneingabe getestet.

Variablen, Bedingungen und Abläufe prüfen

Viele Programmfehler entstehen dort, wo Werte gespeichert, verglichen oder in bestimmter Reihenfolge verarbeitet werden, weshalb Variablen, Bedingungen und Ablaufstrukturen besonders sorgfältig kontrolliert werden sollten.

Variablen speichern Zustände, Punkte, Namen oder Zähler. Bedingungen steuern, wann etwas geschieht. Schleifen wiederholen Abläufe. Genau an diesen Stellen treten häufig Fehler auf, etwa falsche Startwerte, ungenaue Vergleiche oder ungeeignete Reihenfolgen.

Variable, Wert

Bedingung, Vergleich

Schleife, Wiederholung

Startwert, Zähler

Reihenfolge, Ablauf

Zustand, Änderung

Beispiele:

Der Punktestand startet nicht bei null.

Eine Figur verschwindet, weil eine Bedingung zu früh erfüllt ist.

Eine Schleife endet nie, weil sich der Zähler nicht ändert.

Ein Programm prüft zuerst die falsche Bedingung und reagiert deshalb falsch.

Zweiter Zwischenüberblick

Vertiefung	Wichtig dabei
Debugging-Werkzeuge nutzen	Die Fehlersuche wird deutlich präziser, wenn Werkzeuge wie Schritt-Ausführung, Ausgabefenster oder Kontrollanzeigen eingesetzt werden, weil dadurch unsichtbare Zustände und Veränderungen im Programmverlauf besser beobachtbar werden.
Korrekturen prüfen und absichern	Eine Änderung ist erst dann sinnvoll abgeschlossen, wenn nach der Korrektur erneut getestet wird, weil eine schnelle Reparatur sonst unbemerkt neue Fehler erzeugen oder frühere Funktionen beeinträchtigen kann.
Typische Strategien für erfolgreiche Fehlersuche	Nachhaltige Debugging-Kompetenz wächst, wenn Schülerinnen und Schüler nicht nur einzelne Fehler beheben, sondern verlässliche Strategien entwickeln, die sich auf neue Programme und unbekannte Probleme übertragen lassen.

Merke: Die Teilaspekte gehören zusammen: Fachwissen wird besonders tragfähig, wenn du Zusammenhänge an konkreten Beispielen erklären kannst.

Debugging-Werkzeuge nutzen

Die Fehlersuche wird deutlich präziser, wenn Werkzeuge wie Schritt-Ausführung, Ausgabefenster oder Kontrollanzeigen eingesetzt werden, weil dadurch unsichtbare Zustände und Veränderungen im Programmverlauf besser beobachtbar werden.

Debugging bedeutet, ein Programm gezielt zu beobachten. Dabei helfen Ausgaben von Zwischenwerten, das schrittweise Durchlaufen eines Programms, das Markieren von Haltepunkten oder das Sichtbarmachen von Variablenwerten. Solche Werkzeuge machen den inneren Ablauf besser verständlich.

Debugger, Haltepunkt

Schrittlauf, Kontrolle

Konsole, Ausgabe

Wertanzeige, Beobachtung

Zwischenstand, Prüfung

Werkzeug, Unterstützung

Beispiele:

Nach jeder Berechnung wird ein Zwischenwert ausgegeben.

Ein Debugger stoppt vor einer Bedingung.

Eine Variable wird während des Ablaufs beobachtet.

Ein Scratch-Projekt zeigt sichtbar, wie sich Werte ändern.

Ein Fehler wird entdeckt, weil ein Wert nie aktualisiert wird.

Korrekturen prüfen und absichern

Eine Änderung ist erst dann sinnvoll abgeschlossen, wenn nach der Korrektur erneut getestet wird, weil eine schnelle Reparatur sonst unbemerkt neue Fehler erzeugen oder frühere Funktionen beeinträchtigen kann.

Nach der Korrektur sollte geprüft werden, ob das ursprüngliche Problem wirklich gelöst ist und ob das Programm an anderen Stellen weiterhin korrekt arbeitet. Gute Fehlersuche endet also nicht mit dem ersten Fund, sondern mit bewusster Absicherung.

Korrektur, Kontrolle

Nachtest, Vergleich

Wirkung, Nebenwirkung

Altfall, Neufall

Stabilität, Sicherheit

Abschluss, Prüfung

Beispiele:

Nach einer neuen Bedingung wird geprüft, ob andere Spielfunktionen weiterlaufen.

Nach einer Änderung im Formular werden alle Eingabefelder erneut getestet.

Nach einem Syntaxfehler wird kontrolliert, ob das Programm insgesamt startet und richtig reagiert.

Typische Strategien für erfolgreiche Fehlersuche

Nachhaltige Debugging-Kompetenz wächst, wenn Schülerinnen und Schüler nicht nur einzelne Fehler beheben, sondern verlässliche Strategien entwickeln, die sich auf neue Programme und unbekannte Probleme übertragen lassen.

Zu erfolgreichen Strategien gehören: ruhig bleiben, Problem genau beschreiben, Fehlermeldung lesen, Teilbereiche prüfen, mit einfachen Testfällen beginnen, nur eine Änderung auf einmal vornehmen und Ergebnisse dokumentieren. Diese Strategien sind oft wirksamer als hektisches Probieren.

Ruhig, bleiben

Problem, beschreiben

Meldung, lesen

Teilbereich, prüfen

Änderung, einzeln

Ergebnis, notieren

Beispiele:

Nicht drei Dinge gleichzeitig ändern, sondern schrittweise vorgehen.

Zuerst den kleinsten fehlerhaften Abschnitt prüfen.

Nach jeder Änderung erneut testen.

Einen Mitschüler den Ablauf erklären, um Denkfehler zu erkennen.

Begriffe und Zusammenhänge auf einen Blick

Thema	Das solltest du verbinden können
Programmfehler als normaler Teil der Entwicklung	Ein tragfähiges Verständnis entsteht dann, wenn Fehler nicht als Scheitern, sondern als gewöhnlicher Teil von Programmierung betrachtet werden, weil gerade an ihnen sichtbar wird, wie genau Abläufe, Bedingungen und Daten in einem Programm zusammenwirken.
Fehlermeldungen lesen und deuten	Erfolgreiches Debugging beginnt oft mit genauer Aufmerksamkeit für Rückmeldungen des Systems, weil Fehlermeldungen, Markierungen und Warnhinweise meist schon erste Informationen darüber geben, wo und warum ein Programm nicht wie erwartet arbeitet.
Testen mit konkreten Beispielen	Fehler werden oft schneller sichtbar, wenn Programme nicht allgemein, sondern mit gezielt ausgewählten Eingaben überprüft werden, weil dadurch Erwartungen klar formuliert und Abweichungen leichter erkannt werden können.
Debugging-Werkzeuge nutzen	Die Fehlersuche wird deutlich präziser, wenn Werkzeuge wie Schritt-Ausführung, Ausgabefenster oder Kontrollanzeigen eingesetzt werden, weil dadurch unsichtbare Zustände und Veränderungen im Programmverlauf besser beobachtbar werden.
Typische Strategien für erfolgreiche Fehlersuche	Nachhaltige Debugging-Kompetenz wächst, wenn Schülerinnen und Schüler nicht nur einzelne Fehler beheben, sondern verlässliche Strategien entwickeln, die sich auf neue Programme und unbekannte Probleme übertragen lassen.

Merke: Nutze die Tabellen nicht nur zum Nachlesen: Versuche, jede Zeile mit einem eigenen Beispiel oder einer eigenen Begründung zu ergänzen.

Kurz zusammengefasst

Kernkompetenz	Das bedeutet konkret
Fehlerarten erkennen, Unterschiede benennen	„Fehlerarten“ in konkreten Beispielen anhand typischer Merkmale identifizieren und von ähnlichen Fällen abgrenzen. Zum Thema „Unterschiede“ die wichtigsten Elemente oder Begriffe korrekt nennen und passende Beispiele zuordnen.
Meldungen lesen, Hinweise nutzen	Meldungen Schritt für Schritt aus der Darstellung herauslesen und die wesentlichen Zusammenhänge erklären. „Hinweise“ in einer konkreten Aufgabe zweckmäßig einsetzen und das Ergebnis anschließend überprüfen.
Ursachen vermuten, Prüfschritte planen	Aus beobachtbaren Symptomen mehrere plausible Ursachen ableiten und sie anschließend systematisch prüfen. Für „Prüfschritte“ Ziel, notwendige Schritte, Reihenfolge und wichtige Rahmenbedingungen festlegen.
Code prüfen, Logik kontrollieren	„Code“ anhand festgelegter Kriterien kontrollieren und Fehler, Risiken oder Auffälligkeiten begründet benennen. „Logik“ systematisch überprüfen und Abweichungen bzw. notwendige Korrekturen festhalten.
Eingaben testen, Ausgaben vergleichen	Eingaben mit passenden Normal-, Rand- und Fehlerfällen prüfen und Abweichungen dokumentieren. Varianten von „Ausgaben“ anhand sinnvoller Kriterien gegenüberstellen und relevante Gemeinsamkeiten sowie Unterschiede herausarbeiten.
Teilprogramme isolieren, Fehler eingrenzen	Einen verdächtigen Programmteil getrennt testen, um die Fehlerursache auf einen kleineren Bereich einzugrenzen. Durch gezielte Tests bestimmen, in welchem Teil eines Systems oder Programms die Ursache wahrscheinlich liegt.
Debugging nutzen, Werte beobachten	„Debugging“ in einer konkreten Aufgabe zweckmäßig einsetzen und das Ergebnis anschließend überprüfen. Werte gezielt verfolgen, Veränderungen festhalten und daraus fachlich begründete Schlüsse ziehen.
Korrekturen vornehmen, Wirkungen prüfen	Eine vermutete Fehlerursache gezielt beheben und anschließend prüfen, ob die Änderung das Problem löst. „Wirkungen“ anhand festgelegter Kriterien kontrollieren und Fehler, Risiken oder Auffälligkeiten begründet benennen.
Testfälle anwenden, Ergebnisse sichern	„Testfälle“ in einer passenden Aufgabe korrekt einsetzen und erklären, warum das Vorgehen geeignet ist. Arbeit regelmäßig speichern, sinnvoll benennen und bei wichtigen Projekten zusätzlich sichern bzw. versionieren.
Lösungswege erklären, Verbesserungen begründen	Den Zusammenhang „Lösungswege“ in eigenen Worten erläutern und an einem passenden Beispiel zeigen. „Verbesserungen“ mit nachvollziehbaren Kriterien, Fakten oder Beispielen begründen.

Merke: Die wichtigsten Inhalte solltest du nicht nur wiedergeben, sondern auf neue Situationen übertragen, begründet anwenden und kritisch beurteilen können.

Weiterführende Links

• Python Documentation
• MDN Web Docs
• GitHub Docs

Passende LearningSnacks

• Python 3 - Grundlagen
• Python 3 - Kontrollstrukturen I

Übungen

Die Aufgaben setzen die Inhalte praktisch um. Der konkrete Auftrag steht bei jeder Aufgabe ausdrücklich unter Arbeitsauftrag:.

Fehlerdetektive im fremden Programm

Arbeitsauftrag:

Bearbeite die Aufgabe „Fehlerdetektive im fremden Programm“ anhand der folgenden Vorgaben:

Die Lehrkraft stellt ein kurzes fehlerhaftes Programm oder Scratch-Projekt bereit. Die Schülerinnen und Schüler testen zuerst nur das Verhalten und notieren genau, was nicht funktioniert. Danach formulieren sie Vermutungen zur Ursache, markieren verdächtige Stellen und prüfen diese nacheinander. Erst nach der Eingrenzung dürfen Änderungen vorgenommen werden. Anschließend vergleichen die Gruppen, welche Hinweise früh hilfreich waren und welche Vermutungen sich als falsch erwiesen haben.

Hinweise aus der Aufgabe

• Material, Testprojekt
• Beobachtung, Verhalten
• Vermutung, Ursache
• Eingrenzung, Prüfschritt
• Korrektur, Nachtest
• Produkte, Fehlerprotokoll

Fehlermeldungen lesen statt raten

Arbeitsauftrag:

Bearbeite die Aufgabe „Fehlermeldungen lesen statt raten“ anhand der folgenden Vorgaben:

Die Lehrkraft bereitet kleine Programme mit typischen Syntax-oder Laufzeitfehlern vor. Die Schülerinnen und Schüler lesen die Meldungen, markieren Schlüsselwörter, ordnen die betroffene Stelle zu und beschreiben in eigenen Worten, was das System mitteilt. Danach prüfen sie, welche Korrektur zur Meldung passt, und testen das Ergebnis erneut. In der Auswertung wird besprochen, welche Formulierungen leicht verständlich waren und welche Meldungen zusätzliche Erklärung brauchten.

Hinweise aus der Aufgabe

• Meldung, Hinweis
• Zeile, Stelle
• Schlüsselwort, Deutung
• Korrektur, Prüfung
• Nachtest, Kontrolle
• Produkte, Übersetzung

Fehlerbereich eingrenzen

Arbeitsauftrag:

Bearbeite die Aufgabe „Fehlerbereich eingrenzen“ anhand der folgenden Vorgaben:

Die Lehrkraft gibt ein Programm mit mehreren Abschnitten, etwa Eingabe, Verarbeitung und Ausgabe. Die Schülerinnen und Schüler prüfen nacheinander, welcher Teil korrekt funktioniert und ab welchem Punkt das fehlerhafte Verhalten sichtbar wird. Dazu verwenden sie einfache Kontrollfragen oder Zwischenanzeigen. Danach formulieren sie, in welchem Bereich der Fehler wahrscheinlich liegt, und konzentrieren ihre Korrektur nur auf diesen Teil.

Hinweise aus der Aufgabe

• Bereiche, Eingabe
• Bereiche, Verarbeitung
• Bereiche, Ausgabe
• Kontrolle, Zwischenstand
• Fokus, Teilproblem
• Produkte, Eingrenzungsplan

Testfälle selbst entwickeln

Arbeitsauftrag:

Bearbeite die Aufgabe „Testfälle selbst entwickeln“ anhand der folgenden Vorgaben:

Die Schülerinnen und Schüler erhalten eine kleine Funktion, etwa eine Berechnung, ein Quiz, eine Eingabeprüfung oder einen Bewegungsablauf. Zuerst entwickeln sie passende Testfälle mit erwarteten Ergebnissen, darunter Normalfälle, Randfälle und Fehlbedienungen. Danach führen sie die Tests durch, dokumentieren Abweichungen und entscheiden, welche Fehler zuerst korrigiert werden sollten. Nach jeder Änderung werden dieselben Testfälle erneut verwendet.

Hinweise aus der Aufgabe

• Testfall, Erwartung
• Normalfall, Randfall
• Eingabe, Ergebnis
• Abweichung, Priorität
• Nachtest, Vergleich
• Produkte, Testliste

Variablen unter Beobachtung

Arbeitsauftrag:

Bearbeite die Aufgabe „Variablen unter Beobachtung“ anhand der folgenden Vorgaben:

Die Lehrkraft stellt ein Programm bereit, in dem Zähler, Punkte oder Zustände falsch verarbeitet werden. Die Schülerinnen und Schüler beobachten während der Ausführung gezielt einzelne Variablen, notieren deren Veränderungen und vergleichen diese mit dem erwarteten Verlauf. Danach suchen sie die Stelle, an der ein Wert falsch gesetzt, nicht aktualisiert oder zu früh überschrieben wird. Anschließend korrigieren sie den Ablauf und prüfen erneut.

Hinweise aus der Aufgabe

• Variable, Wert
• Zähler, Zustand
• Beobachtung, Verlauf
• Abweichung, Ursache
• Änderung, Kontrolle
• Produkte, Wertetabelle

Debugging im Partnerteam

Arbeitsauftrag:

Bearbeite die Aufgabe „Debugging im Partnerteam“ anhand der folgenden Vorgaben:

Die Klasse arbeitet paarweise. Eine Person erklärt jeden Prüfschritt laut, die andere beobachtet, stellt Rückfragen und achtet auf Widersprüche. Gemeinsam testen die Paare ein fehlerhaftes Programm, formulieren Hypothesen und entscheiden nach jeder Beobachtung über den nächsten Schritt. Rollen werden danach gewechselt. In der Auswertung beschreiben die Lernenden, an welchen Stellen das gemeinsame Erklären den entscheidenden Hinweis geliefert hat.

Hinweise aus der Aufgabe

• Partnerarbeit, Rollen
• Erklären, Nachfragen
• Hypothese, Prüfschritt
• Wechsel, Kontrolle
• Gespräch, Einsicht
• Produkte, Teamprotokoll

Nur eine Änderung gleichzeitig

Arbeitsauftrag:

Bearbeite die Aufgabe „Nur eine Änderung gleichzeitig“ anhand der folgenden Vorgaben:

Die Lehrkraft stellt ein fehlerhaftes Programm mit mehreren möglichen Problemstellen bereit. Die Schülerinnen und Schüler dürfen immer nur eine Änderung vornehmen und müssen danach sofort erneut testen. Jede Änderung wird kurz notiert. In der Reflexion vergleichen die Gruppen, wie übersichtlich der Prozess blieb und wie leicht sich Nebenwirkungen erkennen ließen.

Hinweise aus der Aufgabe

• Änderung, einzeln
• Test, sofort
• Notiz, Verlauf
• Wirkung, Nebenwirkung
• Kontrolle, Übersicht
• Produkte, Änderungslog

Fehlerarten sortieren

Arbeitsauftrag:

Bearbeite die Aufgabe „Fehlerarten sortieren“ anhand der folgenden Vorgaben:

Die Lehrkraft gibt mehrere kurze Beispiele mit unterschiedlichen Fehlerarten. Die Schülerinnen und Schüler ordnen zu, ob es sich eher um Syntaxfehler, Logikfehler, Laufzeitfehler oder Eingabefehler handelt. Danach beschreiben sie, welche Suchstrategie am besten passt, etwa Meldung lesen, Variablen beobachten, Testfall verändern oder Ablauf prüfen. Anschließend korrigieren sie die Beispiele und vergleichen, ob ihre erste Einordnung hilfreich war.

Hinweise aus der Aufgabe

• Fehlerart, Syntax
• Fehlerart, Logik
• Fehlerart, Laufzeit
• Fehlerart, Eingabe
• Strategie, Auswahl
• Produkte, Sortierblatt

Vorher-Nachher-Vergleich

Arbeitsauftrag:

Bearbeite die Aufgabe „Vorher-Nachher-Vergleich“ anhand der folgenden Vorgaben:

Die Schülerinnen und Schüler dokumentieren vor jeder Korrektur das fehlerhafte Verhalten mit kurzer Beschreibung, Screenshot oder Beobachtungsnotiz. Nach der Änderung wiederholen sie denselben Test und halten das neue Verhalten fest. Danach vergleichen sie beide Zustände und formulieren präzise, was sich verbessert hat und ob noch Restprobleme vorhanden sind. In der Auswertung wird besprochen, warum genaue Vergleichsdokumentation bei Fehlersuche nützlich ist.

Hinweise aus der Aufgabe

• Vorher, Nachher
• Beschreibung, Screenshot
• Test, Wiederholung
• Verbesserung, Restfehler
• Vergleich, Erklärung
• Produkte, Dokumentation

Fehlerkonferenz der Klasse

Arbeitsauftrag:

Bearbeite die Aufgabe „Fehlerkonferenz der Klasse“ anhand der folgenden Vorgaben:

Mehrere Gruppen bearbeiten unterschiedliche fehlerhafte Programme oder verschiedene Fehler in demselben Projekt. Danach stellt jede Gruppe kurz ihren Fehler, ihre ersten Vermutungen, den erfolgreichsten Prüfschritt und die endgültige Korrektur vor. Die Klasse sammelt daraus gemeinsame Regeln für erfolgreiche Fehlersuche. Anschließend wird diskutiert, welche Strategien allgemein übertragbar sind.

Hinweise aus der Aufgabe

• Gruppe, Fall
• Vermutung, Prüfschritt
• Korrektur, Ergebnis
• Sammlung, Regeln
• Austausch, Strategien
• Produkte, Klassenplakat

Kompetenzcheck

Überprüfe am Ende selbst, ob du die zentralen Kompetenzen dieses Kapitels sicher anwenden kannst:

Ich kann …	Ja	Noch üben
häufige Programmfehler wie Syntax-, Laufzeit- und Logikfehler unterscheiden.	☐	☐
Fehlermeldungen aufmerksam lesen und daraus sinnvolle nächste Prüfschritte ableiten.	☐	☐
einen Fehler systematisch eingrenzen, statt mehrere Stellen gleichzeitig unkontrolliert zu verändern.	☐	☐
Testfälle verwenden, um fehlerhafte Eingaben, Bedingungen, Schleifen oder Variablen zu erkennen.	☐	☐
Debugging-Werkzeuge und Beobachtungen von Variablenwerten gezielt zur Fehlersuche einsetzen.	☐	☐
nach einer Korrektur erneut testen und dokumentieren, warum die Änderung das Problem tatsächlich behoben hat.	☐	☐