DGB 4: Programme entwerfen und iterativ entwickeln mit kombinierten Kontrollstrukturen
11.1 Lernziele
- grundlegende Kontrollstrukturen wie Schleifen und Bedingungen erklären und anwenden.
- if-, else- und elif-Strukturen zur Steuerung von Programmen nutzen.
- zusammengesetzte Bedingungen mit logischen Operatoren formulieren.
- verschachtelte Schleifen zur Bearbeitung mehrstufiger Abläufe einsetzen.
- Programme in Teilschritte zerlegen und vor dem Codieren planen.
- einfache Algorithmen in lauffähige Programme übertragen.
- Programme iterativ entwickeln und schrittweise erweitern.
- Fehler in Programmen erkennen, testen und gezielt beheben.
- die Wirkung von Bedingungen und Schleifen auf den Programmablauf beschreiben.
- Programme lesbar strukturieren und sinnvoll kommentieren.
- verschiedene Lösungswege vergleichen und verbessern.
- kombinierte Kontrollstrukturen in kleinen Projekten anwenden.
11.2 Lerninhalte
Die Lerninhalte führen von den Grundideen der Ablaufsteuerung über verschachtelte und kombinierte Strukturen bis zur iterativen Verbesserung eigener Programme und zeigen, wie Planung, Testen und Debugging eng mit gutem Programmieren verbunden sind.
Grundlagen der Kontrollstrukturen
Kontrollstrukturen bestimmen, in welcher Reihenfolge Anweisungen ausgeführt werden, ob Entscheidungen getroffen werden und wie oft bestimmte Schritte wiederholt werden, weshalb sie das zentrale Gerüst nahezu jedes Programms bilden. Programme bestehen nicht nur aus einzelnen Befehlen, sondern aus gesteuerten Abläufen. Bedingungen entscheiden, ob etwas passieren soll, Schleifen wiederholen Arbeitsschritte, und die Kombination mehrerer Strukturen ermöglicht komplexere Lösungen. Ohne Kontrollstrukturen wären Programme starr und könnten kaum auf Eingaben, Fehler oder
unterschiedliche Situationen reagieren. Ein einfaches Beispiel ist ein Programm, das eine Zahl prüft. Ist die Zahl größer als null, erscheint „positiv“, ist sie kleiner als null, erscheint „negativ“, sonst „null“. Ein anderes Beispiel ist eine Schleife, die die Zahlen von eins bis zehn ausgibt. Schon an diesen einfachen Fällen wird sichtbar, dass Programme Entscheidungen und Wiederholungen brauchen, um sinnvoll zu funktionieren. Strukturen: Bedingung, Schleife, Verzweigung, Wiederholung, Auswahl, Ablauf Grundformen: if, else, elif, for, while, repeat Alltagsbeispiele: Passwortprüfung, Ampelsteuerung, Punktestand, Countdown, Menüauswahl, Eingabekontrolle Schülerinnen und Schüler sollen verstehen, dass Kontrollstrukturen nicht bloß Codebausteine sind, sondern Denkwerkzeuge. Wer einen Ablauf klar beschreiben kann, erkennt leichter, wann wiederholt, wann geprüft und wann verzweigt werden muss.
Verschachtelte Schleifen
Verschachtelte Schleifen kommen überall dort zum Einsatz, wo Wiederholungen innerhalb anderer Wiederholungen stattfinden, etwa bei Tabellen, Gittern, Mustern oder der Verarbeitung mehrdimensionaler Daten und geordneter Felder. Von einer verschachtelten Schleife spricht man, wenn sich eine Schleife innerhalb einer anderen Schleife befindet. Die äußere Schleife steuert meist größere Abschnitte, die innere Schleife bearbeitet die einzelnen Elemente innerhalb dieses Abschnitts. So entstehen mehrstufige Wiederholungen. Ein klassisches Beispiel ist die Multiplikationstabelle. Die äußere Schleife läuft etwa durch die Zeilen von eins bis zehn, die innere Schleife durch die Spalten von eins bis zehn. Für jede Kombination wird ein Produkt berechnet. Ebenso lassen sich mit verschachtelten Schleifen Muster erzeugen, etwa Rechtecke aus Sternen, Treppenmuster oder farbige Raster in einer Blockprogrammierumgebung. Auch bei Spielfeldern, Kalendern oder Pixelbildern sind verschachtelte Schleifen nützlich. Soll etwa jedes Feld eines Gitters überprüft oder eingefärbt werden, wird häufig zeilenweise und innerhalb jeder Zeile spaltenweise gearbeitet. Diese Denkweise ist für viele spätere Programmieraufgaben grundlegend. Einsatzfelder: Tabelle, Raster, Spielfeld, Matrix, Pixelbild, Kalender Typische Aufgaben: zählen, prüfen, zeichnen, füllen, durchsuchen, berechnen Beispiele: Sternmuster, Schachbrett, Stundenplan, Farbraster, Bildpunkte, Multiplikationstafel Didaktisch wichtig ist, dass Lernende äußere und innere Schleife unterscheiden können. Viele Fehler entstehen, wenn nicht klar ist, welche Schleife die Zeilen steuert und welche die einzelnen Elemente innerhalb einer Zeile bearbeitet.
Zusammengesetzte Konditionale
Zusammengesetzte Bedingungen ermöglichen präzisere Entscheidungen, weil mehrere
Merkmale gleichzeitig geprüft, miteinander verknüpft oder ausdrücklich ausgeschlossen werden können, statt nur eine einzige einfache Bedingung zu betrachten. Mit logischen Operatoren wie UND, ODER und NICHT lassen sich Bedingungen kombinieren. Dadurch können Programme differenzierter reagieren. Eine Eingabe soll vielleicht nur akzeptiert werden, wenn sie nicht leer ist und eine Zahl größer als null enthält. Ein Zugriff soll nur erlaubt sein, wenn ein Passwort stimmt oder ein bestimmter Modus aktiv ist. Genau solche Entscheidungen benötigen zusammengesetzte Konditionale. Ein Beispiel aus dem Alltag ist eine Altersprüfung für ein digitales Angebot: Zugang wird nur gewährt, wenn das Alter mindestens 13 ist und die Zustimmung vorliegt. Ein anderes Beispiel ist ein Wetterprogramm, das meldet: „Nimm eine Jacke“, wenn es kalt ist oder regnet. Noch komplexer wird es, wenn Bedingungen verschachtelt und zusätzlich mit else-Zweigen verbunden werden. Schülerinnen und Schüler sollen dabei erkennen, dass die Reihenfolge und die genaue Formulierung von Bedingungen wichtig sind. Schon kleine logische Fehler können dazu führen, dass Programme falsche Entscheidungen treffen oder gar keine passenden Fälle mehr erkennen. Operatoren: UND, ODER, NICHT, gleich, größer, kleiner Prüfsituationen: Login, Eingabe, Spielregel, Altersgrenze, Auswahl, Zugriff Beispiele: Passwortcheck, Notenlogik, Wetterregel, Ticketprüfung, Rabattregel, Spielfigur Besonders hilfreich sind Entscheidungstabellen oder Wahrheitsbeispiele, bei denen verschiedene Eingaben nacheinander geprüft werden. So wird sichtbar, wann eine Bedingung wahr ist und wie sich kombinierte Prüfungen auf das Ergebnis auswirken.
Programme vor dem Codieren entwerfen
Gute Programme entstehen selten direkt beim ersten Tippen, sondern gewinnen an Qualität, wenn Ziele, Eingaben, Ausgaben und Teilschritte vorab geklärt und in einer einfachen Struktur oder Ablaufbeschreibung festgehalten werden. Programmieren beginnt mit Planung. Dazu gehört die Frage, welches Problem gelöst werden soll, welche Daten benötigt werden, welche Schritte nacheinander erfolgen und an welchen Stellen Entscheidungen oder Wiederholungen nötig sind. Schon eine knappe Skizze, ein Ablaufdiagramm oder Pseudocode kann helfen, spätere Fehler zu vermeiden. Ein Programm zur Passwortprüfung braucht zum Beispiel eine Eingabe, eine Prüfung auf Länge, vielleicht weitere Bedingungen für Sonderzeichen und eine klare Rückmeldung. Ein einfaches Spiel benötigt Startzustand, Spielregeln, Wiederholungen und Bedingungen für Gewinn oder Verlust. Wer diese Elemente vorher ordnet, programmiert gezielter und verliert sich weniger in Einzelfehlern. Auch das Zerlegen in Teilprobleme ist wichtig. Statt sofort ein ganzes Projekt zu bauen, wird zunächst ein kleiner Teil geplant: etwa erst die Eingabe, dann die Prüfung, dann die Ausgabe. Diese Vorgehensweise macht komplexe Aufgaben überschaubar und unterstützt später die iterative Entwicklung. Planungselemente: Ziel, Eingabe, Ausgabe, Schrittfolge, Entscheidung, Wiederholung Hilfsmittel: Skizze, Struktogramm, Ablaufplan, Pseudocode, Notizen, Testfälle
Fragen: Was soll passieren, Wann prüfen, Was wiederholen, Welche Daten, Welche Fehler, Welche Ausgabe Gerade bei verschachtelten Schleifen und zusammengesetzten Bedingungen hilft Planung stark, weil solche Programme schnell unübersichtlich werden. Ein klarer Entwurf schafft Orientierung und verbessert die Qualität des Codes.
Iterative Entwicklung und schrittweises Erweitern
Iterative Entwicklung bedeutet, ein Programm zuerst in einer einfachen Grundversion lauffähig zu machen und es anschließend in mehreren kleinen Schritten zu erweitern, zu testen und zu verbessern, statt alles gleichzeitig lösen zu wollen. Diese Arbeitsweise ist besonders wichtig, wenn Kontrollstrukturen kombiniert werden. Ein Programm kann zum Beispiel zuerst nur eine Eingabe lesen. In der nächsten Version prüft es die Eingabe. Danach wird eine Schleife ergänzt, später eine weitere Bedingung, schließlich ein Ausstieg oder eine Rückmeldung. Jede Version funktioniert bereits besser als die vorige und kann separat getestet werden. Ein Zahlenratespiel könnte in Version 1 nur eine Zahl vergleichen. In Version 2 kommen wiederholte Versuche hinzu. In Version 3 wird geprüft, ob die Eingabe gültig ist. In Version 4 wird gezählt, wie viele Versuche gebraucht wurden. Genauso kann ein Zeichenprogramm Schritt für Schritt von einer einfachen Linie zu einem Raster mit verschachtelten Schleifen wachsen. Iteratives Arbeiten fördert Genauigkeit und Frustrationstoleranz. Fehler werden früher sichtbar, und die Lernenden erleben, dass gute Programme nicht sofort perfekt sein müssen, sondern durch Überarbeitung besser werden. Arbeitsphasen: Grundversion, testen, erweitern, prüfen, verbessern, vereinfachen Versionen: V1, V2, V3, Zusatzfunktion, Korrektur, Endfassung Projektideen: Ratespiel, Punktesystem, Musterzeichner, Menüprogramm, Quiz, Spielfeld Diese Form der Entwicklung passt gut zum schulischen Lernen, weil Erfolge schneller sichtbar werden und komplexe Anforderungen nicht auf einmal bewältigt werden müssen. Kleine stabile Zwischenschritte schaffen Sicherheit und Motivation.
Testen und Debuggen bei komplexeren Abläufen
Sobald Programme mehrere Schleifen und Bedingungen enthalten, steigen Fehlerrisiko und Unübersichtlichkeit, weshalb systematisches Testen und gezieltes Debuggen nötig werden, um Ablauf, Logik und Ergebnisse zuverlässig kontrollieren zu können. Debugging bedeutet, Fehler zu finden, ihre Ursache zu verstehen und sie gezielt zu beheben. Bei kombinierter Ablaufsteuerung treten häufig typische Fehler auf: eine Schleife läuft zu oft oder gar nicht, eine Bedingung ist logisch falsch, eine Einrückung stimmt nicht, eine Variable wird an der falschen Stelle verändert oder eine innere Schleife beginnt mit einem ungeeigneten Startwert. Hilfreich sind dabei Testfälle mit erwarteten Ergebnissen. Wenn ein Programm nur bei
manchen Eingaben funktioniert, lohnt es sich, verschiedene Fälle gezielt durchzuspielen: normale Werte, Grenzwerte, leere Eingaben oder unerwartete Kombinationen. Auch Zwischenausgaben helfen, etwa wenn angezeigt wird, welchen Wert eine Variable gerade hat oder welcher Zweig einer Bedingung aktiv war. Ein Beispiel ist ein Notenprogramm, das nur dann „bestanden“ ausgeben soll, wenn mindestens 50 Punkte erreicht wurden und keine Teilaufgabe mit null Punkten bewertet wurde. Hier müssen gezielt verschiedene Kombinationen geprüft werden, um logische Fehler sichtbar zu machen. Fehlerarten: Syntaxfehler, Logikfehler, Endlosschleife, Grenzfehler, Einrückung, Variablenfehler Strategien: testen, beobachten, Zwischenausgabe, Schrittfolge, Vergleich, Korrektur Testfälle: leer, normal, Grenzwert, falsch, mehrfach, Sonderfall Schülerinnen und Schüler sollen lernen, dass Fehler kein Zeichen von Scheitern sind, sondern Teil des Entwicklungsprozesses. Gerade das schrittweise Finden und Verstehen von Fehlern stärkt algorithmisches Denken und Sorgfalt.
Lesbarkeit, Struktur und Wartbarkeit
Je komplexer ein Programm wird, desto wichtiger werden klare Namen, saubere Einrückungen und verständliche Teilstrukturen, damit der Ablauf nachvollziehbar bleibt und spätere Änderungen ohne unnötige Verwirrung möglich werden. Ein Programm kann technisch funktionieren und dennoch schwer lesbar sein. Gerade bei verschachtelten Schleifen und zusammengesetzten Konditionalen droht schnell Unübersichtlichkeit. Deshalb sollen Lernende von Anfang an auf Struktur achten: sinnvolle Variablennamen, logische Abschnitte, Einrückungen, Kommentare und möglichst einfache Bedingungen statt unnötig komplizierter Konstruktionen. Ein Zählprogramm mit den Variablen zeile, spalte oder punktzahl ist verständlicher als eines mit a, b und c. Eine Bedingung, die in zwei klaren Teilschritten formuliert wird, ist häufig besser lesbar als eine einzige sehr lange Zeile. Auch das Auslagern wiederkehrender Schritte in eigene Blöcke oder Funktionen kann Programme übersichtlicher machen. Diese Qualitätsmerkmale sind nicht bloß Schönheitsfragen. Sie erleichtern das Testen, das gemeinsame Arbeiten und die spätere Weiterentwicklung. Wer lesbaren Code schreibt, versteht das eigene Programm auch nach einer Pause leichter wieder. Qualitätsmerkmale: Klarheit, Einrückung, Namen, Ordnung, Kommentar, Lesbarkeit Hilfen: Abschnitte, Teilprobleme, Funktionen, Zwischenschritte, Formatierung, Rückmeldung Typische Fragen: Kann ich es erklären, Finde ich Fehler, Verstehe ich morgen, Ist es zu lang, Ist es eindeutig, Kann es einfacher sein Gerade in der Schule ist gut lesbarer Code ein wichtiger Lerngegenstand, weil er Denken sichtbar macht. Nicht nur das Ergebnis zählt, sondern auch, wie verständlich und nachvollziehbar der Lösungsweg gestaltet ist.
Typische Projekte mit kombinierten Kontrollstrukturen
Anwendungsorientierte Mini-Projekte zeigen besonders deutlich, wie Schleifen, verschachtelte
Wiederholungen und zusammengesetzte Bedingungen zusammenwirken, weil reale oder spielerische Aufgaben mehrere Formen der Ablaufsteuerung gleichzeitig erfordern. Ein Quizprogramm braucht meist eine Schleife über mehrere Fragen, Bedingungen für richtige und falsche Antworten und oft zusätzliche Prüfungen für Punktestand oder Wiederholung. Ein Musterzeichner nutzt verschachtelte Schleifen, um Zeilen und Spalten eines Bildes oder Rasters zu erzeugen. Ein Menüprogramm verbindet Benutzereingaben mit Bedingungen und Schleifen, bis eine gültige Auswahl getroffen wurde. Auch einfache Spiele sind gut geeignet. Eine Spielfigur bewegt sich nur, wenn bestimmte Tasten gedrückt werden und keine Kollision vorliegt. Ein Sammelspiel zählt Punkte in einer Schleife und reagiert mit Bedingungen auf Treffer, Zeit oder Hindernisse. Ein Stundenplan- oder Sitzplanprogramm kann mit verschachtelten Schleifen Felder erzeugen und mit Bedingungen einzelne Einträge markieren. Solche Projekte helfen, abstrakte Kontrollstrukturen mit sichtbaren Ergebnissen zu verbinden. Dadurch wird erkennbar, dass Programmieren nicht aus isolierten Befehlen besteht, sondern aus sinnvoll koordinierten Abläufen. Projektideen: Quiz, Ratespiel, Rasterbild, Tabellenrechner, Menüsystem, Sammelspiel Kombinationen: Schleife und Bedingung, Schleife in Schleife, Prüfung mit Operatoren, Eingabe und Kontrolle, Zählen und Ausgeben, Testen und Verbessern Produkte: Konsolenprogramm, Scratch-Projekt, Turtle-Bild, Mini-Spiel, Abfrage, Simulation Die Auswahl solcher Projekte sollte zum Lernstand passen: klein genug, um überschaubar zu bleiben, aber anspruchsvoll genug, damit die Kombination der Kontrollstrukturen wirklich gebraucht wird.
11.4 Aufgaben für den Unterricht
11.4.1 Schleifenmuster schrittweise entwickeln
Das schrittweise Erzeugen von Mustern mit Wiederholungen schafft ein stabiles Grundverständnis, weil Lernende sichtbar erleben, wie aus einfachen Schleifen über mehrere Entwicklungsstufen komplexere Ausgaben mit verschachtelten Wiederholungen entstehen. Die Schülerinnen und Schüler beginnen mit einem sehr einfachen Programm, das eine Zeile aus Symbolen ausgibt. Danach erweitern sie das Programm in mehreren Versionen: zuerst mehrere gleiche Zeilen, dann ein Rechteck, anschließend ein Treppenmuster oder ein Schachbrettmuster. In jeder Phase notieren sie kurz, welche neue Schleife oder Bedingung hinzugefügt wurde und welche Wirkung diese Änderung auf die Ausgabe hat. So wird iterative Entwicklung direkt am sichtbaren Ergebnis erfahrbar und verschachtelte Schleifen werden nicht abstrakt, sondern handelnd verstanden. Sozialform: Einzelarbeit, Partnerhilfe Material: Rechner, Entwicklungsblatt Schritte: starten, erweitern, testen, notieren, vergleichen Fokus: Schleifen, Muster, Iteration Ergebnis: Versionsreihe, Musterprogramm
11.4.2 Raster prüfen mit verschachtelten Schleifen
Die Bearbeitung eines Gitters oder Spielfelds fördert systemisches Denken besonders deutlich, weil äußere und innere Schleifen unterschiedliche Ebenen eines Problems steuern und damit mehrdimensionale Strukturen verständlich und programmierbar werden. Die Lehrkraft gibt ein einfaches Rasterproblem vor, etwa ein Spielfeld mit Zahlen, Symbolen oder Farben. Die Schülerinnen und Schüler programmieren ein Verfahren, das zeilenweise und innerhalb jeder Zeile spaltenweise arbeitet. Aufgaben können sein, alle Felder auszugeben, bestimmte Werte zu zählen oder markierte Felder besonders darzustellen. In einer zweiten Runde erweitern sie ihr Programm um eine Bedingung, etwa „markiere nur gerade Zahlen“ oder „zähle nur freie Felder“. Die Auswertung konzentriert sich darauf, welche Schleife für Zeilen und welche für Spalten zuständig ist. Sozialform: Partnerarbeit Material: Rastervorlage, Rechner Schritte: analysieren, planen, codieren, erweitern, erklären Fokus: Raster, Schleifen, Struktur Ergebnis: Rasterprogramm, Erklärskizze
11.4.3 Bedingungen logisch verknüpfen
Die gezielte Formulierung zusammengesetzter Bedingungen stärkt algorithmische Präzision, weil Entscheidungen nicht bloß intuitiv getroffen, sondern bewusst mit UND-, ODER- und NICHT-Verknüpfungen geplant, getestet und sprachlich erklärt werden müssen. Die Schülerinnen und Schüler erhalten mehrere Alltagssituationen, die logisch in Code übersetzt werden sollen, etwa Zugang nur bei richtigem Passwort und ausreichendem Alter,
Rabatt bei Mitgliedschaft oder hoher Punktzahl, Warnung bei Regen oder Kälte. Zunächst formulieren sie die Entscheidung in Alltagssprache, danach als Entscheidungstabelle und schließlich als Programmcode. In einer Vertiefung testen sie Grenzfälle und falsche Kombinationen, um zu erkennen, wann ihre Bedingung korrekt oder zu ungenau formuliert ist. So entsteht ein enger Zusammenhang zwischen Sprache, Logik und Programmablauf. Sozialform: Einzelarbeit, Plenum Material: Situationskarten, Testblatt Schritte: formulieren, tabellieren, codieren, testen, verbessern Fokus: Logik, Operatoren, Präzision Ergebnis: Bedingungscode, Testübersicht
11.4.4 Fehlerjagd im Kontrollfluss
Das systematische Finden und Beheben typischer Fehler erhöht den Lernertrag besonders stark, weil Schülerinnen und Schüler fehlerhafte Kontrollstrukturen analysieren und dabei tiefer verstehen, wie Schleifen, Bedingungen und Einrückungen tatsächlich zusammenwirken. Die Lehrkraft stellt bewusst fehlerhafte Programme bereit, etwa mit Endlosschleifen, falsch verschachtelten if-Strukturen, logischen Fehlern oder unpassenden Startwerten in Schleifen. Die Schülerinnen und Schüler markieren zunächst die vermutete Fehlerstelle, beschreiben das beobachtete Problem und entwickeln erst danach eine Korrektur. Anschließend testen sie die verbesserte Version mit mehreren Eingaben. Die Reflexion richtet den Blick darauf, dass Debugging kein bloßes Raten ist, sondern ein strukturierter Denkprozess mit Beobachtung, Hypothese und Überprüfung. Sozialform: Partnerarbeit, Sicherung Material: Fehlercode, Diagnosebogen Schritte: beobachten, vermuten, korrigieren, testen, begründen Fokus: Debugging, Logik, Analyse Ergebnis: Fehlerprotokoll, Korrekturfassung
11.4.5 Menüprogramm iterativ erweitern
Ein Menüprogramm eignet sich besonders gut für iterative Entwicklung, weil es in kleinen, klar überprüfbaren Schritten wachsen kann und dabei Eingaben, Schleifen, zusammengesetzte Bedingungen und wiederholte Auswahlprozesse sinnvoll verbindet. Die Schülerinnen und Schüler erstellen ein kleines Textmenü, etwa für einen Taschenrechner, ein Quiz, ein Lernprogramm oder ein Spiel. In Version 1 wird nur eine Auswahl angezeigt. In Version 2 reagiert das Programm auf mehrere Eingaben. In Version 3 wird die Menüanzeige in einer Schleife wiederholt, bis „Beenden“ gewählt wird. In weiteren Versionen kommen ungültige Eingaben, zusätzliche Bedingungen oder Punktestände hinzu. Durch diese gestufte Entwicklung erleben die Lernenden, wie Programme kontrolliert wachsen und nach jeder Erweiterung erneut getestet werden müssen. Sozialform: Einzelarbeit, Austausch Material: Rechner, Versionsplan
Schritte: planen, bauen, erweitern, prüfen, dokumentieren Fokus: Menü, Eingabe, Iteration Ergebnis: Menüprogramm, Versionslogbuch
11.4.6 Quiz mit Punktelogik entwickeln
Ein Quizprojekt verbindet fachliche Motivation mit algorithmischer Komplexität, weil mehrere Fragen, wiederholte Abläufe, zusammengesetzte Prüfungen und Rückmeldungen schrittweise zu einem funktionierenden Gesamtprogramm zusammengeführt werden müssen. Die Klasse entwickelt ein Quiz mit mehreren Fragen. Zuerst programmieren die Schülerinnen und Schüler nur eine einzelne Frage mit Rückmeldung. Danach erweitern sie das Programm zu einer Frageschleife, zählen richtige Antworten und ergänzen Bedingungen für Sonderfälle, etwa Groß- und Kleinschreibung, mehrere gültige Lösungen oder Abbruchmöglichkeiten. In einer weiteren Runde gestalten sie Abschlussmeldungen abhängig von der erreichten Punktzahl. Diese Aufgabe fördert das bewusste Kombinieren von Schleifen und Bedingungen in einem sinnvollen Gesamtprodukt. Sozialform: Partnerarbeit Material: Rechner, Fragenblatt Schritte: entwerfen, codieren, testen, erweitern, auswerten Fokus: Quiz, Punktestand, Kontrollfluss Ergebnis: Quizprogramm, Testfassung
11.4.7 Turtle- oder Scratch-Muster mit Schleifen bauen
Grafische Ausgaben machen Programmabläufe besonders anschaulich, weil jede Schleife, jede Verschachtelung und jede zusätzliche Bedingung sofort im Bild sichtbar wird und dadurch Fehler wie auch Verbesserungen leicht erkannt und besprochen werden können. Die Schülerinnen und Schüler erstellen mit Turtle, Scratch oder einer ähnlichen Umgebung ein grafisches Muster. Zunächst zeichnen sie eine einfache Form mit einer Schleife, etwa ein Quadrat oder eine Reihe von Punkten. Danach verschachteln sie Schleifen, um Raster, Spiralen oder Ornamentmuster zu erzeugen. In einer Erweiterung ergänzen sie Bedingungen, zum Beispiel Farbwechsel bei jeder zweiten Wiederholung oder Richtungsänderung nach bestimmten Schritten. Die Lernenden dokumentieren, welche Änderung jeweils welchen sichtbaren Effekt erzeugt hat. Sozialform: Einzelarbeit, Galeriegang Material: Scratch, Turtle, Rechner Schritte: zeichnen, wiederholen, verschachteln, variieren, präsentieren Fokus: Grafik, Schleifen, Sichtbarkeit Ergebnis: Musterbild, Entwicklungsnotiz
11.4.8 Planung mit Pseudocode und Ablaufdiagramm
Die vorgelagerte Modellierung komplexerer Programme verbessert die Qualität des späteren
Codes, weil Entscheidungen, Wiederholungen und Verschachtelungen zuerst sprachlich und grafisch geklärt werden, bevor syntaktische Details der Programmiersprache hinzukommen. Vor dem eigentlichen Codieren erhalten die Schülerinnen und Schüler einen Programmierauftrag, etwa ein Eingabeprüfprogramm, ein Punktesystem oder eine kleine Spiellogik. Sie erstellen zunächst Pseudocode oder ein Ablaufdiagramm mit allen wichtigen Schritten, Bedingungen und Schleifen. Erst danach setzen sie den Entwurf in Code um. In der Auswertung vergleichen sie, an welchen Stellen der vorgeplante Ablauf geholfen hat und wo dennoch Anpassungen nötig waren. So wird Programmieren als Planungs- und Entwicklungsprozess sichtbar. Sozialform: Einzelarbeit, Partnerfeedback Material: Ablaufvorlage, Rechner Schritte: planen, skizzieren, übertragen, prüfen, reflektieren Fokus: Entwurf, Struktur, Vorplanung Ergebnis: Pseudocode, Programmfassung
11.4.9 Testfälle für Grenzwerte entwickeln
Die bewusste Entwicklung von Testfällen stärkt Genauigkeit und Fehlerbewusstsein, weil Programme nicht nur mit naheliegenden Eingaben ausprobiert, sondern auch an Randfällen, falschen Kombinationen und problematischen Spezialfällen überprüft werden. Die Lehrkraft gibt ein Programm oder eine Aufgabenstellung vor, etwa eine Altersprüfung, ein Notensystem oder eine Zugangskontrolle. Die Schülerinnen und Schüler überlegen zunächst nicht den Code, sondern geeignete Testfälle: normale Werte, Grenzwerte, leere Eingaben, falsche Datentypen oder logisch schwierige Kombinationen. Danach testen sie ihr eigenes oder ein vorgegebenes Programm mit diesen Fällen und protokollieren, ob das Verhalten korrekt ist. So wird verständlich, dass gute Programme nicht nur funktionieren sollen, sondern zuverlässig und robust sein müssen. Sozialform: Partnerarbeit, Plenum Material: Testbogen, Beispielprogramme Schritte: sammeln, auswählen, prüfen, protokollieren, verbessern Fokus: Testen, Grenzwerte, Zuverlässigkeit Ergebnis: Testfallliste, Fehlerbericht
11.4.10 Programm überarbeiten nach Peer-Feedback
Rückmeldung durch andere erhöht die Qualität von Code deutlich, weil Lesbarkeit, Struktur und Logik aus einer zweiten Perspektive betrachtet werden und Verbesserungen nicht nur technisch, sondern auch hinsichtlich Verständlichkeit und Wartbarkeit erfolgen. Die Schülerinnen und Schüler tauschen ein selbst erstelltes Programm mit einer Partnerin oder einem Partner. Mithilfe eines klaren Prüfrasters bewerten sie, ob Schleifen sinnvoll verschachtelt, Bedingungen korrekt zusammengesetzt, Variablennamen verständlich und Einrückungen sauber gesetzt sind. Anschließend erhalten die Autorinnen und Autoren Rückmeldungen zu inhaltlichen Fehlern, unklaren Stellen und möglichen Vereinfachungen. In
einer Überarbeitungsphase verbessern sie ihren Code und dokumentieren, welche Änderungen aufgrund des Peer-Feedbacks vorgenommen wurden. Sozialform: Partnerarbeit Material: Code, Prüfraster, Kommentarbogen Schritte: tauschen, prüfen, kommentieren, überarbeiten, dokumentieren Fokus: Feedback, Lesbarkeit, Verbesserung Ergebnis: Endfassung, Änderungsnotiz
11.4.11 Mini-Spiel mit Kontrollstrukturen bauen
Ein kleines Spiel motiviert zur Kombination mehrerer Kontrollstrukturen, weil Eingaben, Bedingungen, Schleifen und Spielregeln in einem überschaubaren Projekt zusammenwirken und dadurch anspruchsvolle Abläufe mit sichtbarer Funktionalität verbunden werden. Die Schülerinnen und Schüler entwickeln ein einfaches Spiel, etwa Zahlenraten, Labyrinth, Reaktionsspiel oder Sammelspiel. Das Projekt soll mindestens eine Schleife zur Wiederholung des Spielablaufs, eine zusammengesetzte Bedingung für Regeln oder Trefferprüfung und eine Erweiterung in mindestens zwei Versionen enthalten. In einer abschließenden Präsentation erläutern die Lernenden, welche Kontrollstrukturen sie verwendet haben, wo Probleme aufgetreten sind und wie ihr Spiel im Verlauf der Entwicklung verbessert wurde. So wird Programmieren als kreativer und iterativer Prozess erfahrbar. Sozialform: Einzelarbeit, Präsentation Material: Rechner, Projektblatt Schritte: wählen, bauen, erweitern, testen, vorstellen Fokus: Spiel, Kombination, Entwicklung Ergebnis: Mini-Spiel, Projektreflexion
11.4.12 Lösungswege vergleichen und vereinfachen
Der Vergleich verschiedener Programmierlösungen fördert tieferes Verständnis, weil Schülerinnen und Schüler erkennen, dass ähnliche Aufgaben mit unterschiedlich klaren, effizienten oder gut lesbaren Kontrollstrukturen gelöst werden können und Verbesserung ein zentrales Ziel des Programmierens ist. Die Lehrkraft sammelt mehrere unterschiedliche Lösungen zu derselben Aufgabe, etwa zu einem Rasterproblem, einem Quiz oder einer Eingabeprüfung. Die Schülerinnen und Schüler analysieren, welche Lösung leichter verständlich ist, welche unnötig kompliziert wirkt und wo Kontrollstrukturen eleganter kombiniert wurden. Anschließend überarbeiten sie eine komplexere Lösung in eine klarere Fassung, ohne die Funktion zu verändern. Dadurch lernen sie, dass iterative Entwicklung nicht nur neue Funktionen meint, sondern auch Vereinfachung, bessere Lesbarkeit und durchdachtere Struktur. Sozialform: Gruppenarbeit, Diskussion Material: Beispielcodes, Vergleichsraster Schritte: lesen, vergleichen, bewerten, vereinfachen, begründen Fokus: Qualität, Struktur, Optimierung
Ergebnis: Codevergleich, verbesserte Lösung
Grundlage: Digitale Grundbildung IV – Lehrband 4. Klasse, Final V2.0.