Informatik 7: Aufgaben mit Mitteln der Informatik modellieren können. Vielfältige Algorithmen entwerfen, diese formal darstellen, implementieren und testen
8.1 Lernziele
- Probleme zerlegen
- Muster erkennen
- Wesentliches abstrahieren
- Modelle bilden
- Algorithmen entwerfen
- Schritte ordnen
- Bedingungen formulieren
- Schleifen nutzen
- Darstellungen wählen
- Pseudocode schreiben
- Programme implementieren
- Tests planen
- Fehler finden
- Lösungen verbessern
8.2 Lerninhalte
Tragfähige informatische Lösungen entstehen aus einem durchgehenden Arbeitsprozess von der Problemklärung über Modellierung, Entwurf und Darstellung bis zur Implementierung, Erprobung und Überarbeitung, sodass Algorithmen nicht isoliert, sondern als entwickelbare Problemlösungen verstanden werden.
Probleme informatisch modellieren
Der Übergang vom Alltagsproblem zur informatischen Lösung gelingt dann, wenn Situationen auf wesentliche Merkmale, Regeln, Zustände und Eingaben reduziert werden, damit aus einer unübersichtlichen Realität ein bearbeitbares Modell für Algorithmen und Programme entsteht. Modellieren bedeutet, ein Problem so zu vereinfachen, dass nur die für die Lösung wichtigen Aspekte erhalten bleiben. Bei einer Klassenparty sind nicht alle Details wichtig, sondern etwa Personenanzahl, Budget, Raum, Musik, Aufgaben und Zeitplan. Bei einem Sortierproblem zählen nicht Buchcover oder Lieblingsfarben, sondern Vergleichsmerkmale wie Größe, Titel
oder Kategorie. Diese Reduktion ist ein Kern informatischen Denkens, weil ein Computer nur mit klar beschriebenen Informationen und Regeln arbeiten kann. Ein informatisches Modell enthält meist Eingaben, Bedingungen, Zustände und gewünschte Ausgaben. Bei einer Ampelsteuerung wären Eingaben etwa Taster und Zeit, Zustände rot, gelb, grün und Ausgaben die geschalteten Lichter. Bei einem Spiel könnten Position, Punkte, Treffer und Zeit zentrale Modellbestandteile sein. Modellierung schafft damit die Brücke zwischen Alltagssituation und algorithmischer Bearbeitung. Beispiele: Klassenparty, Ampel, Spiel, Rezept, Bibliothek, Roboter, Sensor, Liste.
Computational Thinking als Grundlage
Zerlegung, Mustererkennung, Abstraktion und algorithmisches Denken helfen dabei, auch komplexere Aufgaben überschaubar zu machen, weil Probleme schrittweise bearbeitet, wiederkehrende Strukturen erkannt und nur die entscheidenden Informationen in die spätere Lösung übernommen werden. Zerlegung bedeutet, ein großes Problem in kleinere Teilaufgaben zu zerlegen. Eine Wetterstation lässt sich etwa in Messung, Speicherung, Anzeige und Auswertung aufteilen. Mustererkennung hilft, Gemeinsamkeiten zu entdecken, etwa bei wiederkehrenden Spielzügen, ähnlichen Rechenschritten oder häufigen Fehlersituationen. Abstraktion blendet Unnötiges aus und konzentriert sich auf das Wesentliche, etwa auf Zahlenwerte statt auf die Farbe des Sensors. Algorithmisches Denken ordnet schließlich die nötigen Schritte in eine eindeutige, ausführbare Reihenfolge. Diese vier Elemente lassen sich gut an alltäglichen Beispielen zeigen. Ein Kochrezept zerlegt das Kochen in Teilschritte, erkennt wiederkehrende Muster wie Mischen oder Backen, abstrahiert auf Mengen und Reihenfolge und formuliert daraus einen Algorithmus. Ähnlich funktionieren Musikkomposition, Städtebau oder Spielplanung, wie die hochgeladenen Materialien mit Analogien deutlich machen. Begriffe: Zerlegung, Muster, Abstraktion, Algorithmus, Eingabe, Ausgabe, Regel, Zustand.
Algorithmen entwerfen
Ein guter Algorithmus beschreibt eindeutig, vollständig und in sinnvoller Reihenfolge, wie ein Ziel erreicht wird, damit Menschen und Computer die Lösung nachvollziehen, ausführen, prüfen und bei Bedarf verbessern können. Ein Algorithmus ist eine eindeutige Handlungsanleitung zur Lösung eines Problems oder zur Erreichung eines Ziels. Die Materialien nennen dafür alltägliche Beispiele wie Kuchenrezepte und Spielregeln sowie technische Beispiele wie das Finden der größten Zahl in einer Liste. Gerade dieser Vergleich zeigt, dass Algorithmen nicht erst mit Programmcode beginnen, sondern schon in klar strukturierten Handlungsanweisungen vorkommen. Beim Entwurf müssen Schritte sinnvoll geordnet werden. Häufige Bausteine sind Anfang, Eingabe, Verarbeitung, Entscheidung, Wiederholung und Ausgabe. Ein Algorithmus zur Passwortprüfung könnte etwa Eingabe lesen, Länge prüfen, Sonderzeichen prüfen, Ergebnis ausgeben. Ein Sortieralgorithmus könnte vergleichen, vertauschen, wiederholen und beenden. Ein Algorithmus für ein Fangspiel könnte Tasteneingaben prüfen, Figur bewegen, Kollision erkennen und Punkte erhöhen. Erweiterung und Vertiefung bedeuten hier, dass nicht nur
einfache Schrittfolgen, sondern auch verschachtelte Schleifen und zusammengesetzte Bedingungen genutzt werden. Merkmale: Eindeutigkeit, Reihenfolge, Vollständigkeit, Endlichkeit, Korrektheit, Effizienz, Wiederholung, Entscheidung.
Algorithmen formal darstellen
Formale Darstellungen machen Lösungswege überprüfbar und übertragbar, weil sie Gedanken ordnen, Missverständnisse verringern und den Übergang von der Idee zur Implementierung erleichtern, ohne bereits vollständig an eine konkrete Programmiersprache gebunden zu sein. Algorithmen können visuell-symbolisch, textuell oder halbformal beschrieben werden. Das didaktische Skriptum betont ausdrücklich, dass der Ausgangspunkt zunächst unabhängig davon ist, ob Algorithmen visuell-symbolisch oder textuell dargestellt werden. Geeignete Formen sind nummerierte Schrittfolgen, strukturierte Handlungsanweisungen, Ablaufpläne, Blockfolgen und Pseudocode. Die offizielle micro:bit-MakeCode-Aktivität nennt Pseudocode ausdrücklich als Lerngegenstand neben Ereignisbehandlung und Code-Kommentaren. Eine formale Darstellung für „größte Zahl finden“ könnte lauten: erste Zahl merken, jede weitere Zahl vergleichen, bei größerem Wert ersetzen, nach dem letzten Vergleich Ergebnis ausgeben. Für ein Roboterprojekt könnte ein Ablaufplan enthalten: starte, prüfe Sensor, wenn Hindernis dann stoppe und drehe, sonst fahre weiter. Solche Darstellungen sind besonders wertvoll, weil sie Denkfehler oft sichtbar machen, bevor programmiert wird. Darstellungen: Schrittfolge, Ablaufplan, Pseudocode, Blockfolge, Tabelle, Skizze, Kommentar, Diagramm.
Implementieren in geeigneten Umgebungen
Die Umsetzung eines Algorithmus in Programmcode verlangt, dass abstrakte Schritte in konkrete Befehle, Kontrollstrukturen und Daten übersetzt werden, wobei die Wahl der Entwicklungsumgebung den Einstieg, die Fehlersuche und die Verständlichkeit stark beeinflusst. Für den Unterricht eignen sich je nach Ziel visuell-symbolische oder textbasierte Umgebungen. Die Quellen nennen Scratch, Thonny, MakeCode, Open Roberta sowie Python als geeignete Werkzeuge. Das didaktische Skriptum beschreibt außerdem einen hybriden Ansatz, bei dem Blockansicht und Textansicht parallel genutzt werden können, etwa mit MakeCode für micro:bit. Dadurch wird die Logik eines Programms sichtbar, ohne dass der Umstieg auf Syntax zu abrupt erfolgt. Implementieren bedeutet, Kontrollstrukturen, Variablen, Ereignisse und Ausgaben passend zu verwenden. Aus „wiederhole solange“ wird eine Schleife, aus „wenn Taste gedrückt“ eine Bedingung oder ein Ereignis, aus „zeige Ergebnis“ eine Bildschirmausgabe oder Textausgabe. Ein Algorithmus für ein Reaktionsspiel kann in Scratch blockbasiert entstehen, ein Zahlenvergleich in Python textbasiert, ein Sensorprojekt auf dem micro:bit ereignisgesteuert. Entscheidend bleibt, dass der Code die zuvor entworfene Logik nachvollziehbar umsetzt. Werkzeuge: Scratch, Thonny, MakeCode, Open Roberta, Python, Blockcode, Textcode, IDE.
Testen und Debuggen
Erst systematisches Testen zeigt, ob ein Algorithmus oder Programm tatsächlich korrekt arbeitet, weshalb erwartete Ergebnisse, Randfälle, Fehlersuche und schrittweise Verbesserung als fester Teil des Entwicklungsprozesses verstanden werden müssen. Testen bedeutet, Programme mit geplanten Eingaben auszuführen und die Ergebnisse mit den erwarteten Ausgaben zu vergleichen. Dabei sollten nicht nur typische Fälle, sondern auch Grenzfälle geprüft werden, etwa leere Listen, sehr große Werte, falsche Eingaben oder unerwartete Tastenkombinationen. Die hochgeladenen Materialien betonen, dass Schülerinnen und Schüler Programme erstellen, testen, Fehler finden und beheben sowie ihre Erfahrungen reflektieren sollen. Debuggen ist die systematische Fehlersuche. Die Quellen nennen Syntaxfehler wie eine fehlende Klammer, aber auch logisch falsche Ergebnisse bei Berechnungen. IDEs und Debugger unterstützen dabei durch Fehlermeldungen, schrittweise Ausführung und die Beobachtung von Variablenwerten. Besonders lehrreich ist es, wenn Schülerinnen und Schüler nicht nur den Fehler entfernen, sondern erklären können, warum er aufgetreten ist und wie ähnliche Fehler künftig vermieden werden. Schritte: Testfall, Eingabe, Erwartung, Ausgabe, Fehlerbild, Ursache, Korrektur, Wiederholung.
Iteratives Verbessern und Reflektieren
Vertiefte informatische Kompetenz zeigt sich darin, dass Lösungen überarbeitet, vereinfacht, erweitert und mit Rückmeldungen abgeglichen werden, sodass aus ersten Entwürfen schrittweise robustere, verständlichere und besser an neue Anforderungen anpassbare Programme entstehen. Programme entstehen selten im ersten Versuch fertig. Das didaktische Skriptum beschreibt Programmierunterricht als Spannungsfeld zwischen Projektideen und schrittweisem Aufbau komplexerer Algorithmen. Daraus folgt, dass Überarbeitung keine Schwäche ist, sondern normaler Teil des Entwicklungsprozesses. Eine erste Version eines Spiels kann nur Bewegung enthalten, später kommen Punkte, Bedingungen, zusätzliche Figuren und bessere Tests hinzu. Ein Sortierprogramm kann zunächst nur drei Werte vergleichen und später für längere Listen verallgemeinert werden. Reflexion hilft, Lösungswege bewusster zu machen. Wichtige Fragen sind: War mein Modell passend, war mein Algorithmus eindeutig, waren alle Fälle getestet, war mein Code gut lesbar, hätte sich das Problem einfacher darstellen lassen. Gerade diese Rückschau fördert Transfer, weil Lernende nicht nur eine einzelne Lösung besitzen, sondern Strategien für neue Probleme entwickeln. Aspekte: Version, Rückmeldung, Vereinfachung, Erweiterung, Lesbarkeit, Wiederverwendung, Reflexion, Transfer.
Vielfältige Anwendungsbeispiele
Die Tragfähigkeit algorithmischer Lösungen wird besonders anschaulich, wenn Modellierung, Darstellung, Implementierung und Testen an unterschiedlichen Kontexten erprobt werden, weil dadurch sichtbar wird, dass informatische Denkweisen weit über klassische Programmieraufgaben hinausreichen.
Geeignete Beispiele reichen von Alltagsproblemen bis zu technischen Projekten. Alltägliche Kontexte sind Rezepte, Spielregeln, Reiseplanung oder Aufgabenverteilung. Technische Kontexte sind Zahlenlisten, Sortieraufgaben, Passwortprüfung, Sensorsteuerung, Robotik und kleine Spiele. Die Materialien nennen außerdem Kunst, Musik, Wissenschaft und Mathematik als Felder, in denen Computational Thinking angewendet werden kann. Dadurch wird deutlich, dass Algorithmen nicht nur Programmiersprache bedeuten, sondern eine allgemeine Problemlösungsstrategie darstellen. Besonders motivierend sind Projekte mit sichtbarem Ergebnis. Ein Microcontroller kann auf Tastendruck ein Symbol anzeigen, ein Scratch-Projekt kann eine Figur durch ein Labyrinth steuern, ein Python-Programm kann Zahlen prüfen oder Texte umwandeln. Solche Beispiele verbinden Modellierung, Algorithmusentwurf, formale Darstellung, Implementierung und Testen in einem zusammenhängenden Lernprozess. Beispiele: Rezept, Sortieren, Passwort, Labyrinth, Roboter, Microbit, Liste, Spiel.
8.3 Weiterführende Links
- Scratch Learning Library, Scratch-Ideen, Coding Cards
- Python Tutorial, Kontrollfluss, Funktionen
- MakeCode micro:bit, Algorithmen, Pseudocode
- CS Unplugged, Offline-Aktivitäten, Algorithmen
- Open Roberta Lab, Simulation, Blockprogrammierung
8.4 Aufgaben für den Unterricht
8.4.1 Alltagsproblem in ein informatisches Modell überführen
Ein alltagsnahes Szenario wird besonders lernwirksam, wenn Lernende es auf wesentliche Eingaben, Regeln, Zustände und Ausgaben reduzieren und dadurch erfahren, dass Modellierung der entscheidende Schritt zwischen Lebenswelt und programmierbarer Lösung ist. Die Klasse erhält ein konkretes Problem, etwa Schulbuffet-Bestellung, Ampelsteuerung, Bibliotheksausleihe, Klassenraumreservierung oder Reaktionsspiel. Zuerst beschreiben die Gruppen das Problem in Alltagssprache. Danach markieren sie, welche Informationen für die Lösung wichtig sind und welche weggelassen werden können. Im nächsten Schritt formulieren sie Eingaben, Ausgaben, Bedingungen und mögliche Zustände. So entsteht ein erstes informatisches Modell, das noch kein Code ist, aber bereits die Grundlage für den späteren Algorithmus bildet.
Jede Gruppe erstellt zu einem Szenario ein Modellblatt mit Problemziel, Eingaben, Ausgaben, Regeln, Zuständen und Randbedingungen. Danach erklärt die Gruppe, welche Elemente bewusst vereinfacht oder weggelassen wurden. Szenario, Modellblatt Eingaben, Ausgaben Regeln, Zustände Wichtiges, Unwichtiges Vereinfachung, Begründung Präsentation, Vergleich
8.4.2 Zerlegung und Mustererkennung an komplexeren Aufgaben
Große Probleme werden besser beherrschbar, wenn Lernende sie in Teilaufgaben zerlegen, wiederkehrende Muster erkennen und dadurch nicht nur eine einzelne Lösung, sondern allgemeine Strategien für ähnliche Situationen entwickeln können. Die Gruppen erhalten eine etwas umfangreichere Aufgabe, etwa ein Labyrinthspiel, einen Essensplan-Generator, ein Punktesystem für ein Turnier oder eine Temperaturüberwachung mit Warnsignal. Die Lernenden zerlegen das Problem in Teilbereiche wie Eingabe, Verarbeitung, Anzeige, Fehlerfall und Wiederholung. Danach suchen sie nach wiederkehrenden Mustern, etwa Vergleichen, Zählen, Wiederholen oder Sortieren. Diese Muster werden farblich markiert und später gezielt in den Algorithmus übernommen.
Die Schülerinnen und Schüler zerlegen eine komplexere Aufgabe in Teilprobleme, benennen wiederkehrende Muster und erstellen daraus eine strukturierte Übersicht für den späteren Entwurf. Teilprobleme, Muster Eingabe, Ausgabe Zählen, Vergleichen Wiederholen, Prüfen Strukturplan, Übersicht Markierung, Erklärung
8.4.3 Algorithmusentwurf mit Karten und Bodenplan
Algorithmen werden besonders verständlich, wenn Schritte nicht sofort programmiert, sondern zuerst körperlich, visuell und kooperativ aufgebaut werden, weil Denkfehler dabei früh sichtbar und Korrekturen ohne Syntaxprobleme leichter möglich werden. Die Lehrkraft stellt Karten mit Befehlen, Entscheidungen und Wiederholungen bereit. Auf dem Boden oder auf einem großen Plakat legen die Gruppen damit einen Algorithmus, etwa für einen Roboterweg, ein Sortierverfahren oder eine Passwortprüfung. Jede Gruppe führt ihren Ablauf probeweise aus, während andere Lernende Fehler oder Lücken beobachten. Erst wenn der Ablauf logisch funktioniert, wird er in eine formale Darstellung übertragen.
Die Gruppen entwerfen einen vollständigen Algorithmus mit Ablaufkarten, testen ihn durch Ausführen und verbessern ihn anschließend vor der schriftlichen oder digitalen Umsetzung.
Ablaufkarten, Bodenplan Start, Ende Bedingung, Schleife Schritte, Reihenfolge Testlauf, Korrektur Übertragung, Sicherung
8.4.4 Formale Darstellung mit Pseudocode und Ablaufplan
Zwischen Idee und Programmcode entsteht tieferes Verständnis, wenn Algorithmen erst in einer halbformalen Sprache dargestellt werden, weil Reihenfolge, Entscheidungen und Wiederholungen dadurch klarer, kontrollierbarer und leichter diskutierbar werden. Die Gruppen wählen einen bereits modellierten Ablauf und stellen ihn in zwei Formen dar: als Ablaufplan und als Pseudocode. Geeignet sind Aufgaben wie das Finden der größten Zahl, das Berechnen eines Durchschnitts, das Öffnen eines Zahlenschlosses oder das Prüfen eines Tickets. Anschließend vergleichen die Gruppen, welche Darstellung für Übersicht, Genauigkeit und spätere Programmierung hilfreicher war.
Die Schülerinnen und Schüler schreiben zu einem Problem Pseudocode und zeichnen zusätzlich einen Ablaufplan. Danach erläutern sie Unterschiede und Vorteile beider Darstellungsformen. Pseudocode, Ablaufplan Schritte, Bedingungen Schleifen, Variablen Übersicht, Genauigkeit Vergleich, Deutung Transfer, Reflexion
8.4.5 Implementierung eines entworfenen Algorithmus
Der Übergang von der Darstellung zum Code erzeugt besonders nachhaltiges Lernen, wenn Lernende ihren eigenen Entwurf umsetzen und dabei erleben, wie abstrakte Schritte in konkrete Befehle, Variablen und Kontrollstrukturen übersetzt werden müssen. Die Gruppen implementieren einen zuvor entwickelten Algorithmus in einer geeigneten Umgebung, etwa Scratch, MakeCode, Open Roberta oder Python. Die Aufgabe kann ein Reaktionsspiel, eine Ampelsteuerung, ein Zahlenraten, ein Mini-Quiz oder eine Sensorreaktion sein. Wichtig ist, dass die Lernenden nicht mit einem fertigen Beispiel starten, sondern ihren eigenen formalen Entwurf als Grundlage verwenden. So wird der Zusammenhang zwischen Modell, Algorithmus und Code besonders deutlich.
Jede Gruppe setzt ihren Algorithmus in einer Programmierumgebung um und dokumentiert, welche Teile des Entwurfs direkt übernommen werden konnten und wo Änderungen nötig waren. Scratch, Python MakeCode, Roboter Variablen, Bedingungen
Schleifen, Ereignisse Entwurf, Umsetzung Dokumentation, Vergleich
8.4.6 Testfälle planen und Programme systematisch prüfen
Starke Lerneffekte entstehen, wenn Programme nicht nur ausprobiert, sondern gezielt mit geplanten Testfällen überprüft werden, weil dadurch Korrektheit, Randfälle und Fehlverhalten bewusster wahrgenommen und nachvollziehbar dokumentiert werden. Die Klasse arbeitet mit einem fertigen oder selbst geschriebenen Programm, etwa einem Quiz, einem Punktesystem, einem Passwortcheck oder einer Sensorauswertung. Die Gruppen erstellen zuerst Testfälle mit Eingabe, erwarteter Ausgabe und Begründung. Danach führen sie die Tests durch und notieren Abweichungen. Besonders wichtig sind auch Randfälle, etwa leere Eingaben, zu große Zahlen oder unerwartete Tastendrücke. So wird Testen als planbarer Teil der Entwicklung erlebt.
Die Schülerinnen und Schüler erstellen vor der Programmausführung einen Testplan und überprüfen anschließend, ob das Programm in Standardfällen und Grenzfällen korrekt arbeitet. Testplan, Eingaben Erwartung, Ausgabe Grenzfall, Fehlerfall Abweichung, Beleg Korrektur, Wiederholung Protokoll, Ergebnis
8.4.7 Debugging mit Fehlerspur und Begründung
Fehlersuche wird besonders wirksam gelernt, wenn Lernende Fehler nicht bloß zufällig beheben, sondern systematisch eingrenzen, Ursachen benennen und daraus Regeln für zukünftige Programmierarbeit ableiten können. Die Lehrkraft stellt Programme mit typischen Fehlern bereit, etwa falsch gesetzte Bedingungen, vergessene Aktualisierungen von Variablen, endlose Schleifen oder fehlerhafte Reihenfolgen von Anweisungen. Die Gruppen analysieren zuerst das beobachtbare Problem, formulieren dann Vermutungen und prüfen diese Schritt für Schritt. Jede Korrektur muss begründet werden. Abschließend wird festgehalten, welcher Fehlertyp vorlag und wie man ihn früher hätte erkennen können.
Die Gruppen untersuchen ein fehlerhaftes Programm, dokumentieren ihre Fehlersuche und erstellen am Ende eine kurze Fehlerspur mit Ursache, Korrektur und Lernregel. Fehlerbild, Vermutung Ursache, Prüfung Korrektur, Test Syntax, Logik Fehlerspur, Lernregel Reflexion, Austausch
8.4.8 Ein Problem mit mehreren Algorithmen lösen
Vertieftes Verständnis entsteht besonders dann, wenn nicht nur ein einziger Lösungsweg gesucht wird, sondern mehrere Algorithmen für dasselbe Problem entworfen und hinsichtlich Klarheit, Aufwand und Eignung verglichen werden. Die Gruppen bearbeiten ein gemeinsames Problem, etwa Sortieren von Karten, Finden eines bestimmten Eintrags, Zählen von Häufigkeiten oder Steuern einer Spielfigur. Ziel ist, mindestens zwei verschiedene Lösungswege zu entwickeln. Danach werden die Varianten formal dargestellt und miteinander verglichen. So erkennen die Lernenden, dass Algorithmen Entscheidungen sind und dass Lösungen sich in Länge, Übersicht, Wiederholungen oder Erweiterbarkeit unterscheiden können.
Jede Gruppe entwickelt zwei unterschiedliche Algorithmen für dasselbe Problem und vergleicht sie anschließend mit Blick auf Verständlichkeit, Schrittzahl und Übertragbarkeit. Variante A, Variante B Schrittzahl, Klarheit Aufwand, Struktur Vergleich, Kriterien Vorteile, Nachteile Urteil, Begründung
8.4.9 Pair Programming für Entwicklung und Test
Gemeinsames Arbeiten mit klaren Rollen fördert besonders tiefe Lernprozesse, weil Planung, Umsetzung, Kontrolle und Sprache eng verbunden werden und jede Entscheidung im Dialog überprüft, erklärt und verbessert werden muss. Die Lernenden arbeiten zu zweit an einer vollständigen Mini-Aufgabe, etwa einem Zahlenvergleich, einem Reaktionsspiel oder einer Sensorsteuerung. Eine Person übernimmt als Driver die Eingabe, die andere als Navigator achtet auf Logik, Testfälle und mögliche Fehler. Nach einer festgelegten Zeit wechseln die Rollen. Am Ende reflektieren beide, welche Entscheidungen im Team besser gelungen sind als allein und wo Missverständnisse aufgetreten sind.
Die Zweierteams entwickeln ein kleines Programm im Rollenwechsel und halten in einem Kurzprotokoll fest, wie Modellierung, Code und Tests gemeinsam verbessert wurden. Driver, Navigator Rollenwechsel, Dialog Modell, Code Tests, Kontrolle Kurzprotokoll, Reflexion Teamarbeit, Ergebnis
8.4.10 Projektkette vom Modell bis zur Verbesserung
Besonders nachhaltige Lernwirkungen entstehen, wenn der gesamte Entwicklungsprozess in einem Projekt durchlaufen wird, weil Modellierung, Algorithmusentwurf, Darstellung,
Implementierung, Test und Überarbeitung als zusammenhängende Problemlösungsstrategie erfahrbar werden. Die Gruppen wählen oder erhalten ein kleines Projekt, etwa ein Labyrinth, eine Bibliotheksverwaltung, ein Temperaturwarnsystem, ein Quiz mit Punkten oder ein Automatenspiel. Zuerst wird das Problem modelliert, danach ein Algorithmus entworfen und formal dargestellt. Anschließend folgt die Umsetzung in einer Programmierumgebung, danach das Testen mit geplanten Testfällen und schließlich eine überarbeitete zweite Version. So durchlaufen die Lernenden eine vollständige Entwicklungskette.
Jede Gruppe erstellt zu einem Mini-Projekt ein vollständiges Entwicklungsportfolio mit Modell, Darstellung, Code, Testplan, Fehlerkorrektur und verbesserter Endversion. Mini-Projekt, Portfolio Modell, Algorithmus Pseudocode, Code Testplan, Debugging Version eins, Version zwei Präsentation, Auswertung
Grundlage: Informatik – Lehrband 7. Klasse, Final V1.7 (2026).