Computationeel denken is niet hetzelfde als programmeren.
Programmeren illustreert het computationeel denken. Het leidt tot concrete, toonbare resultaten. Programmeren biedt aanmoediging voor creativiteit, logisch denken, nauwkeurig werken en probleemoplossende vaardigheden en ondersteunt de persoonsgebonden ontwikkeling van leerlingen.
Programmeren is het ontwerpen en schrijven van een reeks instructies (een programma) voor een computer en dit in een voor de computer begrijpbare taal. Programmeren kan heel eenvoudig zijn, zoals een programma om een robot een lijn te laten volgen, maar ook ongelooflijk ingewikkeld en complex – denk maar aan de software waarmee het weer wordt voorspeld of waarmee zoekresultaten in Google worden weergegeven.
Om bijvoorbeeld een computer te programmeren, moet je code of een programma schrijven. Dit is precies de reeks instructies die de computer moet uitvoeren, geschreven in een programmeertaal die de computer begrijpt. Een computerprogramma bestaat uit tegelijk nauwkeurige en ondubbelzinnige instructies, er is dus geen plaats voor interpretatie van een programmaregel.
De wereld van vandaag is doordrongen van technologie. Bijna iedereen heeft een smartphone en we gebruiken dagdagelijks een computer. Toch betekent dit niet dat we ook allemaal weten hoe deze technische snufjes precies werken, ookal zijn we er erg handig mee. Een dieper begrip van de technologie erachter, biedt inzicht in de digitale wereld waarin we leven. Zeer waarschijnlijk zal de aanwezigheid van de technologie rondom ons, en onze afhankelijkheid ervan, alleen maar toenemen. Daarom is het belangrijk dat leerlingen vertrouwd geraken met de bestaande systemen.
Er is keuze te over aan programmeertalen. De meerderheid ervan is echter te ingewikkeld als je slechts de basisbeginselen van programmeren wilt aanleren. Maar er zijn ook een aantal eenvoudige, goed ondersteunde talen die zich prima lenen voor gebruik in de (basis)school. Kies daarom voor een programmeertaal die je zélf gemakkelijk onder de knie krijgt – of beter – die je reeds kent. Houd verder rekening met deze criteria:
Tijdens een rollenspel ontdekken jouw leerlingen hoe programmeerbare apparaten werken - denk aan een smartphone, een radiowekker ... Je laat zien dat je deze apparaten kan programmeren. Je kunt een smartphone programmeren om bijvoorbeeld om 7.30 uur een alarm te geven als je op dat uur gewekt wil worden. Je kunt een klok programmeren die aftelt hoeveel tijd de leerlingen nog hebben om aan een taak te werken.
Dit proces kun je ook debuggen, door te controleren waarom de klok op een ingesteld uur toch geen alarm gaf.
Je leerlingen kunnen explorerend omgaan met programmeerbaar speelgoed zoals Bee-Bot. Ze leren waarvoor de verschillende knoppen dienen en in welke volgorde ze moeten worden ingedrukt. In feite zijn je leerlingen nu al aan het programmeren!
Ook leuk: je leerlingen kunnen instructies geven aan een klasgenootje, die ze vervolgens uitvoert. Zo programmeren ze als het ware een levende robot.
Voorbeeld: Programmeer eens een mens.
De leerlingen begrijpen hoe eenvoudige algoritmen worden uitgevoerd zoals programma's op digitale apparaten als laptops, tablet-pc's, programmeerbaar speelgoed. Geef je leerlingen de mogelijkheid om eigen programma's te ontwerpen en te debuggen en om te voorspellen wat de uitkomst van een welbepaalde programma zal zijn. Programma's als Scratch en ScratchJr zijn hiervoor uiterst geschikt.
Ook Bee-Bot en de Ozobot leent zich hiervoor. De leerlingen ontwerpen een eenvoudig programma waarmee een programmeerbaar speelgoedje wordt aangestuurd, of een figuurtje op een computerscherm (zoals ScratchJr). Terwijl ze de route plannen, werken je leerlingen de verschillende stappen van het algoritme uit. Met deze stappen programmeren ze vervolgens het speelgoedje of het schermfiguurtje.
Voorbeeld: Programmeren met avontuur en zonder computer
Voorbeeld: Programmeer eens een mens
Leerlingen leren programma's ontwerpen en schrijven om bijvoorbeeld een robot te programmeren. Leerlingen leren gebruik maken van onder andere keuze en herhaling in hun programma's, alsook van variabelen om gegevens in op te slaan. Ze leren ook om fouten in hun programma's te vinden en deze te corrigeren.
Enkele voorbeelden:
Sommige algoritmes zijn gebaseerd op een lijst van opeenvolgende instructies. Onderstaande afbeelding toont hoe je het klaarmaken van een boterham met confituur en kaas kan opdelen in verschillende opeenvolgende taken.
Programma's zijn opgebouwd uit een reeks van instructies. Wanneer leerlingen een Bee-Bot programmeren om een bepaalde weg af te leggen, dan duiden ze aan welke acties de Bee-Bot chronologisch moet uitvoeren door op knoppen te duwen. Hun programma bestaat dus uit een reeks van instructies. Zoals bij alle programma's zijn deze instructies ondubbelzinnig. De Bee-Bot zal elke opeenvolgende instructie uitvoeren afhankelijk van welke knop in een volgorde werd ingedrukt.
Ook de eerste Scratch-programma's bestaan doorgaans uit een eenvoudige reeks instructies. Ook daar moeten de instructies ondubbelzinnig zijn en is de volgorde belangrijk. Leerlingen moeten dus goed nadenken over in welke volgorde ze de verschillende stappen van hun algoritmes moeten uitvoeren om de taak tot een goed einde te brengen.
In sommige algoritmes - zoals bijvoorbeeld het recept om een cake te bakken - zal de volgorde waarin de stappen uitgevoerd worden, cruciaal zijn. Een cake-bak-algoritme dat eerst zou vragen om eieren toe te voegen en pas daarna om de eieren te breken en de schaal weg te gooien, zal bijvoorbeeld niet bijzonder effectief zijn om die taak te volbrengen. Al zullen er ook stappen in een algoritme voorkomen waarvan de volgorde minder uitmaakt. Het moment waarop je de bakvorm gaat invetten, doet er bijvoorbeeld weinig toe, zolang je het maar doet vóór je het cakebeslag in de vorm giet.
De uitvoer van een programma zal niet enkel afhangen van de commando’s, maar ook van hoe ze geordend zijn. Het belang daarvan wordt geïllustreerd in de uitvoer van onderstaand Scratch-programma, waarin twee commando’s van plaats verwisseld zijn.
Wanneer leerlingen leren tellen, dan moeten ze de volgorde van de cijfers binnen de getallenreeks leren. Als kinderen een toneeltje of dialoogje naspelen, is de volgorde van hun acties belangrijk. Ze leren er niet alleen hun acties ordenen, maar ook om de volgorde ervan af te stemmen op de acties van de andere leerlingen. Leerlingen leren ook de volgorde van de dagen in de week en maanden in het jaar kennen.
Voorbeeld: Help, er zit een Bee in de klas.
Leerlingen krijgen de gelegenheid om programma's te maken in een programmeertaal als Scratch waarbij een correcte volgorde van de commando's van fundamenteel belang is. Leerlingen maken bijvoorbeeld een animatie in Scratch waarbij twee personages een gesprek voeren met elkaar. Daarbij is het natuurlijk cruciaal dat de volgorde van de conversatie juist zit. Naarmate leerlingen progressie maken, zal de code van hun programma's steeds langer en complexer worden.
Met keuze bedoelen we het mechanisme in een programma waarmee een computer één of meerdere reeksen instructies uitvoert en dit naargelang aan een bepaalde voorwaarde is voldaan, of niet.
In Scratch (maar ook in andere programmeertalen) kun je keuzes inbouwen in een reeks van opeenvolgende instructies. Zo laat je de computer verschillende instructies uitvoeren naarmate aan bepaalde voorwaarden is voldaan, of niet. In educatieve games zit meestal een eenvoudig keuzemechanisme verwerkt: als het antwoord juist is, krijg je een beloning; is het fout, dan krijg je niets.
Je kan verschillende keuzes ook met elkaar zijn verbinden. Hierdoor kunnen meer complexe voorwaarden worden opgesteld om te bepalen hoe een programma wordt uitgevoerd. In het onderstaande klokprogramma (in Scratch) zie je hoe sommige 'als'-blokjes in andere 'als'-blokjes zitten vervat. Merk op dat dit programma eveneens gebruik maakt van herhaling, en van variabelen (drie) voor de seconden, minuten en uren.
Dankzij keuzes kun je programma's in een interactieve vorm schrijven. Programma's kunnen met invoergegevens rekening houden. Op die manier kunnen we een andere uitvoering krijgen telkens deze programma's opnieuw worden gestart. Met keuzes kunnen we dus programma's schrijven die verschillende acties uitvoeren naargelang een gebruiker 'ja', dan wel 'nee' kiest (of andere invoergegevens).
Met sommige programma's worden fysieke systemen gecontroleerd. Voorbeelden zijn automatische deuren in een winkel of een inbraakalarm. Bij elk van deze voorbeelden is keuze cruciaal om het programma te laten functioneren. Een schuifdeur gaat alleen open als de sensor erboven een beweging ziet, zoniet gaat of blijft ze dicht. Een inbraakalarm activeert een sirene wanneer er beweging wordt gedetecteerd.
Jonge kinderen maken, zonder dat ze het beseffen, al geregeld gebruik van keuze. Bijvoorbeeld als ze tegen een klasgenootje zeggen dat ze de juf of meester zullen inlichten als hij een stuk speelgoed niet teruggeeft. Ze maken ook keuzes tijdens rollenspellen, waarbij ze soms al kunnen uitleggen waarom ze deze keuze maken.
Ook in deze leeftijdsgroep zijn de mogelijkheden om keuze aan te leren nog eerder beperkt. Bij het programmeren ligt de focus grotendeels op het begrijpen van sequenties van instructies. Toch kun je de leerlingen al kennis laten maken met keuzes via grafische programmeerapps zoals ScratchJr.
Geef je leerlingen de kans om programma's te ontwerpen, te schrijven en te debuggen waarbij ze keuzes inbouwen om een specifieke uitkomst te verkrijgen. Dit kan bijvoorbeeld in Kodu en Scratch. Vooraleer de leerlingen beginnen te programmeren, maak je ze best eerst vertrouwd met verschillende keuzemechanismen en hoe deze te gebruiken. Tijdens het programmeren moeten de leerlingen ook goed weten waar ze keuze in hun algoritmen kunnen toepassen en in welke vorm ze dat het beste doen. Hieronder vind je enkele voorbeelden van keuzes in Scratch.
Keuze is een belangrijk onderdeel van games, zeker als die geschreven zijn in Kodu. Het gedrag van een object in zo’n game wordt bepaald door een aantal voorwaarden. Bijvoorbeeld: ‘Als je op de linker pijltjestoets drukt, schuift het object op naar links’. Op een vergelijkbare manier worden interacties met andere objecten, variabelen en omgevingen geprogrammeerd, meestal in de vorm van ‘als/dan’-voorwaarden. Bijvoorbeeld: ‘Als ik tegen de appel bots, dan eet ik hem op én krijg ik twee punten.’
Een variabele wordt gebruikt om een stukje informatie in het computergeheugen op te slaan en later terug op te halen, dit terwijl een programma aan het draaien is. Het is in feite een plaats in het geheugen die je een naam geeft en waarin je een waarde (informatie) bewaart. Programma’s kunnen deze informatie (de waarde) oproepen, veranderen en weer opslaan. Deze waarde kan een gebruikersnaam zijn, de naam van een product in het winkelmandje van een webshop, een score in een computerspel … Een variabele is maar één voorbeeld van een datastructuur. In het secundair onderwijs leren leerlingen ook over andere structuren, zoals rijen. Een rij kan meerdere waarden bevatten, zoals een lijst van dierennamen of van adressen.
De waarde van
een variabele kan een getal zijn, een stukje tekst of een juist/fout-indicator.
Naam variabele
Type variabele
Voorbeelden van waarde
Punten
Numeriek
10
Antwoord
Tekst
IJsland
Lichtschakelaar
Waar/Onwaar
Waar (=aan)
Terwijl het programma loopt, kunnen we de waarde van de variabelen veranderen. Bijvoorbeeld:
Onthoud goed dat er op elk moment maar één waarde in de doos kan zitten.
Tijdens het schrijven van een programma is het belangrijk om betekenisvolle namen voor de variabelen te verzinnen. Ondubbelzinnige en duidelijke namen maken een stukje programmeercode gemakkelijker om te lezen en te begrijpen – niet alleen voor de programmeur zélf, maar voor iedereen die ermee aan de slag gaat. Bij programma’s met slecht gekozen namen voor de variabelen zal het debuggen (foutopsporing) heel lastig zijn, omdat het doel van de programmeercode niet helemaal duidelijk is.
Als een variabele nog niet bestaat in een computerprogramma, moet een programmeur hem aanmaken. Hij doet dit op zo'n manier dat de programmeertaal alle nodige informatie heeft om de variabele te gebruiken. Je kunt dit vergelijken met het labelen van de kartonnen doos.
Het proces waarbij variabelen worden aangemaakt, wordt soms ook het declareren van de variabelen genoemd. In Scratch verzin je hiervoor gewoon een naam en beslis je waar je hem allemaal wilt gebruiken. In sommige programmeertalen moet je ook direct een type geven aan de variabele bij de declaratie.
Het programma geeft geen foutmelding als je vergeet om een beginwaarde toe te kennen aan een nieuw gecreëerde variabele. Let er dus goed op dat je dit doet bij de maken van het programma. Dit wordt het initialiseren van de variabele genoemd. Als je dit vergeet en het programma uitvoert, weet je niet wat de waarde van de variabele is. Deze waarde is afhankelijk van de programmeertaal. Het kan zijn dat de variabele geen waarde heeft of een vaste beginwaarde of de waarde die hij had op het einde van de vorige keer dat het programma draaide …
Terwijl het programma loopt, kun je de waarden van de variabelen aanpassen. Nieuwe waarden worden berekend en toegekend aan een variabele. Onthoud: slechts één waarde kan aan een variabele worden toegekend.
Tijdens het debuggen kan het handig zijn om de inhoud van de variabelen weer te geven. Dit helpt je te begrijpen wat er allemaal gebeurt in een programma.
Variabelen vormen een van de fundamenten van het programmeren. Zonder variabelen en andere datastructuren zou informatie niet kunnen opgeslagen of gewijzigd worden. Variabelen houden informatie vast van zodra deze is ingegeven, ze onthouden tijdelijke waarden zoals tussenstappen in berekeningen en ze zorgen ervoor dat waarden op het scherm kunnen worden weergegeven of naar een ander systeem kunnen worden gestuurd.
Om te achterhalen welke variabelen een systeem nodig heeft, maken programmeurs gebruik van een reeks computationele denkvaardigheden. Bovendien letten ze er goed op dat ze hun variabelen betekenisvolle en duidelijke namen geven. Als leerlingen leren welke variabelen ze nodig hebben in een programma, maken ze gebruik van dezelfde computationele vaardigheden als die softwareontwikkelaars gebruiken bij het ontwerp van échte systemen.
In de basisschool werken we niet met variabelen.
Leerlingen moeten de kans krijgen om met programma’s te werken die gebruik maken van variabelen, om zélf variabelen in hun code in te bouwen en om te ontdekken welke variabelen ze precies nodig hebben in hun programma’s.
De beste manier om je leerlingen vertrouwd te maken met variabelen, is door ze eerst wat bestaande programma’s te laten exploreren die gebruik maken van variabelen. Zo zien ze wat de variabelen precies doen. Je doet dit bijvoorbeeld met een game waarin een score wordt bijgehouden. Je laat je leerlingen vervolgens ontdekken wat er gebeurt als ze de manier waarop de score wordt bijgehouden, aanpassen. De ervaring die ze hier opdoen kunnen ze gebruiken om zélf een score toe te voegen aan een programma dat ze hebben ontworpen. En ze kunnen natuurlijk nieuwe variabelen bedenken en deze vervolgens ook toevoegen.
In Kodu worden variabelen soms gebruikt om beloningen bij te houden, zoals een score of puntentelling. Of om een grens in te stellen, zoals een tijdslimiet of een drempelwaarde voor het aantal levens waarover een speler in een game nog beschikt. Als de waarde van een variabele zo'n grenswaarde bereikt of overschrijdt, kan het programma een specifieke actie uitvoeren. Helaas kun je in Kodu niet je eigen variabelen maken.
Als je leerlingen met variabelen werken, raken ze vanzelf wegwijs in het brede scala aan mogelijkheden waarvoor ze variabelen kunnen gebruiken. Ze leren bijvoorbeeld nadenken over welke variabelen ze kunnen gebruiken in toekomstige projecten, of ze leren al in de ontwerpfase van hun programma welke variabalen ze later nodig zullen hebben.
Het is zeer belangrijk dat leerlingen het belang inzien van betekenisvolle en duidelijke namen van variabelen. Je stimuleert dit door te tonen hoe een duidelijke naam iets kan vertellen over de functie of het doel van een variabele. Toch kan het nuttig zijn je leerlingen ook te laten werken met variabelen met onzorgvuldig gekozen namen. Ze zullen een duidelijke en ondubbelzinnige naamgeving hierdoor nog meer appreciëren. Ze zullen ook merken hoe moeilijk het is als een programma variabelen bevat met onduidelijke namen.
Tijdens het debuggen van programmeercode ontdekken leerlingen pas écht wat een verschil een duidelijke naamgeving kan maken. Als je bijvoorbeeld kijkt naar deze twee versies van hetzelfde programma, welke vinden je leerlingen dan het gemakkelijkst om te begrijpen?
Je plant ook best activiteiten waarin leerlingen het belang leren inzien van het declareren en toewijzen van de beginwaarden (initialiseren) van variabelen bij de start van een programma. Mogelijk is het geen slecht idee als je ze dit belang aan den lijve leert ondervinden, door ze niet te vertellen dat ze de beginwaarden van hun variabelen moeten opgeven. Sowieso zullen verschillende van je leerlingen dit vergeten. Nadien kun je nog altijd een klein schema maken waarin je uitlegt hoe een programma start, met de nadruk op het instellen van de beginwaarden.
Opmerking: de variabele als kartonnen doos. Het idee dat je een variabele kunt zien als een kartonnen doos, is een handige analogie om je leerlingen vertrouwd te maken met hoe variabelen werken. Toch moet je oppassen dat ze de analogie niet te ver doortrekken, en dat ze geen verkeerd idee krijgen over wat variabelen precies zijn. Variabelen bestaan immers niet in de fysieke realiteit, het zijn imaginaire hulpmiddelen om te helpen visualiseren hoe een computer waarden opslaat
Als ze leren over het opvragen van een waarde van een variabele, kunnen je leerlingen denken dat de doos na het opvragen leeg is. Dit is echter niet hoe variabelen werken. Het opvragen van de waarde van een variabele is niet hetzelfde als deze wegnemen: je hebt alleen maar de waarde 'vastgesteld'. Eigenlijk kijk je dus alleen maar in de doos, zonder er iets uit weg te nemen.
Idem voor het instellen of veranderen van de waarde van een variabele: je leerlingen zouden kunnen denken dat dit hetzelfde is als het plaatsen van een extra item in de doos. In realiteit kan een variabele echter geen twee waarden hebben: als een waarde wordt aangepast, wordt de oude gewist - of beter: 'overschreven'. De analogie met de kartonnen doos is dus aantrekkelijk, maar je mag ze niet te ver doortrekken.
Herhaling of iteratie in programmeren betekent dat de uitvoering van bepaalde instructies moet worden herhaald. Daardoor is een lange reeks instructies veel korter en doorgaans gemakkelijker te begrijpen.
Bij het gebruik van herhalingen in programmeren let je er op dat sommige instructies dezelfde óf erg vergelijkbaar zijn. Daarom wordt gebruik gemaakt van het computationeel denkproces van patroonherkenning. Soms ontdek je in het herhalende codeblok een herhaling, dat wil zeggen dat de computer de opdrachten één voor één blijft doorlopen terwijl ze worden uitgevoerd.
Denk aan het Bee-Bot-programma om een vierkant te maken (vooruit, links, vooruit, links, vooruit, links, vooruit, links). Let op hoe we voor elke zijde vooruitgaan en dan linksaf slaan.
In veel programma's wordt herhaling gebruikt: in een spel kunnen we wensen dat voorwerpen zich voortdurend verbergen en opnieuw verschijnen en een programma voor een airco blijft koude lucht uitblazen totdat bijvoorbeeld aan een gewenste kamertemperatuur wordt voldaan.
Door herhaling toe te passen kunnen we programma's maken die eenvoudiger kunnen worden gewijzigd, omdat we de herhaalde code slechts één keer hoeven te wijzigen.
In de onderstaande schermafbeeldingen worden twee programma's weergegeven die worden gebruikt om een driehoek in Scratch te tekenen, waarbij een herhaling wordt gebruikt. Door deze herhalingsopdracht te gebruiken hoeven we slechts één waarde (rood omcirkeld) te wijzigen, in plaats van drie, om de grootte van het vierkant te wijzigen.
Leerlingen maken kennis met herhaling in de wereld om hen heen. Ze merken dingen op die altijd herhalen, zoals de cyclus van dag en nacht, dingen die soms worden herhaald, zoals van maandag tot en met vrijdag naar school gaan. De schooldag zelf heeft ook een herhalend patroon: elke dag op hetzelfde tijdstip is er speeltijd, lunch ... Leerlingen leren routines op school, zoals hoe ze hun jas moeten ophangen, mooi in de rij moeten staan ... Ze herhalen deze routines dagelijks.
Leerlingen blijven herhaling herkennen in de wereld om hen heen. Leerlingen bemerken bijvoorbeeld de voortdurende herhaling van cijfers in het decimale getallensysteem. Ze leren dat vermenigvuldiging een herhaalde optelling is.
In Scratch Junior zit een herhalingsfunctie.
Leerlingen ontwerpen, schrijven en debuggen code, bijvoorbeeld in Scratch, dat herhaling gebruikt om specifieke doelen te bereiken. Daarbij moeten ze de algoritmen voor deze programma's ontwerpen die aangeven hoe en waar herhaling zal worden gebruikt.
In de onderstaande schermafbeelding wordt gebruik gemaakt van een voorwaardelijke herhaling en een herhaling voor het maken van een eenvoudige stopwatch in Scratch waarbij seconden en minuten wordt opgeteld. De schermafbeelding daaronder gebruikt teller-gestuurde herhalingen om patronen te tekenen.
Er zijn tal van materialen, software en andere ondersteunende mediamiddelen beschikbaar die je kunt gebruiken in de klas. Wij maakten een selectie van veelgebruikte leermiddelen.
Robot mouse + code &go kan worden vergeleken met de Beebot. Een speelveld is voorzien, inclusief enkele obstakels en een kaasblokje waar de muis naartoe moet worden geleid. Er zijn tevens enkele opdrachtfiches.
Botley is een variant op de Beebot. Extra functies zijn een lijnvolger en een objectdetectie waardoor kan worden vermeden dat hij botst. De richtingsknoppen staan niet op de rug. Programmeren doe je met de afstandsbediening.
mBot Starter Robot Kit - bluetooth versie - is een programmeerbare robot om ervaring op te doen met grafisch programmeren (met Scratch/mBlock). De bluetooth versie is, nadat deze in elkaar gezet is, direct te gebruiken met een speciale app voor tablets en smartphones.
Met het CodeWise kaartspel kunnen leerlingen elkaar 'unplugged' programmeren. Op elke kaart in het pakketje staat een opdracht: zing een liedje, spring in de lucht, ga staan of zitten of bepaal een looprichting. Kinderen programmeren spelenderwijs een code door de opdrachtkaarten in een bepaalde volgorde te leggen.
Let's go code is een ‘unplugged’ activiteit speciaal voor kleuters : wat is een robot wat is coderen?
De kleuters programmeren elkaar.
Blue-bot is een robotje met programmeerknoppen op de rug. De basistoepassing is leerlingen de Blue-bot te laten programmeren om van punt A naar punt B te gaan. Blue-Bot lijkt op Bee-Bot, maar kan naast de 7 knoppen op de rug, ook via bluetooth geprogrammeerd worden door middel van de app die gratis te downloaden is. Met de Blue-bot leren de leerlingen programmeren, debuggen en het simuleren van algoritmen.
Scratch is een gratis website waarmee leerlingen zelf animaties, games, verhalen, interactieve verhalen, ... kunnen programmeren. Het bijzondere is dat Scratch een vereenvoudigde programmeertaal heeft die bestaat uit "blokjes tekst". Zo kunnen kinderen en jongeren toch programmeren zonder meteen op de muur van ‘moeilijke’ programmeercode te botsen. De blokjes passen als bouwstenen in elkaar. Scratch is speciaal ontworpen voor 8- tot 16-jarigen.
ScratchJr is een Scratch-versie waarmee jongere kinderen (5-7 jaar) hun eigen interactieve verhalen en spelletjes kunnen maken. Door dit te doen leren ze o.a. problemen op te lossen, projecten te ontwerpen en zijn ze creatief bezig. ScratchJr maakt gebruik van dezelfde principes als Scratch om kinderen te leren programmeren nl . door blokken met commando’s aan elkaar te klikken.
De Ozobot is een kleine robot die gecodeerd wordt door kleurcombinaties, eventueel in combinatie met een lijnvolger.
De Ozotbot EVO kan zowel op papier als op een liggende tablet rijden. Zowel de app als de site bieden heel wat uitdagende levels.
De Micro:bit is een kleine (4x5cm) programmeerbare computer die werkt op batterijen voor allerlei leuke creaties, van robots tot muziekinstrumenten. Ook kunnen er allerlei andere apparaten aan worden gekoppeld, zoals lichtsensoren of motortjes. Kinderen sturen zelfgeschreven code naar het computertje en kunnen meteen testen of wat ze hebben bedacht ook echt werkt.
De website levend programmeren bevat een spel en alle nodige materialen om de basisprincipes van programmeren en computationeel denken aan te leren.
De Bee-Bot is een robotje in de vorm van een bij die bedoeld is om kinderen te leren programmeren. De Bee-Bot heeft 5 functies: vooruit, achteruit, linksom draaien, rechtsom draaien en een seconde wachten
Codeschool heeft een laagdrempelig gratis aanbod van code-activiteiten en allerlei didactisch materiaal zoals posters , stappenplan met Scratch-oefeningen, mBot-oefeningen en Micro:Bit-oefeningen. Daarnaast kan ook computationeel didactisch materiaal gratis worden ontleend.
