DGB 2: Einfache Programme erstellen, testen und debuggen
12.1 Lernziele
Die Schülerinnen und Schüler können:
- erklären, was eine Entwicklungsumgebung ist und wozu sie beim Programmieren dient.
- einfache Programme in einer geeigneten Umgebung erstellen und ausführen.
- Befehle, Reihenfolgen und einfache Abläufe in Programmen gezielt einsetzen.
- Eingaben, Ausgaben und einfache Variablen in überschaubaren Programmen nutzen.
- erkennen, dass Programme nur bei korrekten und eindeutig formulierten Anweisungen wie gewünscht funktionieren.
- Programme schrittweise testen und das Ergebnis mit der geplanten Wirkung vergleichen.
- einfache Fehler in Programmen erkennen, beschreiben und beheben.
- zwischen Fehlern in der Idee, in der Reihenfolge und in der Umsetzung unterscheiden.
- Hilfen der Entwicklungsumgebung wie Fehlermeldungen, Markierungen oder Testläufe nutzen.
- Programme nach einer Korrektur erneut testen und Verbesserungen nachvollziehbar erklären.
12.2 Lerninhalte
Die Auseinandersetzung mit Entwicklungsumgebungen, Programmaufbau, Testen und
perfekt entstehen, sondern schrittweise entwickelt, überprüft und verbessert werden. Eine geeignete Entwicklungsumgebung bietet Werkzeuge, mit denen Programme geschrieben, gespeichert, ausgeführt und verbessert werden können. Je nach Altersstufe kann dies eine blockbasierte Umgebung wie Scratch oder Open Roberta sein oder eine textbasierte Umgebung mit einfacher Programmiersprache. Solche Umgebungen helfen beim Einstieg, weil sie Befehle sichtbar machen, Rückmeldungen geben und das Ausprobieren erleichtern.
Schülerinnen und Schüler sollen verstehen, dass die Entwicklungsumgebung nicht das Programm selbst ist, sondern ein Arbeitsraum, in dem Programme entstehen und überprüft werden. Zu Beginn steht das Kennenlernen zentraler Bestandteile einer Entwicklungsumgebung. Dazu gehören etwa Arbeitsfläche, Befehlsbereich, Skriptfenster, Ausgabefenster, Startknopf, Speicherfunktion und Fehlermeldungen. In blockbasierten Umgebungen werden Befehle häufig
wie Bausteine zusammengesetzt. In textbasierten Umgebungen müssen Anweisungen genau geschrieben werden. Beide Formen verfolgen dasselbe Ziel: Ein Ablauf soll so beschrieben werden, dass der Computer ihn eindeutig ausführen kann. Dadurch lernen die Schülerinnen und Schüler, dass Programmieren ein präzises Formulieren von Anweisungen ist. Entwicklungsumgebungen Scratch, Open Roberta, MakeCode, Python-IDLE, App Inventor, Blockly Bestandteile Arbeitsfläche, Befehle, Skriptfenster, Startknopf, Ausgabe, Fehlermeldung Ein wichtiger Lerninhalt ist der Aufbau einfacher Programme.
Programme bestehen aus Anweisungen, die in einer sinnvollen Reihenfolge ausgeführt werden. Beispiele sind eine Figur bewegen, einen Text ausgeben, auf eine Eingabe reagieren oder einen Ton abspielen. Schon bei sehr einfachen Programmen wird sichtbar, dass die Reihenfolge entscheidend ist. Wenn eine Ausgabe vor der Berechnung erfolgt oder ein Block an der falschen Stelle steht, entsteht ein anderes oder kein sinnvolles Ergebnis. Diese Einsicht stärkt das algorithmische Denken und hilft, Programmabläufe nachvollziehbar zu planen.
Typische erste Programme sind zum Beispiel Begrüßungsprogramme, kleine Rechenprogramme, Quizfragen, Bewegungsabläufe einer Figur oder einfache interaktive Geschichten. In Scratch kann eine Figur etwa beim Klick sprechen, sich bewegen und auf Berührungen reagieren. In einer textbasierten Umgebung kann ein kleines Programm einen Namen abfragen und danach eine passende Begrüßung ausgeben. Solche Beispiele sind überschaubar, motivierend und gut geeignet, um den Zusammenhang zwischen Anweisung und Wirkung unmittelbar zu erkennen.
Programmarten Begrüßung, Quiz, Rechenprogramm, Bewegung, Geschichte, Spiel Grundelemente Befehl, Reihenfolge, Eingabe, Ausgabe, Variable, Bedingung Das Testen ist ein zentraler Bestandteil der Programmarbeit. Ein Programm sollte nicht nur geschrieben, sondern wiederholt ausprobiert werden. Dabei wird geprüft, ob es wirklich das tut, was geplant war. Testen bedeutet, verschiedene Eingaben und Situationen durchzuspielen und die Ergebnisse bewusst zu beobachten. Wenn ein Rechenprogramm nur mit einer Zahl funktioniert, aber bei einer anderen versagt, zeigt sich, dass noch nicht ausreichend getestet wurde.
Diese Haltung ist wichtig, weil sie vermittelt, dass Programmieren ein Prozess des Überprüfens und Verbesserns ist. Zum Testen gehört auch der Vergleich zwischen Erwartung und tatsächlichem Ergebnis. Schülerinnen und Schüler sollen lernen, vor dem Ausführen eines Programms zu überlegen, was passieren müsste, und danach zu prüfen, ob genau dies eingetreten ist. Wenn eine Figur nach rechts statt nach links läuft oder wenn eine Frage immer dieselbe Rückmeldung gibt, obwohl unterschiedliche Antworten eingegeben wurden, muss die Ursache gesucht werden. So wird Testen zu einem bewussten Denkprozess und nicht nur zum Klicken auf Start.
unterschiedliche Ursachen haben. Manchmal ist die Idee unklar, manchmal ist die Reihenfolge der Schritte falsch, manchmal fehlt ein Befehl oder eine Bedingung ist unpassend formuliert. In textbasierten Sprachen kommen zusätzlich Schreibfehler, fehlende Zeichen oder falsche Einrückungen hinzu. In blockbasierten Umgebungen sind logische Fehler besonders häufig, etwa dass ein Ereignis nie ausgelöst wird oder eine Figur nicht auf das richtige Signal reagiert.
Schülerinnen und Schüler sollen erkennen, dass Fehler normal sind und Hinweise für
Verknüpfungsfehler Ein systematisches Vorgehen beim Debugging ist besonders wichtig. Statt wahllos vieles gleichzeitig zu ändern, sollte ein Fehler schrittweise untersucht werden. Hilfreich ist es, nur einen Teil des Programms zu prüfen, Zwischenausgaben einzubauen oder einzelne Blöcke vorübergehend zu vereinfachen. In einer textbasierten Umgebung kann man Zwischenergebnisse ausgeben lassen. In Scratch kann man beobachten, welche Variable sich verändert oder ob ein bestimmter Block überhaupt erreicht wird. Dadurch lernen die Schülerinnen und Schüler, planvoll statt zufällig zu verbessern.
Didaktisch besonders wertvoll sind typische Fehlersituationen. Eine Figur bewegt sich nicht, weil das Startsignal fehlt. Eine Abfrage funktioniert nicht, weil die Bedingung falsch formuliert ist. Eine Variable wird nicht verändert, obwohl sie gezählt werden soll. Ein Python-Programm startet nicht, weil ein Doppelpunkt oder eine Klammer fehlt. Ein Quiz gibt immer dieselbe Antwort aus, weil die Verzweigung falsch angeordnet ist. Solche Fälle helfen, Fehlersuche an echten Beispielen zu üben und aus Fehlern tragfähige Einsichten zu gewinnen. Auch Fehlermeldungen der Entwicklungsumgebung sollen genutzt werden.
Gerade Anfängerinnen und Anfänger lesen Fehlermeldungen oft nicht genau oder verstehen sie zunächst nicht. Deshalb ist es wichtig, diese gemeinsam zu entschlüsseln: Was wird markiert, an welcher Stelle liegt das Problem, welche Art von Fehler könnte gemeint sein? In blockbasierten Umgebungen treten eher sichtbare Funktionsprobleme auf, in textbasierten Umgebungen helfen Markierungen und Hinweise der Umgebung oft direkt beim Auffinden. So wird die Entwicklungsumgebung selbst zu einem Werkzeug der Problemlösung.
Debuggingstrategien eingrenzen, Teil prüfen, vergleichen, vereinfachen, markieren, erneut testen Hilfsmittel Fehlermeldung, Markierung, Testlauf, Variable, Zwischenausgabe, Beobachtung Ein weiterer wichtiger Lerninhalt ist das Verbessern von Programmen nach dem ersten Funktionieren. Ein Programm kann korrekt laufen und dennoch unübersichtlich, umständlich oder schwer verständlich sein. Schülerinnen und Schüler sollen lernen, Programme auch im Hinblick auf Klarheit und einfache Struktur zu überarbeiten.
Dazu gehört, Anweisungen sinnvoll anzuordnen, verständliche Namen zu wählen, unnötige Schritte zu vermeiden und ähnliche Abläufe zusammenzufassen. Dadurch wird vermittelt, dass gutes Programmieren nicht nur Fehlerfreiheit, sondern auch Qualität der Lösung umfasst. Praktische Beispiele aus dem Unterricht helfen, diese Inhalte zu verbinden. In einem kleinen Quizprogramm werden Fragen gestellt und Antworten geprüft. Beim Testen fällt auf, dass Groß- und Kleinschreibung zu Problemen führen. In einem Bewegungsprogramm reagiert eine Figur nur einmal, weil eine Wiederholung fehlt.
In einem Rechenprogramm wird eine Zahl nicht richtig verarbeitet, weil sie als Text behandelt wird. In einer interaktiven Geschichte springt der Ablauf an die falsche Stelle, weil Bedingungen falsch verkettet sind. Solche Beispiele verknüpfen Entwicklungsumgebung, Programmaufbau, Testen und Debugging auf anschauliche Weise.
Ebenso wichtig ist die Haltung zum Fehler. Fehler sind kein Zeichen des Scheiterns, sondern ein normaler Bestandteil informatischen Arbeitens. Wer programmiert, plant, probiert aus, testet, entdeckt Probleme und verbessert. Diese Erfahrung stärkt Ausdauer, Genauigkeit und problemlösendes Denken. Gerade im Unterricht sollte deshalb eine Lernkultur gefördert werden, in der Fehlversuche offen besprochen, gemeinsam untersucht und als Lernchancen genutzt werden. So wird Debugging nicht als Zusatz, sondern als Kern des Programmierens verstanden.
Lernhaltungen Geduld, Genauigkeit, Ausdauer, Offenheit, Fehlermut, Problemlösen Eine fachübergreifende Verbindung ist leicht möglich. In Mathematik können kleine Rechenprogramme entwickelt und getestet werden. Im Sprachunterricht lassen sich Quiz oder Dialogprogramme erstellen. Im Sachunterricht können Abfolgen, Steuerungen oder kleine Simulationen genutzt werden. Im Kunstunterricht lassen sich interaktive Figuren oder einfache Animationen programmieren. Dadurch wird sichtbar, dass Programmieren nicht nur technisches Schreiben von Befehlen ist, sondern kreatives und problemlösendes Gestalten mit digitalen Mitteln.
Weiterführende Links
- scratch.mit.edu
- open-roberta.org
- makecode.microbit.org
- code.org
- csunplugged.org
- saferinternet.at
12.3 Aufgaben für den Unterricht
12.3.1 Entwicklungsumgebung erkunden und Grundfunktionen nutzen
Die erste gezielte Orientierung in einer geeigneten Entwicklungsumgebung schafft Sicherheit im Umgang mit Werkzeugen und bildet die Grundlage dafür, dass die Schülerinnen und Schüler spätere Programmier- und Testaufgaben selbstständiger und strukturierter bearbeiten können. Die Lernenden öffnen eine einfache Entwicklungsumgebung wie Scratch, Open Roberta oder eine kindgerechte textbasierte Umgebung und erhalten den Auftrag, zentrale Bereiche zu erkunden. Sie lokalisieren Befehlsbereiche, Arbeitsfläche, Startfunktion, Speicheroption, Ausgabefeld und gegebenenfalls Fehlermeldungen.
Anschließend führen sie kleine vorgegebene Aktionen aus, etwa eine Figur sprechen lassen, eine Zahl ausgeben oder ein gespeichertes Projekt erneut öffnen. Die Klasse hält gemeinsam fest, welche Funktionen beim Erstellen, Testen und Verbessern eines Programms besonders wichtig sind. Werkzeuge Arbeitsfläche, Befehlsbereich, Startknopf, Ausgabe, Speicherfunktion, Hilfe Schwerpunkte Orientierung, Sicherheit, Bedienung, Überblick, Grundfunktionen,
Selbstständigkeit Ergebnis Übersichtsblatt, Merkbild, Kurzdemonstration
12.3.2 Erstes einfaches Programm erstellen
Die eigenständige Erstellung eines kleinen Programms fördert das Verständnis dafür, dass Programme aus eindeutig formulierten Anweisungen bestehen und nur dann funktionieren, wenn Schritte vollständig und in sinnvoller Reihenfolge umgesetzt werden. Die Schülerinnen und Schüler erstellen ein erstes kurzes Programm, etwa eine Begrüßung, eine kleine Bewegungsfolge oder eine einfache Bildschirmausgabe. In einer blockbasierten Umgebung können sie eine Figur bei Programmstart sprechen und sich bewegen lassen. In einer textbasierten Umgebung kann ein Name abgefragt und eine passende Begrüßung ausgegeben werden.
Anschließend vergleichen die Lernenden ihre Programme mit der Aufgabenstellung und prüfen, ob die gewünschte Wirkung tatsächlich eintritt. Dadurch verbinden sich Planung, Umsetzung und erste Kontrolle in einer überschaubaren Form. Programmideen Begrüßung, Bewegung, Ausgabe, Ton, Farbwechsel, Reaktion Grundelemente Start, Befehl, Reihenfolge, Eingabe, Ausgabe, Aktion Lernprodukte Erstprogramm, Screenshot, Kurzbeschreibung
12.3.3 Programme schrittweise testen
Das bewusste Testen in kleinen Schritten stärkt die Einsicht, dass Programme nicht nur geschrieben, sondern systematisch überprüft werden müssen, damit Fehler früh sichtbar werden und nicht erst am Ende schwer nachvollziehbare Probleme verursachen. Die Lernenden erhalten die Aufgabe, ein kleines Programm nicht erst nach vollständiger Fertigstellung, sondern nach jedem wichtigen Schritt zu testen. Nach jeder Ergänzung, etwa einer neuen Ausgabe, Bewegung oder Abfrage, führen sie das Programm aus und notieren, ob das Ergebnis ihrer Erwartung entspricht. Dabei beschreiben sie jeweils, was passieren sollte und was tatsächlich geschieht.
Anschließend vergleichen sie in Partnerarbeit ihre Testprotokolle und besprechen, an welchen Stellen frühes Testen besonders hilfreich war. So wird Testen als durchgehender Teil des Programmierens eingeübt.
Beobachtungspunkte Erwartung, Ergebnis, Abweichung, Ursache, Wirkung, Änderung Ergebnis Testprotokoll, Vergleich, Auswertung
12.3.4 Fehlerhafte Programme debuggen
Die gezielte Arbeit mit vorgegebenen fehlerhaften Programmen fördert eine produktive Fehlerkultur und hilft den Schülerinnen und Schülern, typische Probleme nicht nur zu erkennen, sondern auch in nachvollziehbaren Schritten zu beheben. Die Klasse erhält kurze Programme mit bewusst eingebauten Fehlern. Dazu können fehlende Startblöcke, vertauschte Reihenfolgen, falsche Bedingungen, unpassende Variablenwerte oder kleine Schreibfehler gehören. Die Schülerinnen und Schüler führen die Programme aus,
beschreiben das Problem möglichst genau und verändern anschließend nur gezielt jene Stelle, die für den Fehler verantwortlich sein könnte. Danach testen sie erneut und prüfen, ob der Fehler wirklich behoben ist. Die gemeinsame Besprechung macht deutlich, dass Debugging planvolles Untersuchen und nicht bloßes Raten bedeutet.
Bedingungsfehler Debuggingschritte beobachten, eingrenzen, ändern, testen, prüfen, erklären Sicherung Fehlerliste, Lösungsweg, Merkkarte
12.3.5 Eingaben und Ausgaben programmieren
Die bewusste Gestaltung von Eingabe und Ausgabe vertieft das Verständnis dafür, dass Programme auf Informationen reagieren und Ergebnisse nur dann sinnvoll nutzbar sind, wenn Eingaben passend verarbeitet und Ausgaben verständlich dargestellt werden. Die Lernenden programmieren ein kleines Dialogprogramm, das eine Eingabe entgegennimmt und darauf reagiert. Das kann eine Namenseingabe, eine Zahl, eine Antwort auf eine Quizfrage oder eine Auswahl zwischen zwei Möglichkeiten sein. Anschließend testen sie mehrere Eingaben, auch solche, die vom erwarteten Muster abweichen, und prüfen, ob das Programm sinnvoll reagiert.
In der Auswertung wird besprochen, warum Programme nicht nur für den Idealfall geschrieben, sondern auch auf unerwartete Eingaben vorbereitet werden sollten. Elemente Eingabe, Ausgabe, Frage, Antwort, Reaktion, Rückmeldung Testfälle richtig, falsch, leer, ungewöhnlich, mehrfach, unvollständig Ergebnis Dialogprogramm, Testübersicht, Kurzreflexion
12.3.6 Variablen gezielt einsetzen und überprüfen
Die Arbeit mit Variablen unterstützt die Schülerinnen und Schüler dabei zu verstehen, wie Programme Informationen speichern, verändern und später wiederverwenden, und warum genaue Kontrolle solcher Werte für funktionierende Abläufe entscheidend ist. Die Schülerinnen und Schüler erstellen ein kleines Programm mit einer oder mehreren Variablen, etwa für Punktestand, Alter, Anzahl richtiger Antworten oder Anzahl von Schritten. Während des Programmablaufs beobachten sie, wie sich die Werte verändern, und prüfen, ob dies an den richtigen Stellen geschieht.
In blockbasierten Umgebungen können Variablen sichtbar eingeblendet werden, in textbasierten Umgebungen helfen Zwischenausgaben. Danach besprechen die Lernenden, wie leicht Fehler entstehen, wenn eine Variable nicht gesetzt, nicht verändert oder an der falschen Stelle abgefragt wird. Variablenideen Punktestand, Zähler, Alter, Ergebnis, Treffer, Schritte Prüffragen Wann ändert es sich, Wo wird es gesetzt, Was wird angezeigt Lernprodukte Variablenprogramm, Beobachtungsbogen, Auswertung
12.3.7 Eigene Testfälle entwickeln
Die Entwicklung eigener Testfälle fördert vorausschauendes Denken und zeigt, dass gute Programme nicht nur anhand eines einzigen Beispiels überprüft werden sollten, sondern mit mehreren Situationen zuverlässig funktionieren müssen. Die Lernenden erhalten ein kleines Programm, etwa ein Quiz, eine Rechenaufgabe oder eine Eingabeprüfung, und entwickeln dazu selbst passende Testfälle. Sie überlegen, welche Eingaben typisch, grenzwertig oder problematisch sein könnten, und notieren erwartete Ergebnisse. Anschließend führen sie die Tests durch und vergleichen Erwartung und tatsächliches Verhalten.
So lernen die Schülerinnen und Schüler, Programme nicht zufällig, sondern anhand geplanter Prüfsituationen zu bewerten. Das stärkt sowohl Genauigkeit als auch Verständnis für mögliche Fehlerquellen. Testarten Normalfall, Grenzfall, Fehlerfall, Leerfall, Sonderfall, Wiederholung Planungsschritte auswählen, erwarten, testen, vergleichen, notieren, bewerten Ergebnis Testfallliste, Prüftabelle, Kurzbericht
12.3.8 Programme gegenseitig prüfen
Die kooperative Überprüfung durch andere Lernende erweitert die Perspektive auf ein Programm und macht sichtbar, dass unklare Abläufe oder versteckte Fehler oft leichter erkannt werden, wenn jemand anderes das Produkt testet und Rückmeldung gibt. Jeweils zwei Gruppen tauschen ihre Programme aus und testen das Werk der anderen Gruppe, ohne dass vorher zusätzliche Erklärungen gegeben werden. Die testende Gruppe dokumentiert, was gut funktioniert, wo Probleme auftreten und welche Stellen unklar oder fehleranfällig wirken. Danach besprechen beide Gruppen gemeinsam die Rückmeldungen und entscheiden, welche Verbesserungen sie übernehmen.
Diese Aufgabe verbindet Programmieren, Testen und konstruktive Rückmeldung miteinander und fördert ein realistisches Verständnis von Softwareentwicklung als gemeinschaftlichem Verbesserungsprozess. Kooperationsformen Partnergruppe, Austausch, Testphase, Rückmeldung, Überarbeitung, Gespräch Rückmeldungspunkte Funktion, Verständlichkeit, Fehler, Verbesserung, Stabilität, Bedienung Produkte Feedbackbogen, Überarbeitung, Vergleich
12.3.9 Ein kleines Projekt planen, erstellen und verbessern
Die Verbindung von Planung, Umsetzung, Test und Debugging in einem überschaubaren Gesamtprojekt führt die zentralen Teilkompetenzen zusammen und zeigt, dass funktionierende Programme schrittweise entstehen und durch wiederholtes Verbessern an Qualität gewinnen. Die Schülerinnen und Schüler entwickeln ein kleines eigenes Projekt, etwa ein Miniquiz, eine interaktive Geschichte, ein Reaktionsspiel oder einen einfachen Rechner. Zunächst planen sie die gewünschte Funktion in wenigen Schritten. Danach programmieren sie die Grundversion, testen diese systematisch, beheben entdeckte Fehler und ergänzen am Ende eine kleine Erweiterung.
Im Abschlussgespräch reflektieren sie, welche Fehler auftraten, wie sie diese
gefunden haben und welche Teststrategie besonders hilfreich war. So wird Debugging als normaler Bestandteil kreativer Programmarbeit erlebt. Projektideen Quiz, Geschichte, Rechner, Spiel, Animation, Dialog Arbeitsphasen planen, programmieren, testen, debuggen, verbessern, vorstellen Ergebnis Miniprojekt, Testdokumentation, Präsentation
12.3.10 Reflexion und Ergebnissicherung
Die abschließende Sicherung unterstützt die Schülerinnen und Schüler dabei, ihre Erfahrungen mit Entwicklungsumgebung, Programmentwicklung, Testen und Debugging zu einem klaren Arbeitsmodell für zukünftige Programmieraufgaben zusammenzuführen. Die Lernenden halten schriftlich oder mündlich fest, welche Schritte beim Erstellen eines Programms besonders wichtig sind, welche Fehler ihnen begegnet sind und wie sie diese erfolgreich behoben haben. Zusätzlich formulieren sie eigene Regeln für gutes Testen und sinnvolles Debugging, etwa nur eine Änderung nach der anderen vorzunehmen oder vor dem Start eine Erwartung zu notieren.
Die Ergebnisse werden zu einer gemeinsamen Merkhilfe gebündelt und dienen als Orientierung für weitere Programmierprojekte. Reflexionsfragen Was plane ich, Was teste ich, Wo finde ich Fehler, Wie verbessere ich Sicherung Lernjournal, Exit Card, Merkblatt, Wandplakat
Grundlage: Digitale Grundbildung II – Lehrband 2. Klasse, Final V2.5.