Theorie.
Wie in den vorherigen Kapiteln erläutert, spielen Aufgaben eine zentrale Rolle im Unterricht. Gerade beim Lernen können Aufgaben den Lernprozess der Schüler*innen nachhaltig beeinflussen (vgl. Geldreich, 2019, S. 181). Im Informatikunterricht können besonders bei dem Erlernen einer (textuellen) Programmiersprache sinnvoll gewählte Aufgaben den Lern- und Entwicklungsprozess der Schüler*innen entscheidend beeinflussen und unterstützten.
Eine Art der Unterstützung von Lernprozesse durch verschiedene Maßnahmen der Lehrkraft, wie z.B. Hilfestellungen, Anleitungen oder auch die Aufgabenauswahl, ist das Scaffolding (vgl. Geldreich, 2019, S. 182). Nach von de Pol (2010, S. 274) beschreibt Scaffolding, zu Deutsch Gerüst, einen interaktionellen Prozess zwischen den Schüler*innen und der Lehrkraft. Zentral für diesen Prozess ist zum einen die Unterstützung der Lehrkraft und zum anderen die Verantwortung für den eigenen Lernprozess und die Kompetenz der Schüler*innen. Während diesem Prozess nimmt mit zunehmender Verantwortung und Kompetenz der Schüler*innen (transfer of responsibility) die Unterstützung der Lehrkraft immer mehr ab (fading). Somit passt sich die Unterstützung der Lehrkraft stets an das aktuelle Kompetenzlevel der Lernenden an, bis die Unterstützung minimal und die geförderte Kompetenz/Wissen der Lernenden maximal bzw. auf dem zu erreichenden Level ist.
Die Theorie von Scaffolding basiert sowohl auf der soziokonstruktivistischen Theorie des Wissenserwerbs als auch auf der Zone der proximalen Entwicklung nach Vygotsky (vgl. Wild, 2009, S. 94). Unter der Zone der proximalen Entwicklung versteht man dabei den Bereich, welcher zwischen dem liegt, was der/die Lernende ohne Hilfestellung leisten kann und dem, was der/die Lernende unter einer optimalen Unterstützung schaffen kann (vgl. van de Pol, 2010, S. 272).
Zu Beginn des Lernprozesses wird somit durch die Lehrkraft ein „Lerngerüst“ geschaffen, mithilfe dessen die Schüler*innen ihre Kompetenzen aufbauen können. Mit fortschreitendem Lernprozess wird das Gerüst immer weiter abgebaut und den Lernenden mit zunehmenden Können immer mehr Verantwortung für ihren Lernprozess übertragen.
Scaffolding kann jedoch auf verschiedenen Ebenen des Unterrichts stattfinden (vgl. Geldreich, 2019, S. 182). Zum einen kann es sich auf einzelne, kleinere Interaktionen zwischen Schüler*innen und der Lehrkraft beziehen (Mikro-Ebene) wie Tipps oder wie die Lehrkraft auf Fragen reagiert und auf diese eingeht, aber auch welche Fragen die Lehrkraft stellt. Eine weitere Möglichkeit ist Scaffolding auf der Meso-Ebene zu betreiben. Dabei bezieht sich die Unterstützung auf „die Strukturierung von Lernaufgaben in einzelne Arbeitsschritte“ (Geldreich, 2019, S. 182). So können die Arbeitsschritte der Aufgaben sich an die wachsende Kompetenzen der Lernenden anpassen und beispielsweise immer großschrittiger werden, sodass zu Beginn Aufgaben sehr kleinschrittig und geschlossen sind und mit der Zeit immer offener und ohne weitere Hilfestellung formuliert sind. Zuletzt kann Scaffolding auch auf der Makro-Ebene betrieben werden. Hier geht es um die Planung der Unterrichtssequenzen und um die Planung von Lernaufgaben.
In der Informatikdidaktik wurde Scaffolding im Informatikunterricht sowohl von Lee et al. (2011) als auch von Sentance und Waite (2017) untersucht. Hauptaugenmerk des Scaffolding im Informatikunterricht ist dabei die Entwicklung, welche die Schüler*innen auf ihrem Weg zum eigenständigen Programmieren durchlaufen und wie sie dabei unterstützt werden können (vgl. Geldreich, 2019, S. 182).
Use-Modify-Create (Lee et al.).
Das erste Konzept stammt von Lee et al. (2011, S. 35f.) und beschreibt drei Phasen: Use, Modify und Create. Es soll Informatik Lehrkräften dabei helfen, wie sie ihre Schüler*innen beim Erlernen einer Programmiersprache bestmöglich unterstützten können.
In der ersten Phase, der Use-Phase, benutzen die Schüler*innen vorgegeben, fertige Programme. Beispielsweise führen sie gegebene Programme aus, äußern Vermutungen und untersuchen oder analysieren die Programme.
Mit der Zeit fangen sie an, an den gegebenen Programmen Veränderungen vorzunehmen. Dies ist die Modify-Phase. Zu Beginn nehmen die Schüler*innen beispielsweise erst kleinere Veränderungen vor (bspw. Variablenwerte verändern). Mit der Zeit werden diese Veränderungen immer komplexer, sodass die Schüler*innen irgendwann eigenen, ergänzenden Code schreiben, um Programme anzupassen oder zu erweitern. Solche Veränderungen setzten ein Grundverständnis der Schüler*innen für die Abstraktionsprozesse des Programmierens und Algorithmen voraus (vgl. Lee, 2011, S. 35). Durch diese Modifikationen der Programme vertiefen die Schüler*innen ihre Kompetenzen und ihr Verständnis über das Programmieren. Die Programme werden mehr und mehr zu den eigenen Programmen der Schüler*innen und nicht mehr zu Programmen von der Lehrkraft/jemand anderen.
Als letztes erfolgt die Create-Phase. Die Schüler*innen haben nun die benötigen Kompetenzen und das Selbstvertrauen, um selbstständig eigene Programme zu entwickeln. Sie modellieren und implementieren nun eigenen Programm, beispielsweise nach textuellen Vorgaben. Nach dem Erstellen eigener Programme sollte noch ein „iterativer Prozess des Testens, Analysierens und der Weiterentwicklung“ (Geldreich, 2019, S. 182) erfolgen, sodass die Schüler*innen den gesamten Prozess des Programmierens erlernen können.
Während des gesamten Prozesses sollte besonders darauf geachtet werden, dass das Anforderungsniveau der Aufgaben und Lerninhalte stets an das Level der Lernenden angepasst wird, andernfalls ist Langeweile bei den Schüler*innen garantiert. Die Aufgaben sollten zudem ein gewisses Komplexitätsniveau besitzen, sodass die Schüler*innen an ihnen wachsen können. Auch wenn die Aufgaben herausfordernd für die Schüler*innen erscheinen können, sollten sie trotzdem auch als machbar erscheinen, sodass die Schüler*innen nicht abgeschreckt oder verängstigt werden (vgl. Lee, 2011, S. 35), sondern durch anschließende Kompetenzerfahrung bestärkt werden.
Nach Lee (2011, S. 35f.) ist jedoch zu beachten, dass es keine klare Trennung zwischen der Modify und der Create Phase gibt. Es kann beispielsweise sein, dass die Schüler*innen zwischen den beiden Phasen hin und her wechseln.
PRIMM (Sentance und Waite).
Eine Weiterentwicklung des Use-Modify-Create Ansatzes stammt von Sentance und Waite (2017). Das Konzept bezieht sich auf das Erlernen einer textbasierten Programmiersprache und versucht, Probleme, Schwierigkeiten und Frustration auf Seiten der Schüler*innen zu vermeiden (vgl. Sentance, 2017, S. 113).
PRIMM steht dabei für Predict, Run, Investigate, Modify und Make. Zuerst äußern die Schüler*innen Vermutungen darüber, was ein gegebenes Programm tut (Predict). Anschließend führen sie das gegebene Programm aus (Run) um ihre Vermutungen zu überprüfen. Im nächsten Schritt untersuchen die Schüler*innen Programme (Investigate), Dazu kann beispielsweise das Analysieren, Erklären, Kommentieren, Debuggen oder das schrittweise Nachvollziehen von Programmen gehören. Darauf folgt, wie bei Use-Modify-Create, eine Phase des Modifizierens (Modify), in dem die Schüler*innen Programme verändern oder um Funktionalitäten ergänzen. Auch hier erfolgt als letztes eine Phase, in dem die Schüler*innen schließlich eigene Programme erstellen (Make) (vgl. Sentance, 2017, S. 113). Der PRIMM Ansatz verfeinert somit die Use-Phase des UMC Ansatzes und unterteilt sie in Predict, Run und Investigate. Die Modify Phase ist in beiden Konzepten gleich, die Make Phase in PRIMM entspricht der Create Phase des UMC Ansatzes.
Hauptaugenmerk des PRIMM Ansatzes ist, dass die Schüler*innen zuerst mit kleinen und kleinschrittigen Aufgaben arbeiten, in denen sie Code lesen und Zeile für Zeile nachvollziehen, bevor sie eigenen Code schreiben (vgl. Sentance, 2017, S. 114).
Beispiel nach Geldreich (2019)
Use (mit vorgegebenen Programmen arbeiten):
Programme nachbauen.
Die Schülerinnen bauen zuerst komplett vorgegebene Programme in Scratch nach und führen diese aus. Ziel ist es, die Bedienung von Scratch und die Handhabung der Programmierblöcke kennen zu lernen.
Blöcke erkunden.
Die Schüler*innen öffnen ein bestehendes Scratch-Projekt und führen es aus. Anschließend sollen sie notieren, welche Funktionen die einzelnen Blöcke haben. Besonders für die Einführung von unbekannten/neuen Blöcken oder Erweiterungen sind solche Aufgaben gut geeignet.
Programme lesen.
Die Schüler*innen lesen zuerst ein vorgegebenes Programm auf einem Aufgabenblatt. Anschließend sollen sie beschreiben, was z.B. bei verschiedenen Mauszeiger-Positionen auf dem Bühnenbild passiert oder wenn verschiedenen Tasten gedrückt werden. Abschließend können sie ihre Vermutungen durch Ausführen des Programmes überprüfen.
Programme lesen und Fehler finden.
Die Schüler*innen überprüfen ein gegebenes Programm auf Fehler und kennzeichnen diese.
Programme testen.
Die Schüler*innen testen, ob ein Programm die gewünschte Funktionalität(en) erfüllt. Sie überprüfen beispielsweise, ob bei verschiedenen Eingaben die gewünschten Ergebnisse ausgegeben werden/die gewünschten Ereignisse ausgeführt werden.
Modify (Programme verändern, anpassen und erweitern):
Programme debuggen.
Die Schüler*innen bekommen ein Programm, welches nicht die gewünschte Funktionalität erfüllt. Sie sollen analysieren, wo der Fehler liegt und anschließend das Programm modifizieren und so die Fehler beheben. Für diese Aufgabe müssen die Schüler*innen den Ablauf des Programmes genau nachvollziehen.
Programm erweitern.
Die Schüler*innen erhalten Teile eines Programmes und sollen es nun um weitere Funktionen erweitern. Z.B. bewegt sich eine Figur mithilfe der rechten und linke Pfeiltasten nach rechts oder links. Das Programm soll nurn so erweitert werden, dass auch mit den Pfeiltasten nach oben oder unten die Figur gesteuert werden kann, sodass die Figur auch nach oben oder unten bewegt werden kann.
Programme optimieren.
Die Schüler*innen untersuchen ein fertiges Programm mithilfe von verschiedenen Fallunterscheidungen. Anschließend sollen sie das Programm so optimieren, dass in allen Situationen/Fallunterscheidungen die gewünschte Funktionalität des Programmes erfüllt wird.
Szenario in Scratch anpassen.
Die Schüler*innen sollen für ein vorgegebenes Programm das Bühnenbild anpassen/verändern, sodass das Programm die gewünschte Funktionalität erfüllt.
Create: (Programme eigenständig erstellen)
Programmieren nach einer bildlichen Vorgabe.
Die Schüler*innen sollen eine vorgegebene Bildgeschichte in Scratch nachprogrammieren. Dabei kann variiert werden, ob die Schüler*innen zusätzlich zu der Programmierung der Figur auch z.B. das Bühnenbild selbst gestalten sollen oder eine Vorlage gegeben bekommen.
Programmieren nach einer textlichen Vorgabe.
Die Schüler*innen erhalten eine textliche Vorgabe und schreiben ein entsprechendes Programm, welches die Vorgaben erfüllt. Dabei kann variiert werden, wie detailliert die textliche Vorgabe angibt, was genau programmiert werden soll.
Programmieren von eigenen Ideen nach textlichen Vorlagen.
Auch wenn man den Schüler*innen vorgibt, was sie programmieren sollen, können die Aufgaben so gestaltet werden, dass die Schüler*innen trotzdem ihre eigenen Ideen umsetzten können/müssen.