Kinderen basisconcepten van het programmeren leren. Dat kan in mijn ogen beter met Scratch dan met de micro:bit. Die stelling poneerde ik op Twitter als reactie op een vraag over micro:bit-lesmateriaal van Hylke Faber, docent digitale vaardigheden aan de Hanze Hogeschool. "Nu ben ik wel benieuwd waarom?", was zijn terecht vraag. In deze blog probeer ik daar een antwoord op te geven.
Geschreven door: Martine Segers
Als je kinderen uit groep 5, 6, 7 of 8 van de basisschool wilt leren programmeren, is het allereerst de vraag wat je wil bereiken. Zelf wil ik graag dat kinderen in mijn lessen zicht krijgen op wat programmeren überhaupt is en wat je er mee kunt. Ik wil ze laten kennismaken met een aantal abstracte programmeerconcepten en hen helpen om die stapje voor stapje steeds beter te begrijpen. En daarbij ook laten zien dat je veel kunt leren van je fouten; je ziet immers onmiddellijk dat er iets niet klopt als je je programma runt en er gebeurt niet wat je verwacht had.
Daarnaast wil ik kinderen graag laten ervaren dat je als programmeur zelf aan het stuur zit en je eigen creaties tot leven kunt brengen met code. Ik laat leerlingen zien dat je projectideeën van anderen naar je eigen smaak kunt aanpassen (remixen heet dat in Scratch) en daag hen uit om ook hun eigen ideeën te verzinnen en uit te werken.
"In MakeCode moet je snel variabelen
op een abstracte manier inzetten"
Ik heb zowel lesmateriaal voor Scratch gemaakt als voor de micro:bit en deze lessen zowel in een schoolse omgeving als in naschoolse workshops gebruikt. Met de micro:bit kun je geweldige dingen doen. Zo heb ik flipperkastjes, zwaardgevechtspellen en robotjes met kinderen gemaakt. Echt superleuk. Ook een eigen lichtshow maken met drie ledjes en een animatie maken op het display vinden veel kinderen leuk, evenals het uitproberen van de radio-functie van de micro:bit.
Via de micro:bit leren kinderen meer over het aansturen van ledjes en motortjes en het uitlezen van sensoren. Leuk en leerzaam. Ze kunnen ook met eigen ontwerpen aan de slag. Zo heb ik een keer drie meiden uit groep 8 begeleid bij het maken van een houten voetbalspel waarbij de micro:bit de score bijhield. Ook bedachten twee leerlingen zelf dat ze een knikkerspel wilden maken.
Maar als je de JavaScript Block Editor voor de micro:bit van MakeCode wilt gebruiken om basisschoolkinderen stap voor stap programmeerconcepten aan te leren, dan loop je naar mijn mening snel tegen lastigheden aan waar je in Scratch niet tegen aan loopt.
Laag instapniveau, hoog plafond
Je hebt snel variabelen nodig die je op een abstracte manier moet gebruiken. Een variabele gebruiken om een score bij te houden is voor kinderen prima te begrijpen. Een variabele gebruiken om de computer te laten beslissen of bepaalde stukken script wel of niet uitgevoerd moeten worden, daarentegen, is een erg abstract concept voor beginners. Verderop in deze blog geef ik daar een aantal voorbeelden van.
Hieronder vind je eerst een overzicht van manieren waarop Scratch abstract gebruik van variabelen door beginners weet te omzeilen, overigens zonder opties te blokkeren voor meer gevorderde programmeurs. De makers van Scratch hebben bewust gekozen voor een laag instapniveau en een hoog plafond. En tot hun eigen verbazing blijken er projecten met Scratch mogelijk die vele malen complexer zijn qua code dan de bedenkers van Scratch destijds voor mogelijk hadden gehouden.
Overzicht Scratch-blokken en opties die het leven van een jonge, beginnende programmeur makkelijker maken
- Het blok met de volgende drie keuzemogelijkheden die het uitlezen van alle of delen van de code stopt: "stop alle / stop dit script / stop andere scripts in sprite"
- De signaalblokken: "zend signaal ..." en "wanneer ik signaal ... ontvang"
- Het blok "wacht tot ..."
- De optie om meerdere keren het blok "wanneer op de groene vlag wordt geklikt" te gebruiken in één project, waarna de computer de code min of meer gelijktijdig begint uit te voeren.
- De ingebouwde variabelen die al een logische naam hebben, zoals "grootte", "uiterlijk nummer" en de handige combinatie van een blok waar je een vraag mee kunt stellen en een ingebouwde variabele die automatisch het antwoord bewaart dat de speler geeft.
Bovenstaande blokken en opties maken het programmeren allemaal net wat minder abstract. En hierdoor kun je abstracte programmeerconcepten makkelijker stap voor stap aanleren aan kinderen. Ook met nog weinig begrip van allerlei programmeerconcepten kunnen ze in Scratch toch al leuke projecten maken die hen motiveren om verder te gaan en ook zelf dingen uit te gaan proberen. De remix-optie en het bekijken van andermans code helpen daar ook bij.
Slapende micro:bit
Hierbij een voorbeeld van een slapende micro:bit, bedacht door een jongen van een jaar of 11 in een van mijn workshops in de openbare bibliotheek. De linker versie gemaakt met MakeCode werkt niet zoals hij het wilde. Het boze gezichtje komt namelijk maar heel kort in beeld als je de "slapende micro:bit wakker schudt".
In Scratch is dit makkelijk op te lossen door het blok "stop andere scripts in sprite" te gebruiken. Zie code hier rechtsboven. Met deze code stopt het slapen (animatie met afwisselend een kleine en een grote Z) en blijft het gezichtje op de micro:bit boos kijken. Hier kun je vervolgens weer makkelijk code onder hangen, door bijvoorbeeld met twee extra codeblokken de computer de opdracht te geven om tien seconden te wachten en daarna weer een vrolijk gezichtje te tonen op de micro:bit.
Met de code hieronder links kun je het probleem een beetje verhelpen. Het boze gezicht is iets langer te zien. Maar het is niet leerzaam om het zo op te moeten lossen in mijn ogen en je hebt eigenlijk nog veel meer blokken met een boos gezichtje nodig.
De echte oplossing, met hetzelfde resultaat als de Scratch-code (zie hier rechtsonder), is naar mijn mening veel te abstract voor een kind dat voor het eerst kennismaakt met programmeren.
Het feit dat je geen tekst en dus geen "ja" en "nee" kan typen als waarden van de variabelen, maakt het bovendien nog extra abstract. In bovenstaand voorbeeld zou je in Scratch achter "slapen" "ja" kunnen schrijven als tekst, wat voor kinderen net iets minder abstract is als "1" voor waar en "0" voor niet waar.
Tijdslimiet
Ander voorbeeld: een tijdslimiet bij een spel. In Scratch kun je kinderen het blok "wacht 60 seconden" laten gebruiken en daarna "stop alle" (zie code hier rechtsonder) als het om een spel gaat met een herhaal-lus in de code. In MakeCode heb je voor een tijdslimiet in zo'n geval opnieuw een abstract gebruik van een variabele nodig (zie code hier linksonder).
Als leerlingen meer ervaring krijgen met programmeren, kun je programma's stap voor stap complexer maken door voor de alternatieven "stop dit script" en "stop andere scripts in sprite" te kiezen, vaak in combinatie met signalen. De computer code in een specifieke volgorde laten uitvoeren, afhankelijk van user input, wordt naar mijn mening flink makkelijker door de mogelijkheid om signalen te gebruiken.
Worden projecten complexer, dan krijg je met het gebruik van veel signalen een programma dat moeilijk meer is te overzien. Dan kan het handig zijn om toestanden van het programma via variabelen te definiëren. Er zullen echter weinig kinderen zijn die op de basisschool dit niveau bereiken. Dat kan alleen als een kind heel goed abstract kan denken voor zijn of haar leeftijd en veel tijd krijgt/neemt om te leren programmeren.
Wacht tot...
De stelling van dit artikel is gebaseerd op mijn eigen praktijkervaring. Nog een voorbeeld. Bij het micro:bit-knikkerspel dat je hier rechtsonder ziet, was ook een complexere micro:bit-code nodig dan ik van te voren verwacht had. In dit spel krijgt de speler in de verschillende bakjes een verschillend aantal punten. Er moeten echter maar één keer punten bijkomen als de bal in het bakje komt en daar de stroomkring tussen de GND-pin en pin 1 sluit.
Daarom moet de code "wachten" tot pin 1 niet meer wordt ingedrukt. Dit is het moment dat je de bal (een kraal met koperfolie eromheen) uit het bakje haalt. In Scratch is er een "wacht tot"-blok dat in MakeCode ontbreekt. Daar moet je zelf coderen dat je code elke 50 milliseconden moet controleren of pin 1 nog steeds ingedrukt is oftewel of de stroomkring tussen pin 1 en de GND-pin nog steeds gesloten is doordat de bal nog in het bakje ligt.
Robotjes
Bij het programmeren van micro:bit-robotjes, gemaakt met het all-in-one-robotics board van Kitronik, werd het programmeren met MakeCode ook veel ingewikkelder dan ik gewend was van mBlock, een op Scratch gebaseerde programmeertaal om de educatieve robot mBot te programmeren. De micro:bit-robotjes die ik met kinderen gemaakt heb kunnen niet alleen rijden, maar hebben ook bewegende delen bovenop de robot, bijvoorbeeld vleugels die op en neer bewegen.
Doordat MakeCode geen twee stapels met codeblokken vanzelf (voor de kind-programmeur onzichtbaar) uitvoert, is een abstract stukje code nodig waarmee de "hoofdcode" blijft checken of er een radio-signaal binnenkomt. Zie de code hieronder. Zonder deze code was de robot onbestuurbaar tijdens het bewegen van de vleugels.
Heeft Scratch dan geen nadelen?
Jazeker. Grootste nadeel vind ik dat kinderen het coördinatenstelsel met een x- en y-as moeten leren begrijpen en al heel snel negatieve getallen nodig hebben die ze bij rekenen meestal niet leren in groep 5, 6 en 7. Ook allebei best abstract.
Ook het verschuiven van een tekening in het tekenprogramma kan tot verwarring leiden, omdat daardoor het draaipunt van de zogenoemde sprite verandert en de sprite ook op andere x- en y-coördinaten kan lijken te staan dan je verwacht. Verder is het "raak ik ... kleur"-blok een krachtig blok, maar tegelijkertijd kan een klein, onzichtbaar stipje van die kleur dat een kind per ongeluk ergens neer heeft gezet, je hele programma in de soep laten lopen.
En voor sommige kinderen biedt Scratch eigenlijk net wat veel vrijheid. Het kan leuk zijn om allerlei blokken gewoon eens uit te proberen en gekke dingen te maken in het tekenprogramma. Maar soms is gekke tekeningen maken alleen maar een uitvlucht als een kind de opdracht niet helemaal begrijpt.
Verder leren kinderen in het begin veel tegelijk, zeker als ze nog niet eerder met een digitaal tekenprogramma hebben gewerkt. Dat kan tot veel vragen leiden. In een klas met 25 kinderen kan dat lastig zijn. Ik werk zelf vooral met kleine groepjes en vermoed dat ik bij lessen aan een hele klas meer tijd zou moeten nemen om wat basisvaardigheden van het werken met editor en tekenprogramma aan te leren bij de kinderen.
Als je slechts tijd hebt om kinderen een paar middagen programmeerles te geven, zou ik voor de micro:bit kiezen. Daar kun je snel wat leuke dingen mee doen, waarmee je leerlingen laagdrempelig een indruk kan geven van wat er mogelijk is met programmeren. Wil je echter een langere serie lessen verzorgen waarin flink wat basisconcepten van het programmeren aan bod komen, van herhaling en voorwaarden tot aan variabelen en lijsten, dan zou ik persoonlijk voor Scratch kiezen.
Opzet van mijn eigen Scratch-lessenserie
Tot slot een korte schets van mijn eigen aanpak. Ik heb zelf een serie van zes lessen van anderhalf uur gemaakt waar ik in principe altijd mee begin. Ik begin met een les met veel voorbeeldprojecten en uitleg over wat programmeren überhaupt is, daarna maken we Vader Jacob in canon, vervolgens een kunstproject, het spel Snake, een animatie, en een quiz. Wat ik daarna ga doen, hangt af van de leeftijd, het niveau en de interesse van de kinderen.
Via mijn Vader Jacob-les leren kinderen bijvoorbeeld over toetsenbord-input (ze koppelen een aantal muzieknoten aan letters op het toetsenbord), over het van boven naar beneden lezen van code, over herhaling en over signalen, tijdens de kunstles leren ze onder andere over de x- en y-coördinaten en bij het maken van de quiz komt het codeblok "als .... dan / anders", oftewel het if...else statement, nadrukkelijk aan bod.
Ik geef leerlingen in de eerste lessen vooral code die ze grotendeels namaken, maar wel met wat witte vlekken en enkele blokken die ze zelf op de goede plek er tussen moeten "schuiven". Zo krijgen ze een idee wat er mogelijk is, maar volgen ze niet klakkeloos een recept. Ze moeten wel ook zelf nadenken.
Daarna krijgen ze een deel van de code nog steeds met witte vlekken en moeten ze voor een deel van de code losse blokjes in elkaar puzzelen. En dan schakel ik terug naar een veel eenvoudiger project waarbij ze zelf de code maken. Bij nieuwe concepten probeer ik steeds deze "fases" min of meer opnieuw te gebruiken.
Wat in mijn ogen verder goed werkt, is om kinderen relatief eenvoudige Scratch-projecten te laten zien (alleen het speelveld en wat daar gebeurt en niet de code) en ze met elkaar te laten brainstormen welke codeblokken gebruikt zijn. Ik vraag ze dan min of meer om een project uit elkaar te rafelen in kleine opdrachten die de programmeur aan de computer geeft om onderdelen van het project uit te voeren.
Wil je reageren op deze blog? Leuk! Staat er iets in mijn tekst dat niet klopt? Dan hoor ik het graag. Je kunt mij een mailtje sturen via PinkyPepper.scratch apenstaartje gmail.com of reageren via Twitter @PinkyPepper_.
