|
|
| Zeile 1: |
Zeile 1: |
| ← [[DGB 3. Klasse|Digitale Grundbildung 3. Klasse]] | | ← [[DGB 3. Klasse|Digitale Grundbildung 3. Klasse]] |
|
| |
|
| Die kompakt formulierten Lernziele unterstützen den Aufbau informatischen Problemlösens, indem sie das Zerlegen, Strukturieren, Modellieren und schrittweise Umsetzen von Lösungswegen mit Beispielen aus Alltag, Mathematik, Technik und einfachen Programmierumgebungen verbinden. Lernziele Die Schülerinnen und Schüler können:
| | Computational Thinking ist eine Methode zum strukturierten Problemlösen. Ein Problem wird zerlegt, Muster werden gesucht, Unwichtiges wird ausgeblendet und daraus entsteht ein eindeutiger Algorithmus. Erst danach wird der Lösungsweg in '''Blöcke, Pseudocode oder Programmcode''' übersetzt und getestet. |
|
| |
|
| == 13.1 Lernziele == | | == Lehrplanbezug == |
|
| |
|
| * Elemente des Computational Thinkings an einfachen und lebensnahen Beispielen erklären.
| | {| class="wikitable" |
| * Probleme in kleinere Teilprobleme zerlegen und strukturiert bearbeiten.
| | ! Bereich |
| * Muster, Wiederholungen und Gemeinsamkeiten in Aufgaben erkennen.
| | ! Zuordnung |
| * unwichtige Details ausblenden und zentrale Merkmale eines Problems herausarbeiten.
| | |- |
| * Lösungswege als eindeutige Schrittfolgen planen und beschreiben.
| | | '''Kompetenzbereich''' |
| * Algorithmen mit Sequenzen, Bedingungen und Schleifen entwickeln.
| | | Produktion |
| * einfache Lösungswege in einer Programmiersprache oder blockbasierten Umgebung umsetzen.
| | |- |
| * Programme testen, Fehler erkennen und Lösungen verbessern.
| | | '''Perspektiven''' |
| * eigene Lösungswege begründen und auf ähnliche Probleme übertragen.
| | | T, I |
| | |- |
| | | '''Schwerpunkt''' |
| | | Computational Thinking nachvollziehen und Lösungswege in Programmiersprache umsetzen |
| | |- |
| | | '''Kompetenz''' |
| | | Probleme zerlegen, Muster erkennen, abstrahieren, Algorithmen entwerfen und einfache Lösungswege in einer Programmiersprache oder blockbasierten Umgebung umsetzen und testen. |
| | |} |
|
| |
|
| == 13.2 Lerninhalte == | | == Lernziele == |
|
| |
|
| Die Lerninhalte verbinden grundlegende Denkweisen des Computational Thinkings mit anschaulichen Beispielen und ersten Programmierumsetzungen, sodass Problemlösen nicht nur theoretisch verstanden, sondern als planbarer, überprüfbarer und technisch umsetzbarer Prozess erlebt werden kann. | | Die Schülerinnen und Schüler können: |
| | |
| | * die Kernideen Zerlegung, Mustererkennung, Abstraktion und algorithmisches Denken erklären; |
| | * größere Probleme in bearbeitbare Teilprobleme zerlegen; |
| | * Wiederholungen und Gemeinsamkeiten erkennen; |
| | * wichtige von unwichtigen Informationen unterscheiden; |
| | * Algorithmen als eindeutige Schrittfolgen formulieren; |
| | * Sequenzen, Bedingungen und Schleifen verwenden; |
| | * Ablaufpläne oder Pseudocode lesen und erstellen; |
| | * einfache Lösungen in einer geeigneten Programmier- oder Lernumgebung umsetzen; |
| | * Programme mit Testfällen prüfen und Fehler systematisch beheben; |
| | * Lösungswege vergleichen, begründen und auf ähnliche Probleme übertragen; |
| | |
| | == Lerninhalte == |
|
| |
|
| === Was Computational Thinking bedeutet === | | === Was Computational Thinking bedeutet === |
|
| |
|
| Computational Thinking wird besonders verständlich, wenn es als Denkweise zum Lösen von Problemen betrachtet wird, bei der Aufgaben geordnet analysiert, in sinnvolle Schritte zerlegt und so beschrieben werden, dass Menschen oder Computer sie ausführen können. Computational Thinking bedeutet nicht einfach nur Programmieren, sondern eine bestimmte Art des Denkens. Ein Problem wird so bearbeitet, dass klare Strukturen, wiederkehrende Muster und eindeutige Abläufe sichtbar werden. Wer etwa einen Weg durch ein Labyrinth plant, einen Stundenplan ordnet oder ein Spiel mit Regeln beschreibt, nutzt bereits Denkweisen, die dem Computational Thinking nahekommen. Entscheidend ist, dass ein Problem systematisch statt zufällig bearbeitet wird. | | Computational Thinking ist nicht auf Computer beschränkt. Es beschreibt Denkstrategien, mit denen komplexe Aufgaben systematisch lösbar werden. |
|
| |
|
| Im Alltag geschieht das häufig unbewusst. Beim Packen einer Schultasche wird geprüft, welche Fächer anstehen, welche Materialien gebraucht werden und in welcher Reihenfolge etwas vorbereitet werden soll. Beim Backen wird ein Rezept in Einzelschritte zerlegt. Beim Suchen eines verlorenen Gegenstands werden Orte ausgeschlossen, Muster im eigenen Verhalten erkannt und Suchstrategien angepasst. Solche Beispiele zeigen, dass informatisches Denken auch ohne Computer beginnt. Im schulischen Kontext wird Computational Thinking besonders wichtig, wenn Probleme nicht nur gelöst, sondern auch so beschrieben werden sollen, dass eine andere Person oder ein Computer sie nachvollziehen kann. Genau hier entsteht die Verbindung zur Programmiersprache: Ein klar geplanter Lösungsweg lässt sich später technisch umsetzen. Kernelemente: ordnen, zerlegen, erkennen, abstrahieren, planen Alltagsbeispiele: Rezept, Schultasche, Suchweg, Wegbeschreibung, Spielregel Ziele: Klarheit, Struktur, Nachvollziehbarkeit, Übertragbarkeit, Umsetzung
| | Das Ziel ist eine Lösung, die so klar beschrieben ist, dass sie von einem Menschen oder Computer nachvollzogen werden kann. |
|
| |
|
| === Probleme zerlegen und strukturieren === | | === Probleme zerlegen und strukturieren === |
|
| |
|
| Die Zerlegung eines Problems in kleinere Schritte erleichtert das Verstehen und Bearbeiten deutlich, weil große oder unübersichtliche Aufgaben dadurch in handhabbare Teilprobleme mit klaren Zwischenzielen und nachvollziehbaren Arbeitsschritten überführt werden können. Eine der wichtigsten Denkweisen des Computational Thinkings ist die Dekomposition. Dabei wird ein großes Problem in kleinere Teilprobleme aufgeteilt. Wer etwa ein digitales Quiz programmieren möchte, muss nicht alles gleichzeitig lösen. Zunächst wird geklärt, wie Fragen gespeichert werden, wie Antworten eingegeben werden, wie richtige Lösungen erkannt werden und wie Punkte gezählt werden. Jede Teilaufgabe kann einzeln geplant und gelöst werden. Auch außerhalb des Programmierens ist diese Strategie hilfreich. Soll ein Klassenfest organisiert werden, lässt sich die Aufgabe in Raumplanung, Einladungen, Verpflegung, Musik und Ablauf unterteilen. Beim Lösen einer Sachaufgabe in Mathematik werden Informationen entnommen, Zwischenschritte berechnet und Ergebnisse überprüft. Gerade für komplexe Probleme ist diese Zerlegung besonders wertvoll, weil sie Überforderung reduziert und Zusammenarbeit erleichtert. Für die Umsetzung in einer Programmiersprache ist diese Denkweise zentral. Ein Programm besteht oft aus mehreren Teilen, etwa Eingabe, Verarbeitung und Ausgabe. Wer Probleme sinnvoll zerlegt, kann Funktionen, Variablen und Teilprogramme gezielter planen und später besser testen. Denkschritte: zerlegen, ordnen, trennen, bündeln, prüfen Beispiele: Quizprogramm, Klassenfest, Sachaufgabe, Appidee, Spiel Nutzen: Übersicht, Zwischenziele, Arbeitsteilung, Fehlersuche, Planbarkeit
| | Eine große Aufgabe wird in kleinere Teile zerlegt. Bei einem Quizprogramm können dies Fragen speichern, Antwort einlesen, Antwort prüfen, Punkte zählen und Ergebnis ausgeben sein. |
| | |
| | Zerlegung macht sichtbar, welche Teilprobleme unabhängig bearbeitet werden können. |
|
| |
|
| === Muster erkennen und Gemeinsamkeiten nutzen === | | === Muster erkennen und Gemeinsamkeiten nutzen === |
|
| |
|
| Das Erkennen von Mustern hilft dabei, ähnliche Situationen schneller zu verstehen und Lösungen zu verallgemeinern, weil nicht jede Aufgabe vollständig neu gedacht werden muss, wenn sich Strukturen, Wiederholungen oder Regeln bereits wiederfinden lassen.
| | Wiederkehrende Abläufe können zusammengefasst werden. Wenn zehn Fragen immer gleich geprüft werden, muss der Prozess nicht zehnmal neu erfunden werden. |
|
| |
|
| Mustererkennung bedeutet, Gemeinsamkeiten, Wiederholungen oder ähnliche Abläufe in Problemen zu entdecken. Wenn in einem Spiel mehrere Figuren nach denselben Regeln bewegt werden, kann ein gemeinsamer Lösungsweg genutzt werden. Wenn bei vielen Mathematikaufgaben immer zuerst Werte eingelesen, dann verglichen und anschließend ausgegeben werden, zeigt sich eine wiederkehrende Struktur. Solche Muster helfen, Lösungen effizienter zu entwickeln. Ein anschauliches Beispiel ist das Sortieren. Ob Bücher nach Titel, Karten nach Zahl oder Namen in einer Liste geordnet werden sollen, das Grundproblem ähnelt sich. Ebenso gibt es Muster bei Bewegungen in Spielen: eine Figur läuft, stößt an einen Rand, dreht um und läuft weiter. Wird dieses Muster erkannt, kann es in einer Schleife oder einer Funktion gebündelt werden. Bei digitalen Geschichten treten ebenfalls Muster auf, wenn Figuren begrüßen, warten, reagieren und weitergehen. In der Programmiersprache zeigt sich Mustererkennung oft darin, dass ähnliche Codeteile zusammengefasst werden. Wiederholte Abläufe können mit Schleifen oder Funktionen gelöst werden. Dadurch wird Code kürzer, übersichtlicher und leichter veränderbar. Musterarten: Wiederholung, Regel, Vergleich, Reihenfolge, Struktur Beispiele: Sortieren, Spielfigur, Namensliste, Rechenmuster, Begrüßung Umsetzung: Schleife, Funktion, Vorlage, Wiederverwendung, Vereinfachung | | Mustererkennung führt häufig zu Schleifen, Funktionen oder wiederverwendbaren Programmteilen. |
|
| |
|
| === Wesentliches hervorheben und Unwichtiges ausblenden === | | === Wesentliches hervorheben und Unwichtiges ausblenden === |
|
| |
|
| Abstraktion wird dann nachvollziehbar, wenn aus einer komplexen Situation nur die entscheidenden Merkmale übernommen werden und nebensächliche Details bewusst weggelassen werden, damit ein Problem einfacher beschrieben, verglichen und technisch verarbeitet werden kann. Abstraktion bedeutet, sich auf das Wesentliche zu konzentrieren. Soll ein Programm den kürzesten Schulweg berechnen, sind Haarfarbe, Lieblingsmusik oder Schuhgröße der beteiligten Personen unwichtig. Relevant sind dagegen Startpunkt, Ziel, Entfernung, mögliche Wege und vielleicht Verkehrsregeln. Durch Abstraktion wird ein Problem handhabbar und programmierbar. Auch bei Spielen ist diese Denkweise wichtig. Eine Spielfigur kann in der Realität viele Eigenschaften haben, für ein bestimmtes Programm reichen aber vielleicht nur Position, Richtung und Geschwindigkeit. Bei einer Wetter-App interessieren nicht alle Umweltfaktoren gleichzeitig, sondern zunächst nur Temperatur, Niederschlag und Uhrzeit. In Tabellen oder Datenmodellen zeigt sich Abstraktion ebenfalls: Nicht alles wird gespeichert, sondern nur das, was für die Aufgabe gebraucht wird. Für die Programmierung bedeutet Abstraktion, passende Variablen, Datenstrukturen und Regeln auszuwählen. Wer zu viele Details übernimmt, macht Programme unnötig kompliziert. Wer zu wenig berücksichtigt, löst das Problem unvollständig. Gute Lösungen entstehen deshalb dort, wo das Wesentliche treffend ausgewählt wird. Abstraktion: auswählen, weglassen, vereinfachen, modellieren, fokussieren Beispiele: Schulweg, Wetterapp, Spielfigur, Stundenplan, Punktestand Wesentlich: Ort, Zahl, Zustand, Regel, Eingabe | | Abstraktion konzentriert sich auf Merkmale, die für die Lösung notwendig sind. Für einen Fahrkartenautomaten sind Farbe der Jacke oder Lieblingsmusik der Nutzerin irrelevant. |
| | |
| | Zu starke Vereinfachung kann wichtige Informationen verlieren; gute Abstraktion ist daher eine begründete Auswahl. |
|
| |
|
| === Algorithmen als eindeutige Schrittfolgen === | | === Algorithmen als eindeutige Schrittfolgen === |
|
| |
|
| Ein Algorithmus wird besonders verständlich, wenn Lösungswege so formuliert werden, dass sie eindeutig, vollständig und in einer sinnvollen Reihenfolge ausführbar sind, ohne dass geraten oder zusätzliche Entscheidungen außerhalb der Beschreibung nötig werden. Ein Algorithmus ist eine eindeutige Schrittfolge zur Lösung eines Problems. Im Alltag finden sich viele algorithmische Abläufe, etwa beim Händewaschen, beim Binden von Schuhen oder beim Kochen nach Rezept. In der Informatik müssen diese Schritte jedoch besonders klar beschrieben werden, damit ein Computer sie ausführen kann. Mehrdeutige Aussagen wie „mach es ordentlich“ reichen dafür nicht aus. Ein Beispiel ist das Finden der größten Zahl aus drei Eingaben. Der Lösungsweg kann lauten: Lies drei Zahlen ein, vergleiche die erste mit der zweiten, merke die größere, vergleiche diese mit der dritten und gib die größte aus. Ein anderes Beispiel ist das Steuern einer Spielfigur: Drücke die Pfeiltaste, bewege die Figur um einen Schritt, prüfe den Rand, ändere bei Bedarf die Richtung. Solche Algorithmen bestehen aus klaren Einzelschritten. Für Schülerinnen und Schüler ist wichtig zu erkennen, dass Algorithmen nicht nur geschrieben, sondern auch getestet und verbessert werden. Ein guter Algorithmus ist nachvollziehbar, wiederholbar und für ähnliche Aufgaben übertragbar. Genau diese Eigenschaften machen ihn zur Grundlage von Programmen. Eigenschaften: eindeutig, endlich, geordnet, ausführbar, überprüfbar Beispiele: Rezept, Vergleich, Spielfigur, Suchweg, Sortierfolge Arbeitsschritte: beschreiben, testen, verbessern, übertragen, umsetzen | | Ein Algorithmus ist eine geordnete, ausführbare und endliche Schrittfolge. Unklare Anweisungen wie „mach es passend“ sind für Computer ungeeignet. |
| | |
| | Ablaufpläne und Pseudocode helfen, Logik zu prüfen, bevor konkreter Programmcode geschrieben wird. |
|
| |
|
| === Grundstrukturen der Programmierung verstehen === | | === Grundstrukturen der Programmierung verstehen === |
|
| |
|
| Die Umsetzung von Lösungswegen in Programmiersprache gelingt besonders gut, wenn grundlegende Bausteine wie Reihenfolge, Wiederholung, Verzweigung, Variablen und Funktionen an einfachen Beispielen mit klar erkennbarem Nutzen eingeführt und erprobt werden. Damit aus einem Lösungsweg ein Programm wird, braucht es grundlegende Strukturen. Eine Sequenz beschreibt eine feste Reihenfolge von Befehlen, etwa „Frage stellen, Antwort lesen, Ergebnis anzeigen“. Bedingungen steuern Entscheidungen, zum Beispiel „wenn die Antwort richtig ist, erhöhe die Punktzahl, sonst gib einen Hinweis“. Schleifen wiederholen Abläufe, etwa „wiederhole fünf Fragen“ oder „solange die Figur den Rand nicht erreicht, bewege sie weiter“. Variablen speichern Werte, die sich ändern können, etwa Punkte, Namen, Temperaturen oder Positionen. Funktionen oder Prozeduren fassen wiederkehrende Abläufe zusammen, beispielsweise „begrüße Spielende“, „zeichne Quadrat“ oder „prüfe Kollision“. Diese Bausteine bilden das Gerüst vieler Programme, egal ob blockbasiert oder textbasiert programmiert wird. Beispiele helfen beim Verstehen: Eine Ampelsimulation braucht Zustände und Wiederholungen, ein Reaktionstest braucht Zeitmessung, Eingabe und Vergleich, ein Vokabeltrainer braucht Zufallsauswahl, Antwortprüfung und Punkteanzeige. So wird deutlich, dass Programmiersprachen Lösungswege nicht ersetzen, sondern sie in ausführbare Form bringen.
| | Eine '''Sequenz''' führt Befehle nacheinander aus. Eine '''Bedingung''' entscheidet abhängig von einem Wahrheitswert. Eine '''Schleife''' wiederholt Schritte. |
|
| |
|
| Bausteine: Sequenz, Bedingung, Schleife, Variable, Funktion Beispiele: Quiz, Ampel, Reaktionstest, Vokabeltrainer, Spielfigur Nutzen: steuern, speichern, wiederholen, entscheiden, vereinfachen
| | Variablen speichern veränderliche Werte, Eingaben liefern Daten und Ausgaben machen Ergebnisse sichtbar. |
|
| |
|
| === Beispiele vom Problem zur Programmlösung === | | === Beispiele vom Problem zur Programmlösung === |
|
| |
|
| Der Weg von einer Aufgabenstellung zur Programmiersprache wird besonders anschaulich, wenn konkrete Probleme Schritt für Schritt analysiert, algorithmisch beschrieben und anschließend mit passenden Programmbausteinen umgesetzt werden. Ein einfaches Beispiel ist ein digitales Würfelspiel. Zuerst wird das Problem beschrieben: Eine Zahl von eins bis sechs soll zufällig erzeugt und angezeigt werden. Dann wird der Lösungsweg geplant: Taste drücken, Zufallszahl erzeugen, Bild oder Zahl anzeigen. Schließlich wird dies in einer Programmiersprache umgesetzt, etwa mit einem Ereignis, einer Variablen und einer Zufallsfunktion. Ein zweites Beispiel ist ein Pflanzen-Erinnerer. Die Aufgabe lautet: Gib je nach Anzahl vergangener Tage einen Hinweis, ob gegossen werden soll. Der Lösungsweg nutzt Eingabe, Vergleich und Ausgabe. Ein drittes Beispiel ist ein Laufspiel mit Punkten. Hier werden Tasten, Bewegung, Kollision, Punktestand und Spielende geplant. Solche Beispiele zeigen, dass Computational Thinking immer mit einer Analyse beginnt und dann zu konkreten Programmstrukturen führt. Auch fachübergreifende Aufgaben sind möglich. In Mathematik kann ein Programm Zahlenreihen untersuchen oder Flächen berechnen. In Geografie kann eine kleine Wetterauswertung programmiert werden. In Sprachen kann ein Vokabeltrainer entstehen. So wird sichtbar, dass informatisches Denken nicht nur für Computerunterricht relevant ist, sondern allgemeine Problemlösekompetenz stärkt. Beispielwege: analysieren, planen, codieren, testen, verbessern Programme: Würfelspiel, Pflanzenhilfe, Laufspiel, Rechner, Vokabeltrainer Fächer: Mathematik, Geografie, Sprache, Technik, Alltag
| | Ein Zahlenratespiel beginnt mit Problemdefinition und Ablauf. Danach werden Eingabe, Vergleich, Ausgabe und Wiederholung festgelegt. Erst anschließend erfolgt die technische Umsetzung. |
| | |
| | Diese Reihenfolge verhindert, dass Programmieren zu blindem Ausprobieren einzelner Befehle wird. |
|
| |
|
| === Testen, Fehler finden und verbessern === | | === Testen, Fehler finden und verbessern === |
|
| |
|
| Das Überprüfen und Verbessern von Lösungen gehört wesentlich zum Computational Thinking, weil Programme selten auf Anhieb fehlerfrei funktionieren und erst durch systematisches Testen sichtbar wird, ob ein Lösungsweg vollständig, sinnvoll und technisch korrekt umgesetzt wurde. Beim Testen wird geprüft, ob ein Programm wirklich das tut, was geplant war. Dazu werden verschiedene Eingaben ausprobiert, Randfälle betrachtet und Fehlermeldungen beobachtet. Wenn ein Quiz keine Punkte zählt, eine Figur durch Wände läuft oder ein Taschenrechner falsche Ergebnisse liefert, muss untersucht werden, an welcher Stelle der Lösungsweg oder der Code fehlerhaft ist. Dieses gezielte Suchen und Korrigieren nennt man Debugging. Fehler können unterschiedliche Ursachen haben. Vielleicht wurde eine Bedingung falsch formuliert, eine Variable nicht richtig gesetzt oder eine Schleife läuft zu oft oder gar nicht. Deshalb ist es hilfreich, Programme schrittweise zu entwickeln und jeden Teil einzeln zu prüfen.
| | Programme werden mit normalen, besonderen und fehlerhaften Eingaben getestet. Fehler werden reproduziert, eingegrenzt und schrittweise korrigiert. |
|
| |
|
| Auch das laute Erklären eines Programms oder das Prüfen in Partnerarbeit kann helfen, Fehler zu entdecken. Für das Lernen ist wichtig, Fehler nicht als Scheitern zu verstehen, sondern als Teil des Entwicklungsprozesses. Gerade beim Programmieren zeigt sich, dass gute Lösungen oft durch mehrfaches Überarbeiten entstehen. Computational Thinking schließt deshalb immer auch Prüfen, Anpassen und Verbessern ein. Fehlersuche: testen, vergleichen, beobachten, korrigieren, wiederholen Fehlerarten: Bedingung, Schleife, Variable, Eingabe, Reihenfolge Haltungen: Geduld, Genauigkeit, Offenheit, Überarbeitung, Lernchance
| | Debugging ist keine Niederlage, sondern ein normaler Teil der Softwareentwicklung. |
|
| |
|
| === Übertragen und weiterentwickeln === | | === Übertragen und weiterentwickeln === |
|
| |
|
| Die Stärke des Computational Thinkings zeigt sich besonders darin, dass einmal entwickelte Lösungswege auf ähnliche Probleme übertragen und schrittweise erweitert werden können, sodass aus einfachen Modellen zunehmend komplexere und kreativere Programme entstehen. Ein gelernter Lösungsweg bleibt nicht auf ein einziges Beispiel beschränkt. Wer verstanden hat, wie ein Quiz mit Fragen und Antworten funktioniert, kann später ein Sprachquiz, ein Mathequiz oder ein Geografiequiz gestalten. Wer Schleifen bei einer Tanzanimation einsetzt, kann sie auch für Bewegungen in einem Spiel oder für Muster in einer Grafik verwenden. So entsteht aus einer einzelnen Lösung ein übertragbares Denkwerkzeug. Auch Erweiterungen gehören dazu. Ein einfaches Würfelprogramm kann später um einen zweiten Würfel, eine Punktewertung oder Spielregeln ergänzt werden. Eine Wetterauswertung kann zunächst nur Temperaturen anzeigen und später Durchschnittswerte oder Warnhinweise berechnen. Solche Weiterentwicklungen zeigen, dass Programme wachsen können, wenn die Grundstruktur klar geplant wurde. Diese Übertragbarkeit ist ein zentrales Ziel des Lernens. Schülerinnen und Schüler sollen nicht nur einzelne Befehle kennen, sondern erkennen, welche Denk- und Lösungsweisen sich auf neue Aufgaben anwenden lassen. Dadurch wird aus dem Programmieren ein verstehendes und kreatives Arbeiten mit informatischen Mitteln. Übertragung: wiederverwenden, anpassen, erweitern, kombinieren, verallgemeinern Beispiele: Quizvarianten, Spielausbau, Grafikmuster, Wettertool, Rechner Ziele: Selbstständigkeit, Kreativität, Transfer, Sicherheit, Problemlösen
| | Ein gelöster Algorithmus kann oft auf ähnliche Aufgaben übertragen werden. Eine Schleife zum Durchlaufen einer Fragenliste kann auch für Messwerte oder Namen verwendet werden. |
| | |
| | Reflexion fragt, welche Teile allgemein und welche speziell für das ursprüngliche Problem waren. |
| | |
| | == Aufgaben für den Unterricht == |
| | |
| | === Probleme in Teilaufgaben zerlegen === |
| | |
| | '''Arbeitsauftrag:''' Zerlegt eine Klassenveranstaltung oder ein kleines Softwareprojekt in klar abgegrenzte Teilprobleme. |
| | |
| | '''Erwartetes Ergebnis:''' Zerlegungsbaum. |
| | |
| | === Muster in Aufgaben erkennen === |
| | |
| | '''Arbeitsauftrag:''' Markiert wiederkehrende Schritte in mehreren ähnlichen Arbeitsabläufen. |
| | |
| | '''Erwartetes Ergebnis:''' Musterliste. |
| | |
| | === Unwichtiges ausblenden und Wesentliches wählen === |
| | |
| | '''Arbeitsauftrag:''' Entscheidet bei einem Problem, welche Informationen für die Lösung gebraucht werden. |
| | |
| | '''Erwartetes Ergebnis:''' Abstraktionskarte. |
| | |
| | === Algorithmen als Schrittfolgen formulieren === |
|
| |
|
| == 13.4 Aufgaben für den Unterricht ==
| | '''Arbeitsauftrag:''' Schreibt eine eindeutige Anleitung für eine Alltagshandlung und testet sie mit einer anderen Gruppe. |
|
| |
|
| === 13.4.1 Probleme in Teilaufgaben zerlegen ===
| | '''Erwartetes Ergebnis:''' getesteter Algorithmus. |
|
| |
|
| Das strukturierte Zerlegen einer Aufgabe in kleinere Bearbeitungsschritte hilft den Lernenden besonders wirksam dabei, komplexe Anforderungen überschaubar zu machen und den Übergang von einer Idee zu einem lösbaren informatischen Problem bewusst nachzuvollziehen. Die Schülerinnen und Schüler erhalten ein alltagsnahes Problem, etwa ein digitales Quiz, einen Punktezähler für ein Spiel, eine Pflanzen-Erinnerung oder eine einfache Wetteranzeige. In Kleingruppen zerlegen sie die Gesamtaufgabe in Teilprobleme, zum Beispiel Eingaben, Verarbeitung, Ausgabe, Rückmeldung und mögliche Fehlerfälle. Anschließend ordnen sie die Teilaufgaben in eine sinnvolle Reihenfolge und erstellen ein Aufgabenblatt mit Zwischenzielen. Im Plenum wird verglichen, welche Zerlegungen besonders klar und praktikabel sind. Die Aufgabe ist besonders lernwirksam, weil sie den ersten Schritt informatischen Denkens sichtbar macht und eine tragfähige Grundlage für spätere Programmierung schafft. Beispiele: Quiz, Punktezähler, Pflanzenhilfe, Wetteranzeige Arbeitsschritte: zerlegen, ordnen, benennen, strukturieren Kompetenzen: analysieren, planen, gliedern, begründen Produkte: Teilaufgabenplan, Zwischenzielübersicht
| | === Ablaufpläne und Flussdiagramme erstellen === |
|
| |
|
| === 13.4.2 Muster in Aufgaben erkennen ===
| | '''Arbeitsauftrag:''' Übertragt einen Algorithmus mit Start, Entscheidung, Wiederholung und Ende in ein Flussdiagramm. |
|
| |
|
| Die gezielte Suche nach Wiederholungen und Gemeinsamkeiten stärkt das informatische Denken, weil Lernende dadurch verstehen, dass viele Probleme ähnliche Strukturen besitzen und deshalb nicht jedes Mal von Grund auf neu gelöst werden müssen. Die Klasse bearbeitet mehrere kurze Problemsituationen, etwa das Sortieren von Namen, das Wiederholen einer Spielfigurbewegung, das Prüfen mehrerer Antworten oder das Zeichnen sich wiederholender Formen. Die Schülerinnen und Schüler markieren Gemeinsamkeiten und formulieren, welches Grundmuster jeweils vorliegt, zum Beispiel Wiederholung, Vergleich oder Reihenfolge. Danach ordnen sie zu, welche Programmierbausteine dazu passen könnten, etwa Schleifen, Bedingungen oder Variablen. Diese Aufgabe ist besonders lernförderlich, weil sie abstrakte Denkmuster direkt mit späteren Programmstrukturen verbindet. Musterarten: Wiederholung, Vergleich, Reihenfolge, Auswahl, Regel Zuordnungen: Schleife, Bedingung, Variable, Funktion, Sequenz Kompetenzen: erkennen, abstrahieren, vergleichen, übertragen
| | '''Erwartetes Ergebnis:''' Ablaufplan. |
|
| |
|
| Produkte: Mustertabelle, Bausteinzuordnung
| | === Lösungswege in Programmiersprache umsetzen === |
|
| |
|
| === 13.4.3 Unwichtiges ausblenden und Wesentliches wählen ===
| | '''Arbeitsauftrag:''' Programmiert eine kleine Aufgabe mit Eingabe, Verarbeitung und Ausgabe in einer geeigneten Lernumgebung. |
|
| |
|
| Die Konzentration auf zentrale Merkmale eines Problems fördert tiefes Verstehen, weil Lernende lernen, zwischen hilfreichen und störenden Details zu unterscheiden und dadurch klarere Modelle für spätere Algorithmen und Programme zu entwickeln. Die Schülerinnen und Schüler erhalten beschriebene Alltagssituationen, etwa die Planung eines Schulwegs, die Steuerung einer Spielfigur oder die Organisation einer Essensbestellung. Ihre Aufgabe besteht darin, alle Informationen zu markieren, die für eine technische Lösung wichtig sind, und solche zu streichen, die für das Problem keine Rolle spielen. Anschließend formulieren sie in Gruppen ein vereinfachtes Modell mit nur den notwendigen Angaben. Im Austausch wird diskutiert, warum zu viele Details eine Programmierung erschweren und warum zu wenig Details das Problem unvollständig machen können. Die Aufgabe ist besonders wirksam, weil sie Abstraktion praktisch erfahrbar macht. Methoden: markieren, streichen, auswählen, modellieren Beispiele: Schulweg, Spielfigur, Bestellung, Wetterdaten Kompetenzen: abstrahieren, fokussieren, vereinfachen, erklären Produkte: Modellbeschreibung, Merkmalliste
| | '''Erwartetes Ergebnis:''' lauffähiges Programm. |
|
| |
|
| === 13.4.4 Algorithmen als Schrittfolgen formulieren === | | === Bedingungen und Schleifen gezielt einsetzen === |
|
| |
|
| Die Formulierung eindeutiger Schrittfolgen hilft den Lernenden besonders stark dabei, unscharfe Ideen in klar strukturierte Handlungsanweisungen zu überführen und dadurch die Grundlage für jede spätere Umsetzung in einer Programmiersprache zu legen. Die Schülerinnen und Schüler wählen ein einfaches Problem, etwa „größte Zahl finden“, „eine Figur durchs Labyrinth führen“ oder „eine Punktzahl berechnen“. Zunächst formulieren sie den Lösungsweg in Alltagssprache. Danach überarbeiten sie ihre Beschreibung so, dass jeder Schritt eindeutig, vollständig und in sinnvoller Reihenfolge formuliert ist. Im nächsten Schritt testet eine Partnergruppe den Algorithmus genau nach Vorgabe und meldet zurück, an welchen Stellen Unklarheiten oder Lücken sichtbar werden. Die Aufgabe ist besonders lernwirksam, weil sie präzises Denken, Sprache und technische Umsetzbarkeit verbindet. Probleme: Zahlvergleich, Labyrinth, Punktezahl, Sortieren Arbeitsschritte: beschreiben, präzisieren, testen, verbessern Kompetenzen: algorithmisieren, formulieren, ordnen, überprüfen Produkte: Algorithmusblatt, Partnerfeedback
| | '''Arbeitsauftrag:''' Erweitert das Programm um eine Entscheidung und mindestens eine sinnvolle Wiederholung. |
|
| |
|
| === 13.4.5 Ablaufpläne und Flussdiagramme erstellen ===
| | '''Erwartetes Ergebnis:''' erweiterte Version. |
|
| |
|
| Die Visualisierung von Lösungswegen unterstützt das Verständnis besonders nachhaltig, weil Lernende Abläufe, Entscheidungen und Wiederholungen grafisch ordnen und dadurch erkennen, wie ein Problem systematisch und nachvollziehbar aufgebaut werden kann. Die Klasse erstellt zu vorgegebenen Aufgaben ein Flussdiagramm oder einen Ablaufplan, etwa
| | === Fehler finden und Programme verbessern === |
|
| |
|
| für ein Quiz mit Rückmeldung, einen Türcode-Check oder ein kleines Rechenspiel. Die Schülerinnen und Schüler verwenden dabei Symbole für Start, Eingabe, Entscheidung, Verarbeitung und Ausgabe. Anschließend erklären sie ihren Plan mündlich und vergleichen ihn mit anderen Gruppenlösungen. In der Auswertung wird besprochen, welche Darstellung besonders klar ist und wo Schritte fehlen oder unnötig doppelt vorkommen. Diese Aufgabe ist besonders lernstark, weil sie Denkstruktur und Programmstruktur eng miteinander verknüpft. Darstellungen: Ablaufplan, Flussdiagramm, Symbolfolge, Strukturkarte Symbole: Start, Eingabe, Entscheidung, Ausgabe, Ende Kompetenzen: visualisieren, strukturieren, erklären, vergleichen Produkte: Diagramm, Kurzpräsentation
| | '''Arbeitsauftrag:''' Bearbeitet ein vorbereitetes fehlerhaftes Programm und dokumentiert Fehlerursache und Korrektur. |
|
| |
|
| === 13.4.6 Lösungswege in Programmiersprache umsetzen ===
| | '''Erwartetes Ergebnis:''' Debugging-Protokoll. |
|
| |
|
| Die erste technische Umsetzung eines bereits durchdachten Lösungswegs fördert ein besonders tragfähiges Verständnis, weil Lernende erleben, wie aus Analyse und Planung konkrete Programmbefehle, Steuerstrukturen und sichtbare Ergebnisse entstehen. Die Schülerinnen und Schüler übertragen einen vorbereiteten Algorithmus in eine blockbasierte oder textbasierte Programmiersprache, etwa Scratch oder eine einfache Python-Umgebung. Geeignete Aufgaben sind ein Begrüßungsprogramm, ein Reaktionstest, ein Würfelprogramm oder ein kleines Quiz. Wichtig ist, dass die Lernenden ihre zuvor geplanten Schritte gezielt passenden Befehlen zuordnen, statt nur Blöcke oder Codezeilen auszuprobieren. Nach der Umsetzung vergleichen sie Plan und fertiges Programm. Diese Aufgabe ist besonders lernförderlich, weil sie zeigt, dass Programmieren ein Umsetzen von Denkstrukturen und nicht bloß ein technisches Klicken ist. Programme: Begrüßung, Würfel, Quiz, Reaktionstest Bausteine: Eingabe, Ausgabe, Variable, Bedingung, Schleife Kompetenzen: codieren, zuordnen, umsetzen, nachvollziehen Produkte: Programm, Plan Code Vergleich
| | === Eigene Problemlösungen entwickeln === |
|
| |
|
| === 13.4.7 Bedingungen und Schleifen gezielt einsetzen ===
| | '''Arbeitsauftrag:''' Plant und programmiert ein kleines Quiz, Rechentool oder Spiel mit klaren Anforderungen. |
|
| |
|
| Das bewusste Arbeiten mit Bedingungen und Schleifen erhöht die Lernwirksamkeit deutlich, weil diese beiden Strukturen viele typische Probleme lösen helfen und Lernende dadurch zentrale Grundmuster der Programmierung praktisch und übertragbar verstehen. Die Schülerinnen und Schüler bearbeiten zwei eng verwandte Aufgaben: eine mit Entscheidung, etwa „wenn die Antwort richtig ist, gibt es einen Punkt“, und eine mit Wiederholung, etwa „stelle fünf Fragen hintereinander“. Zunächst markieren sie, wo im Lösungsweg entschieden oder wiederholt werden muss. Danach setzen sie beide Strukturen im Programm um und testen, ob das Verhalten den Erwartungen entspricht. Im Anschluss formulieren sie in eigenen Worten, wann eine Bedingung sinnvoll ist und wann eine Schleife gebraucht wird. Die Aufgabe ist besonders wirksam, weil sie zwei Schlüsselkonzepte nicht isoliert, sondern problembezogen vermittelt. Strukturen: Bedingung, Schleife, Wiederholung, Auswahl, Zähler
| | '''Erwartetes Ergebnis:''' Mini-Projekt. |
|
| |
|
| Beispiele: Quiz, Laufspiel, Punktewertung, Zahlenraten Kompetenzen: unterscheiden, einsetzen, erklären, anwenden Produkte: Teilprogramm, Strukturerklärung
| | === Lösungswege vergleichen und reflektieren === |
|
| |
|
| === 13.4.8 Fehler finden und Programme verbessern ===
| | '''Arbeitsauftrag:''' Vergleicht zwei funktionierende Lösungen nach Verständlichkeit, Aufwand und Übertragbarkeit. |
|
| |
|
| Die systematische Fehlersuche vertieft das Verständnis informatischer Lösungswege besonders stark, weil Lernende erkennen, dass Programme selten sofort funktionieren und dass Prüfen, Vergleichen und Überarbeiten ein wesentlicher Teil professionellen Problemlösens ist. Die Klasse erhält fehlerhafte kleine Programme oder bewusst unvollständige Codeabschnitte, etwa ein Quiz ohne richtige Punktewertung, eine Schleife mit falscher Anzahl oder eine Bedingung mit verkehrter Ausgabe. Die Schülerinnen und Schüler testen das Programm, beschreiben das beobachtete Problem und suchen gezielt die fehlerhafte Stelle. Danach verbessern sie das Programm und dokumentieren, welche Änderung welche Wirkung hatte. Diese Aufgabe ist besonders lernstark, weil sie Debugging als denkenden Prozess erfahrbar macht und nicht als reines Korrigieren. Fehlerarten: Variable, Bedingung, Schleife, Reihenfolge, Ausgabe Arbeitsschritte: testen, beobachten, lokalisieren, korrigieren Kompetenzen: debuggen, überprüfen, verbessern, begründen Produkte: Fehlerprotokoll, korrigiertes Programm
| | '''Erwartetes Ergebnis:''' Lösungsvergleich. |
|
| |
|
| === 13.4.9 Eigene Problemlösungen entwickeln === | | === Reflexion zum Abschluss === |
|
| |
|
| Die selbstständige Entwicklung eines kleinen Programms verbindet alle Elemente des Computational Thinkings zu einem zusammenhängenden Lernprozess und zeigt besonders deutlich, ob Lernende Analyse, Planung, Umsetzung und Überarbeitung eigenständig auf ein neues Problem anwenden können. Die Schülerinnen und Schüler wählen aus mehreren offenen Aufgabenstellungen, etwa digitales Lernspiel, Taschenrechner für einfache Werte, Zufallsgenerator, Vokabeltrainer oder Mini-Spiel mit Punkten. Sie planen zunächst Problem, Teilaufgaben und Algorithmus, erstellen dann ein Ablaufdiagramm und setzen ihre Lösung anschließend programmierend um. Während der Arbeit dokumentieren sie wichtige Entscheidungen und auftretende Schwierigkeiten. Abschließend präsentieren sie nicht nur das Ergebnis, sondern auch ihren Denkweg. Diese Aufgabe ist besonders wirksam, weil sie isolierte Teilkompetenzen in einem vollständigen Produktionsprozess zusammenführt. Projektideen: Lernspiel, Rechner, Zufallsgenerator, Trainer, Minispiel Prozess: planen, diagrammieren, programmieren, testen, zeigen Kompetenzen: selbstständig lösen, transferieren, gestalten, erklären Produkte: Eigenprogramm, Projektdokumentation
| | '''Arbeitsauftrag:''' Erkläre an deinem Projekt, wo Zerlegung, Mustererkennung, Abstraktion und Algorithmus vorkommen. |
|
| |
|
| === 13.4.10 Lösungswege vergleichen und reflektieren ===
| | '''Erwartetes Ergebnis:''' CT-Reflexion. |
|
| |
|
| Der Vergleich verschiedener Lösungswege fördert besonders nachhaltiges Lernen, weil sichtbar wird, dass Probleme oft auf mehreren Wegen lösbar sind und gute Informatik nicht nur richtige Ergebnisse, sondern auch Klarheit, Effizienz und Verständlichkeit umfasst. Die Schülerinnen und Schüler betrachten zwei oder drei unterschiedliche Lösungen für dieselbe Aufgabe, etwa verschiedene Quizprogramme oder alternative Wege zur Steuerung einer Figur. In Gruppen untersuchen sie, welche Lösung übersichtlicher, leichter erweiterbar oder besser nachvollziehbar ist. Danach formulieren sie Kriterien für eine gute Lösung, zum Beispiel Klarheit, passende Variablen, sinnvolle Wiederverwendung oder saubere Struktur. Diese Aufgabe ist besonders lernwirksam, weil sie Qualitätsbewusstsein und informatische Urteilskraft stärkt. Kriterien: Klarheit, Kürze, Struktur, Erweiterbarkeit, Verständlichkeit Vergleiche: Plan, Code, Ablauf, Wirkung, Fehleranfälligkeit Kompetenzen: beurteilen, vergleichen, reflektieren, verbessern Produkte: Kriterienliste, Vergleichsfazit
| | == Selbstcheck == |
|
| |
|
| === 13.4.11 Reflexion zum Abschluss ===
| | * Ich kann den Schwerpunkt „Computational Thinking nachvollziehen und Lösungswege in Programmiersprache umsetzen“ mit eigenen Worten erklären. |
| | * Ich kann die Kernideen Zerlegung, Mustererkennung, Abstraktion und algorithmisches Denken erklären. |
| | * Ich kann größere Probleme in bearbeitbare Teilprobleme zerlegen. |
| | * Ich kann Wiederholungen und Gemeinsamkeiten erkennen. |
| | * Ich kann wichtige von unwichtigen Informationen unterscheiden. |
| | * Ich kann Algorithmen als eindeutige Schrittfolgen formulieren. |
|
| |
|
| Eine strukturierte Abschlussreflexion sichert die Einsicht, dass Computational Thinking weit mehr ist als das Schreiben von Code, weil Probleme zuerst verstanden, strukturiert, modelliert und erst danach bewusst in eine Programmiersprache übertragen werden. Zum Abschluss verfassen die Schülerinnen und Schüler einen Reflexionstext oder bearbeiten Satzanfänge wie „Beim Zerlegen eines Problems hilft mir …“, „Ein Muster erkenne ich daran, dass …“, „Für einen guten Algorithmus ist wichtig …“ und „Beim Programmieren habe ich verstanden, dass …“. Alternativ kann ein Partnergespräch mit Reflexionskarten durchgeführt werden. Entscheidend ist, dass Denkweg, Umsetzung und Verbesserung als zusammenhängender Prozess beschrieben werden. Dadurch werden Problemlösekompetenz und Programmierverständnis nachhaltig gefestigt. Formen: Reflexionstext, Partnergespräch, Kartenarbeit Impulse: Zerlegung, Muster, Algorithmus, Programmierung Kompetenzen: sichern, formulieren, verknüpfen, reflektieren Produkte: Text, Gesprächsnotiz
| | == Siehe auch == |
|
| |
|
| Grundlage: Digitale Grundbildung III – Lehrband 3. Klasse, Final V2.5.
| | * [[DGB 2: Programmieren Testen Debuggen|Programmieren Testen Debuggen]] |
| | * [[DGB 3: KI in Software und physischen Systemen|Kuenstliche Intelligenz in Systemen]] |
| | * [[DGB 3: Computersysteme in Alltagsgegenstaenden|Computersysteme in Alltagsgegenstaenden]] |
|
| |
|
| [[Kategorie:Digitale Grundbildung 3. Klasse]] | | [[Kategorie:Digitale Grundbildung]] |
| | [[Kategorie:DGB 3]] |
← Digitale Grundbildung 3. Klasse
Computational Thinking ist eine Methode zum strukturierten Problemlösen. Ein Problem wird zerlegt, Muster werden gesucht, Unwichtiges wird ausgeblendet und daraus entsteht ein eindeutiger Algorithmus. Erst danach wird der Lösungsweg in Blöcke, Pseudocode oder Programmcode übersetzt und getestet.
| Bereich
|
Zuordnung
|
| Kompetenzbereich
|
Produktion
|
| Perspektiven
|
T, I
|
| Schwerpunkt
|
Computational Thinking nachvollziehen und Lösungswege in Programmiersprache umsetzen
|
| Kompetenz
|
Probleme zerlegen, Muster erkennen, abstrahieren, Algorithmen entwerfen und einfache Lösungswege in einer Programmiersprache oder blockbasierten Umgebung umsetzen und testen.
|
Die Schülerinnen und Schüler können:
- die Kernideen Zerlegung, Mustererkennung, Abstraktion und algorithmisches Denken erklären;
- größere Probleme in bearbeitbare Teilprobleme zerlegen;
- Wiederholungen und Gemeinsamkeiten erkennen;
- wichtige von unwichtigen Informationen unterscheiden;
- Algorithmen als eindeutige Schrittfolgen formulieren;
- Sequenzen, Bedingungen und Schleifen verwenden;
- Ablaufpläne oder Pseudocode lesen und erstellen;
- einfache Lösungen in einer geeigneten Programmier- oder Lernumgebung umsetzen;
- Programme mit Testfällen prüfen und Fehler systematisch beheben;
- Lösungswege vergleichen, begründen und auf ähnliche Probleme übertragen;
Computational Thinking ist nicht auf Computer beschränkt. Es beschreibt Denkstrategien, mit denen komplexe Aufgaben systematisch lösbar werden.
Das Ziel ist eine Lösung, die so klar beschrieben ist, dass sie von einem Menschen oder Computer nachvollzogen werden kann.
Eine große Aufgabe wird in kleinere Teile zerlegt. Bei einem Quizprogramm können dies Fragen speichern, Antwort einlesen, Antwort prüfen, Punkte zählen und Ergebnis ausgeben sein.
Zerlegung macht sichtbar, welche Teilprobleme unabhängig bearbeitet werden können.
Muster erkennen und Gemeinsamkeiten nutzen
[Bearbeiten]Wiederkehrende Abläufe können zusammengefasst werden. Wenn zehn Fragen immer gleich geprüft werden, muss der Prozess nicht zehnmal neu erfunden werden.
Mustererkennung führt häufig zu Schleifen, Funktionen oder wiederverwendbaren Programmteilen.
Wesentliches hervorheben und Unwichtiges ausblenden
[Bearbeiten]Abstraktion konzentriert sich auf Merkmale, die für die Lösung notwendig sind. Für einen Fahrkartenautomaten sind Farbe der Jacke oder Lieblingsmusik der Nutzerin irrelevant.
Zu starke Vereinfachung kann wichtige Informationen verlieren; gute Abstraktion ist daher eine begründete Auswahl.
Algorithmen als eindeutige Schrittfolgen
[Bearbeiten]Ein Algorithmus ist eine geordnete, ausführbare und endliche Schrittfolge. Unklare Anweisungen wie „mach es passend“ sind für Computer ungeeignet.
Ablaufpläne und Pseudocode helfen, Logik zu prüfen, bevor konkreter Programmcode geschrieben wird.
Grundstrukturen der Programmierung verstehen
[Bearbeiten]Eine Sequenz führt Befehle nacheinander aus. Eine Bedingung entscheidet abhängig von einem Wahrheitswert. Eine Schleife wiederholt Schritte.
Variablen speichern veränderliche Werte, Eingaben liefern Daten und Ausgaben machen Ergebnisse sichtbar.
Beispiele vom Problem zur Programmlösung
[Bearbeiten]Ein Zahlenratespiel beginnt mit Problemdefinition und Ablauf. Danach werden Eingabe, Vergleich, Ausgabe und Wiederholung festgelegt. Erst anschließend erfolgt die technische Umsetzung.
Diese Reihenfolge verhindert, dass Programmieren zu blindem Ausprobieren einzelner Befehle wird.
Programme werden mit normalen, besonderen und fehlerhaften Eingaben getestet. Fehler werden reproduziert, eingegrenzt und schrittweise korrigiert.
Debugging ist keine Niederlage, sondern ein normaler Teil der Softwareentwicklung.
Ein gelöster Algorithmus kann oft auf ähnliche Aufgaben übertragen werden. Eine Schleife zum Durchlaufen einer Fragenliste kann auch für Messwerte oder Namen verwendet werden.
Reflexion fragt, welche Teile allgemein und welche speziell für das ursprüngliche Problem waren.
Arbeitsauftrag: Zerlegt eine Klassenveranstaltung oder ein kleines Softwareprojekt in klar abgegrenzte Teilprobleme.
Erwartetes Ergebnis: Zerlegungsbaum.
Arbeitsauftrag: Markiert wiederkehrende Schritte in mehreren ähnlichen Arbeitsabläufen.
Erwartetes Ergebnis: Musterliste.
Unwichtiges ausblenden und Wesentliches wählen
[Bearbeiten]Arbeitsauftrag: Entscheidet bei einem Problem, welche Informationen für die Lösung gebraucht werden.
Erwartetes Ergebnis: Abstraktionskarte.
Arbeitsauftrag: Schreibt eine eindeutige Anleitung für eine Alltagshandlung und testet sie mit einer anderen Gruppe.
Erwartetes Ergebnis: getesteter Algorithmus.
Ablaufpläne und Flussdiagramme erstellen
[Bearbeiten]Arbeitsauftrag: Übertragt einen Algorithmus mit Start, Entscheidung, Wiederholung und Ende in ein Flussdiagramm.
Erwartetes Ergebnis: Ablaufplan.
Lösungswege in Programmiersprache umsetzen
[Bearbeiten]Arbeitsauftrag: Programmiert eine kleine Aufgabe mit Eingabe, Verarbeitung und Ausgabe in einer geeigneten Lernumgebung.
Erwartetes Ergebnis: lauffähiges Programm.
Bedingungen und Schleifen gezielt einsetzen
[Bearbeiten]Arbeitsauftrag: Erweitert das Programm um eine Entscheidung und mindestens eine sinnvolle Wiederholung.
Erwartetes Ergebnis: erweiterte Version.
Fehler finden und Programme verbessern
[Bearbeiten]Arbeitsauftrag: Bearbeitet ein vorbereitetes fehlerhaftes Programm und dokumentiert Fehlerursache und Korrektur.
Erwartetes Ergebnis: Debugging-Protokoll.
Arbeitsauftrag: Plant und programmiert ein kleines Quiz, Rechentool oder Spiel mit klaren Anforderungen.
Erwartetes Ergebnis: Mini-Projekt.
Lösungswege vergleichen und reflektieren
[Bearbeiten]Arbeitsauftrag: Vergleicht zwei funktionierende Lösungen nach Verständlichkeit, Aufwand und Übertragbarkeit.
Erwartetes Ergebnis: Lösungsvergleich.
Arbeitsauftrag: Erkläre an deinem Projekt, wo Zerlegung, Mustererkennung, Abstraktion und Algorithmus vorkommen.
Erwartetes Ergebnis: CT-Reflexion.
- Ich kann den Schwerpunkt „Computational Thinking nachvollziehen und Lösungswege in Programmiersprache umsetzen“ mit eigenen Worten erklären.
- Ich kann die Kernideen Zerlegung, Mustererkennung, Abstraktion und algorithmisches Denken erklären.
- Ich kann größere Probleme in bearbeitbare Teilprobleme zerlegen.
- Ich kann Wiederholungen und Gemeinsamkeiten erkennen.
- Ich kann wichtige von unwichtigen Informationen unterscheiden.
- Ich kann Algorithmen als eindeutige Schrittfolgen formulieren.
