|
|
| (2 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt) |
| Zeile 1: |
Zeile 1: |
| ← [[DGB 2. Klasse|Digitale Grundbildung 2. Klasse]] | | ← [[DGB 2. Klasse|Digitale Grundbildung 2. Klasse]] |
|
| |
|
| Die Arbeit mit einer altersgerechten Entwicklungsumgebung unterstützt die Schülerinnen und Schüler dabei, einfache Programme planvoll zu erstellen, Eingaben und Ausgaben sinnvoll zu gestalten sowie Fehler systematisch zu finden, zu verstehen und zu verbessern.
| | Programmieren bedeutet, eine Lösung so genau zu beschreiben, dass ein Computersystem sie ausführen kann. In der 2. Klasse stehen kleine, verständliche Programme im Mittelpunkt: Abläufe planen, Befehle kombinieren, '''Variablen, Eingaben, Ausgaben und Bedingungen''' verwenden, systematisch testen und Fehler gezielt beheben. |
|
| |
|
| == 12.1 Lernziele == | | == Lehrplanbezug == |
| | |
| | {| class="wikitable" |
| | ! Bereich |
| | ! Zuordnung |
| | |- |
| | | '''Kompetenzbereich''' |
| | | Produktion |
| | |- |
| | | '''Perspektiven''' |
| | | T, I |
| | |- |
| | | '''Schwerpunkt''' |
| | | Einfache Programme erstellen, testen und debuggen |
| | |- |
| | | '''Kompetenz''' |
| | | Einfache Programme in einer geeigneten Lernumgebung entwickeln, Testfälle planen, Fehler lokalisieren und Programme schrittweise verbessern. |
| | |} |
| | |
| | == Lernziele == |
|
| |
|
| Die Schülerinnen und Schüler können: | | Die Schülerinnen und Schüler können: |
|
| |
|
| * erklären, was eine Entwicklungsumgebung ist und wozu sie beim Programmieren dient. | | * eine Entwicklungs- oder Lernumgebung grundlegend bedienen; |
| * einfache Programme in einer geeigneten Umgebung erstellen und ausführen. | | * Programm und Quelltext bzw. Blockfolge unterscheiden; |
| * Befehle, Reihenfolgen und einfache Abläufe in Programmen gezielt einsetzen. | | * einfache Befehlsfolgen erstellen und ausführen; |
| * Eingaben, Ausgaben und einfache Variablen in überschaubaren Programmen nutzen. | | * Eingaben entgegennehmen und Ausgaben erzeugen; |
| * erkennen, dass Programme nur bei korrekten und eindeutig formulierten Anweisungen wie gewünscht funktionieren. | | * Variablen zum Speichern veränderlicher Werte verwenden; |
| * Programme schrittweise testen und das Ergebnis mit der geplanten Wirkung vergleichen. | | * einfache Bedingungen für Entscheidungen einsetzen; |
| * einfache Fehler in Programmen erkennen, beschreiben und beheben. | | * Wiederholungen in einfachen Aufgaben erkennen und gegebenenfalls verwenden; |
| * zwischen Fehlern in der Idee, in der Reihenfolge und in der Umsetzung unterscheiden.
| | * Syntaxfehler, Laufzeitprobleme und logische Fehler in einfachen Beispielen unterscheiden; |
| * Hilfen der Entwicklungsumgebung wie Fehlermeldungen, Markierungen oder Testläufe nutzen.
| | * Programme schrittweise statt nur am Ende testen; |
| * Programme nach einer Korrektur erneut testen und Verbesserungen nachvollziehbar erklären.
| | * eigene Testfälle mit Normal-, Rand- und Fehlersituationen entwickeln; |
| | * Debugging als systematische Fehlersuche erklären; |
| | * Änderungen kontrolliert durchführen und nach jeder Änderung erneut testen; |
| | * ein kleines Programm planen, umsetzen, dokumentieren und verbessern. |
| | |
| | == Lerninhalte == |
| | |
| | === Entwicklungsumgebung und Programm === |
| | |
| | Eine Programmierumgebung stellt Werkzeuge zum Schreiben bzw. Zusammensetzen, Starten und Testen von Programmen bereit. In blockbasierten Systemen werden Befehle als Blöcke kombiniert; in textbasierten Sprachen werden Anweisungen geschrieben. |
| | |
| | Die konkrete Umgebung ist austauschbar. Entscheidend sind algorithmisches Denken, Daten und Testen. |
| | |
| | === Sequenzen und klare Abläufe === |
| | |
| | Eine '''Sequenz''' ist eine geordnete Folge von Anweisungen. Bereits ein kleines Programm kann Eingabe lesen, einen Wert verarbeiten und eine Ausgabe anzeigen. |
| | |
| | Die Reihenfolge muss logisch stimmen. Wie bei einem Algorithmus führen ausgelassene oder vertauschte Schritte zu falschen Ergebnissen. |
|
| |
|
| == 12.2 Lerninhalte == | | === Variablen === |
|
| |
|
| Die Auseinandersetzung mit Entwicklungsumgebungen, Programmaufbau, Testen und
| | Variablen speichern Werte, die im Programm verwendet oder verändert werden. Beispiele sind Punktestand, Name, Temperatur oder Anzahl von Versuchen. |
|
| |
|
| '''Debugging''' fördert ein grundlegendes Verständnis dafür, dass Programme nicht auf Anhieb
| | Aussagekräftige Namen wie `punkte` oder `anzahlVersuche` erleichtern das Lesen und spätere Debuggen. |
|
| |
|
| 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.
| | === Bedingungen und Wiederholungen === |
|
| |
|
| 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
| | Mit Bedingungen kann ein Programm abhängig von einem Wert unterschiedlich reagieren: Wenn die Antwort richtig ist, erhöhe die Punkte; sonst zeige einen Hinweis. Wiederholungen führen Anweisungen mehrfach aus. |
|
| |
|
| 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.
| | Die 2. Klasse benötigt noch keine komplexen Algorithmen. Wichtig ist, die Logik in kleinen Schritten nachvollziehen zu können. |
|
| |
|
| 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.
| | === Testen === |
|
| |
|
| 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.
| | Ein Programm sollte früh und häufig getestet werden. Nach einem kleinen Arbeitsschritt wird geprüft, ob das Ergebnis dem erwarteten Verhalten entspricht. So lässt sich ein Fehler leichter dem zuletzt geänderten Bereich zuordnen. |
|
| |
|
| 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.
| | Gute Tests verwenden verschiedene Eingaben und prüfen nicht nur einen einzigen Erfolgsfall. |
|
| |
|
| 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.
| | === Debugging === |
|
| |
|
| '''Debugging''' bedeutet, Fehler in Programmen zu finden und zu beheben. Fehler können | | '''Debugging''' bedeutet, Fehler systematisch zu finden und zu beheben. Hilfreich ist: Fehler reproduzieren, betroffenen Bereich eingrenzen, Zwischenwerte beobachten, eine Vermutung bilden, nur eine gezielte Änderung vornehmen und erneut testen. |
|
| |
|
| 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.
| | Wahlloses Verändern vieler Stellen gleichzeitig erschwert die Fehlersuche. |
|
| |
|
| Schülerinnen und Schüler sollen erkennen, dass Fehler normal sind und Hinweise für
| | === Fehlerarten === |
|
| |
|
| '''Verbesserungen''' liefern. '''Testschritte''' starten, beobachten, vergleichen, notieren, verändern, erneut prüfen '''Fehlerarten''' Reihenfolgefehler, Denkfehler, Schreibfehler, Logikfehler, Eingabefehler,
| | Ein Syntaxfehler verletzt Regeln der Programmiersprache. Ein Laufzeitproblem tritt beim Ausführen auf. Ein logischer Fehler lässt das Programm zwar laufen, aber ein falsches Ergebnis erzeugen. |
|
| |
|
| 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.
| | In blockbasierten Umgebungen treten klassische Syntaxfehler seltener auf, logische Fehler bleiben dennoch wichtig. |
|
| |
|
| 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.
| | === Dokumentieren und verbessern === |
|
| |
|
| 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.
| | Ein kleines Projekt sollte Ziel, wichtige Variablen, Testfälle und bekannte Grenzen dokumentieren. Nach der ersten funktionierenden Version können Bedienung, Fehlermeldungen und Lesbarkeit verbessert werden. |
|
| |
|
| 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.
| | Programmieren ist damit ein iterativer Prozess: planen, erstellen, testen, verbessern. |
|
| |
|
| 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.
| | == Aufgaben für den Unterricht == |
|
| |
|
| 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.
| | === Entwicklungsumgebung erkunden und Grundfunktionen nutzen === |
|
| |
|
| 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.
| | Die Lernumgebung wird systematisch statt zufällig erkundet. |
|
| |
|
| '''Verbesserungen''' vereinfachen, ordnen, umbenennen, kürzen, ergänzen, strukturieren | | '''Arbeitsauftrag:''' Finde Bereich für Code, Start/Stop, Ausgabe, Speichern und Hilfe. Erstelle eine beschriftete Übersicht. |
|
| |
|
| 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.
| | '''Erwartetes Ergebnis:''' Orientierung in der Programmierumgebung. |
|
| |
|
| === Weiterführende Links === | | === Erstes einfaches Programm erstellen === |
|
| |
|
| * scratch.mit.edu
| | Ein klar begrenztes Programm wird umgesetzt. |
| * open-roberta.org
| |
| * makecode.microbit.org
| |
| * code.org
| |
| * csunplugged.org
| |
| * saferinternet.at
| |
|
| |
|
| == 12.3 Aufgaben für den Unterricht ==
| | '''Arbeitsauftrag:''' Erstelle ein Programm, das nach einem Namen fragt und eine passende Begrüßung ausgibt. |
|
| |
|
| === 12.3.1 Entwicklungsumgebung erkunden und Grundfunktionen nutzen ===
| | '''Erwartetes Ergebnis:''' Funktionierende Ein- und Ausgabe. |
|
| |
|
| 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.
| | === Programme schrittweise testen === |
|
| |
|
| 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,
| | Ein Programm wird in kleinen Stufen aufgebaut. |
|
| |
|
| Selbstständigkeit Ergebnis Übersichtsblatt, Merkbild, Kurzdemonstration
| | '''Arbeitsauftrag:''' Teste nach jedem neuen Block bzw. Codeabschnitt und notiere erwartetes und tatsächliches Ergebnis. |
|
| |
|
| === 12.3.2 Erstes einfaches Programm erstellen ===
| | '''Erwartetes Ergebnis:''' Dokumentierter Testprozess. |
|
| |
|
| 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.
| | === Fehlerhafte Programme debuggen === |
|
| |
|
| 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
| | Vorbereitete Programme enthalten einfache Fehler. |
|
| |
|
| === 12.3.3 Programme schrittweise testen ===
| | '''Arbeitsauftrag:''' Finde und behebe mindestens drei Fehler. Beschreibe jeweils Symptom, Ursache und Korrektur. |
|
| |
|
| 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.
| | '''Erwartetes Ergebnis:''' Nachvollziehbare Fehlersuche. |
|
| |
|
| 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.
| | === Eingaben und Ausgaben programmieren === |
|
| |
|
| '''Testschritte''' starten, beobachten, vergleichen, notieren, prüfen, wiederholen
| | Nutzereingaben werden verarbeitet. |
|
| |
|
| Beobachtungspunkte Erwartung, Ergebnis, Abweichung, Ursache, Wirkung, Änderung Ergebnis Testprotokoll, Vergleich, Auswertung
| | '''Arbeitsauftrag:''' Erstelle einen Mini-Rechner, ein Quiz oder eine Umrechnung mit mindestens einer Eingabe und einer Ausgabe. |
|
| |
|
| === 12.3.4 Fehlerhafte Programme debuggen ===
| | '''Erwartetes Ergebnis:''' Anwendungsnahes Programm. |
|
| |
|
| 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,
| | === Variablen gezielt einsetzen und überprüfen === |
|
| |
|
| 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.
| | Zwischenwerte werden sichtbar gemacht. |
|
| |
|
| '''Fehlerarten''' Startfehler, Reihenfolgefehler, Logikfehler, Schreibfehler, Variablenfehler, | | '''Arbeitsauftrag:''' Verwende mindestens zwei Variablen und gib ihre Werte während des Testens gezielt aus. |
|
| |
|
| Bedingungsfehler Debuggingschritte beobachten, eingrenzen, ändern, testen, prüfen, erklären Sicherung Fehlerliste, Lösungsweg, Merkkarte
| | '''Erwartetes Ergebnis:''' Verständnis von Zustandsänderungen. |
|
| |
|
| === 12.3.5 Eingaben und Ausgaben programmieren === | | === Eigene Testfälle entwickeln === |
|
| |
|
| 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.
| | Nicht nur der Normalfall wird geprüft. |
|
| |
|
| 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
| | '''Arbeitsauftrag:''' Definiere vor dem Test mindestens fünf Fälle, darunter einen Rand- oder Fehleingabefall, und notiere das erwartete Ergebnis. |
|
| |
|
| === 12.3.6 Variablen gezielt einsetzen und überprüfen ===
| | '''Erwartetes Ergebnis:''' Systematische Testsammlung. |
|
| |
|
| 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.
| | === Programme gegenseitig prüfen === |
|
| |
|
| 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
| | Peer-Testing erweitert die Sicht auf Fehler. |
|
| |
|
| === 12.3.7 Eigene Testfälle entwickeln ===
| | '''Arbeitsauftrag:''' Tauscht Programme aus, führt die Testfälle der anderen Gruppe aus und gebt sachliches Feedback. |
|
| |
|
| 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.
| | '''Erwartetes Ergebnis:''' Testbericht mit reproduzierbaren Beobachtungen. |
|
| |
|
| 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
| | === Ein kleines Projekt planen, erstellen und verbessern === |
|
| |
|
| === 12.3.8 Programme gegenseitig prüfen ===
| | Ein vollständiger Entwicklungszyklus wird durchgeführt. |
|
| |
|
| 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.
| | '''Arbeitsauftrag:''' Plane ein Quiz, Spiel oder Hilfsprogramm, setze eine erste Version um, teste sie und dokumentiere zwei Verbesserungen. |
|
| |
|
| 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
| | '''Erwartetes Ergebnis:''' Kleines fertig getestetes Projekt. |
|
| |
|
| === 12.3.9 Ein kleines Projekt planen, erstellen und verbessern === | | === Reflexion und Ergebnissicherung === |
|
| |
|
| 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.
| | Der Entwicklungsprozess wird sprachlich gesichert. |
|
| |
|
| Im Abschlussgespräch reflektieren sie, welche Fehler auftraten, wie sie diese
| | '''Arbeitsauftrag:''' Erkläre mit einem eigenen Beispiel den Unterschied zwischen Programmieren, Testen und Debuggen. |
|
| |
|
| 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
| | '''Erwartetes Ergebnis:''' Sicheres Prozessverständnis. |
|
| |
|
| === 12.3.10 Reflexion und Ergebnissicherung === | | == Selbstcheck == |
|
| |
|
| 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.
| | * Ich kann eine einfache Programmierumgebung bedienen. |
| | * Ich kann Eingaben, Ausgaben und Variablen verwenden. |
| | * Ich kann einfache Bedingungen erklären. |
| | * Ich teste Programme schrittweise. |
| | * Ich kann Fehler reproduzieren und systematisch eingrenzen. |
| | * Ich kann ein kleines Programm planen, testen und verbessern. |
|
| |
|
| 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
| | == Siehe auch == |
|
| |
|
| Grundlage: Digitale Grundbildung II – Lehrband 2. Klasse, Final V2.5.
| | * [[DGB 2: Programme und Daten|Daten in Programmen]] |
| | * [[DGB 2: Geistiges Eigentum und Urheberrecht|Code und Remixe rechtlich fair nutzen]] |
| | * [[DGB 1: Algorithmen|Grundlagen der Algorithmen]] |
|
| |
|
| [[Kategorie:Digitale Grundbildung 2. Klasse]] | | [[Kategorie:Digitale Grundbildung]] |
| | [[Kategorie:DGB 2]] |
← Digitale Grundbildung 2. Klasse
Programmieren bedeutet, eine Lösung so genau zu beschreiben, dass ein Computersystem sie ausführen kann. In der 2. Klasse stehen kleine, verständliche Programme im Mittelpunkt: Abläufe planen, Befehle kombinieren, Variablen, Eingaben, Ausgaben und Bedingungen verwenden, systematisch testen und Fehler gezielt beheben.
| Bereich
|
Zuordnung
|
| Kompetenzbereich
|
Produktion
|
| Perspektiven
|
T, I
|
| Schwerpunkt
|
Einfache Programme erstellen, testen und debuggen
|
| Kompetenz
|
Einfache Programme in einer geeigneten Lernumgebung entwickeln, Testfälle planen, Fehler lokalisieren und Programme schrittweise verbessern.
|
Die Schülerinnen und Schüler können:
- eine Entwicklungs- oder Lernumgebung grundlegend bedienen;
- Programm und Quelltext bzw. Blockfolge unterscheiden;
- einfache Befehlsfolgen erstellen und ausführen;
- Eingaben entgegennehmen und Ausgaben erzeugen;
- Variablen zum Speichern veränderlicher Werte verwenden;
- einfache Bedingungen für Entscheidungen einsetzen;
- Wiederholungen in einfachen Aufgaben erkennen und gegebenenfalls verwenden;
- Syntaxfehler, Laufzeitprobleme und logische Fehler in einfachen Beispielen unterscheiden;
- Programme schrittweise statt nur am Ende testen;
- eigene Testfälle mit Normal-, Rand- und Fehlersituationen entwickeln;
- Debugging als systematische Fehlersuche erklären;
- Änderungen kontrolliert durchführen und nach jeder Änderung erneut testen;
- ein kleines Programm planen, umsetzen, dokumentieren und verbessern.
Eine Programmierumgebung stellt Werkzeuge zum Schreiben bzw. Zusammensetzen, Starten und Testen von Programmen bereit. In blockbasierten Systemen werden Befehle als Blöcke kombiniert; in textbasierten Sprachen werden Anweisungen geschrieben.
Die konkrete Umgebung ist austauschbar. Entscheidend sind algorithmisches Denken, Daten und Testen.
Eine Sequenz ist eine geordnete Folge von Anweisungen. Bereits ein kleines Programm kann Eingabe lesen, einen Wert verarbeiten und eine Ausgabe anzeigen.
Die Reihenfolge muss logisch stimmen. Wie bei einem Algorithmus führen ausgelassene oder vertauschte Schritte zu falschen Ergebnissen.
Variablen speichern Werte, die im Programm verwendet oder verändert werden. Beispiele sind Punktestand, Name, Temperatur oder Anzahl von Versuchen.
Aussagekräftige Namen wie `punkte` oder `anzahlVersuche` erleichtern das Lesen und spätere Debuggen.
Mit Bedingungen kann ein Programm abhängig von einem Wert unterschiedlich reagieren: Wenn die Antwort richtig ist, erhöhe die Punkte; sonst zeige einen Hinweis. Wiederholungen führen Anweisungen mehrfach aus.
Die 2. Klasse benötigt noch keine komplexen Algorithmen. Wichtig ist, die Logik in kleinen Schritten nachvollziehen zu können.
Ein Programm sollte früh und häufig getestet werden. Nach einem kleinen Arbeitsschritt wird geprüft, ob das Ergebnis dem erwarteten Verhalten entspricht. So lässt sich ein Fehler leichter dem zuletzt geänderten Bereich zuordnen.
Gute Tests verwenden verschiedene Eingaben und prüfen nicht nur einen einzigen Erfolgsfall.
Debugging bedeutet, Fehler systematisch zu finden und zu beheben. Hilfreich ist: Fehler reproduzieren, betroffenen Bereich eingrenzen, Zwischenwerte beobachten, eine Vermutung bilden, nur eine gezielte Änderung vornehmen und erneut testen.
Wahlloses Verändern vieler Stellen gleichzeitig erschwert die Fehlersuche.
Ein Syntaxfehler verletzt Regeln der Programmiersprache. Ein Laufzeitproblem tritt beim Ausführen auf. Ein logischer Fehler lässt das Programm zwar laufen, aber ein falsches Ergebnis erzeugen.
In blockbasierten Umgebungen treten klassische Syntaxfehler seltener auf, logische Fehler bleiben dennoch wichtig.
Ein kleines Projekt sollte Ziel, wichtige Variablen, Testfälle und bekannte Grenzen dokumentieren. Nach der ersten funktionierenden Version können Bedienung, Fehlermeldungen und Lesbarkeit verbessert werden.
Programmieren ist damit ein iterativer Prozess: planen, erstellen, testen, verbessern.
Entwicklungsumgebung erkunden und Grundfunktionen nutzen
[Bearbeiten]Die Lernumgebung wird systematisch statt zufällig erkundet.
Arbeitsauftrag: Finde Bereich für Code, Start/Stop, Ausgabe, Speichern und Hilfe. Erstelle eine beschriftete Übersicht.
Erwartetes Ergebnis: Orientierung in der Programmierumgebung.
Ein klar begrenztes Programm wird umgesetzt.
Arbeitsauftrag: Erstelle ein Programm, das nach einem Namen fragt und eine passende Begrüßung ausgibt.
Erwartetes Ergebnis: Funktionierende Ein- und Ausgabe.
Ein Programm wird in kleinen Stufen aufgebaut.
Arbeitsauftrag: Teste nach jedem neuen Block bzw. Codeabschnitt und notiere erwartetes und tatsächliches Ergebnis.
Erwartetes Ergebnis: Dokumentierter Testprozess.
Vorbereitete Programme enthalten einfache Fehler.
Arbeitsauftrag: Finde und behebe mindestens drei Fehler. Beschreibe jeweils Symptom, Ursache und Korrektur.
Erwartetes Ergebnis: Nachvollziehbare Fehlersuche.
Nutzereingaben werden verarbeitet.
Arbeitsauftrag: Erstelle einen Mini-Rechner, ein Quiz oder eine Umrechnung mit mindestens einer Eingabe und einer Ausgabe.
Erwartetes Ergebnis: Anwendungsnahes Programm.
Variablen gezielt einsetzen und überprüfen
[Bearbeiten]Zwischenwerte werden sichtbar gemacht.
Arbeitsauftrag: Verwende mindestens zwei Variablen und gib ihre Werte während des Testens gezielt aus.
Erwartetes Ergebnis: Verständnis von Zustandsänderungen.
Nicht nur der Normalfall wird geprüft.
Arbeitsauftrag: Definiere vor dem Test mindestens fünf Fälle, darunter einen Rand- oder Fehleingabefall, und notiere das erwartete Ergebnis.
Erwartetes Ergebnis: Systematische Testsammlung.
Peer-Testing erweitert die Sicht auf Fehler.
Arbeitsauftrag: Tauscht Programme aus, führt die Testfälle der anderen Gruppe aus und gebt sachliches Feedback.
Erwartetes Ergebnis: Testbericht mit reproduzierbaren Beobachtungen.
Ein kleines Projekt planen, erstellen und verbessern
[Bearbeiten]Ein vollständiger Entwicklungszyklus wird durchgeführt.
Arbeitsauftrag: Plane ein Quiz, Spiel oder Hilfsprogramm, setze eine erste Version um, teste sie und dokumentiere zwei Verbesserungen.
Erwartetes Ergebnis: Kleines fertig getestetes Projekt.
Der Entwicklungsprozess wird sprachlich gesichert.
Arbeitsauftrag: Erkläre mit einem eigenen Beispiel den Unterschied zwischen Programmieren, Testen und Debuggen.
Erwartetes Ergebnis: Sicheres Prozessverständnis.
- Ich kann eine einfache Programmierumgebung bedienen.
- Ich kann Eingaben, Ausgaben und Variablen verwenden.
- Ich kann einfache Bedingungen erklären.
- Ich teste Programme schrittweise.
- Ich kann Fehler reproduzieren und systematisch eingrenzen.
- Ich kann ein kleines Programm planen, testen und verbessern.
