Effect van Programmeren op het Computational Thinking Bachelorscriptie Onderwijskunde
Universiteit van Amsterdam
Naam: Lisa Habermehl Studentnummer: 10549404
Begeleider: Thomas Jaarsma
Inhoudsopgave
Abstract………. 3
Inleiding………. 4
Computational thinking………. 4
Programmeren……….…..……. 5
Onderzoeksvraag en belangrijke begrippen…..………. 8
Methode literatuurverzameling………..…… 10
Het effect van visueel programmeren op het computational thinking…………...… 11
Primair onderwijs………... 11
Secundair onderwijs………... 13
Conclusie……… 14
Het effect van tastbaar programmeren op het computational thinking……..…….... 15
Primair onderwijs……….…….. 15
Secundair onderwijs………... 17
Conclusie……….... 19
Het effect van unplugged programmeren op het computational thinkin…..…….... 20
Primair onderwijs……….…….. 21
Secundair onderwijs………... 22
Conclusie……….... 23
Conclusie en discussie………... 25
Abstract
One of the most recent discussions in the educational field is the development of the 21st century skills and how these should be implemented in the curriculum. Computational thinking is such a skill: a way of thinking to solve problems by using computer science concepts and techniques. This study analyses what the effect of visual, tangible and unplugged programming is be on the development of computational thinking.
Through an analysis of 13 studies an overview will be given of the effects of visual, tangible and unplugged programming on the development of computational thinking of students in the primary and secondary schools. To analyse these studies the framework of Brennan and Resnick was used. They distinguish three key dimensions of computational thinking: computational concepts, computational practices and computational perspectives.
The results indicate that in order for visual, tangible or unplugged programming to be effective it is important that there are methods to support this programming education. Besides this it is also important that there is enough support for the students and that the content of the education meets the knowledge that a student already has.
In this study the results of schools from different countries were analysed. Therefore it is possible that the different school systems had an influence on the effect. For further research it could be of great value to analyse the effects of programming on computational thinking in schools that have the same school system. Keywords: visual programming, tangible programming, unplugged programming, computational thinking, problem solving
21e eeuwse vaardigheden
creativiteit kritisch denken probleemoplos -vaardigheden
communiceren samenwerken digitale geletterdheid basiskennis computational thinking gebruik gedrag sociaal en cultureel bewustzijn zelfregulering Het effect van programmeren op het computational thinking
In 2015 is het Platform Onderwijs2032 opgericht met als taak de kennis en vaardigheden die leerlingen binnen het primaire en het secundaire onderwijs aangeboden moeten krijgen in beeld te krijgen (Onderwijs2032, 2016). Het gaat hier om de vaardigheden die van belang zijn in de huidige en toekomstige samenleving, vaak de 21e eeuwse vaardigheden genoemd (zie Figuur 1). Het onderwijs van de toekomst is een populair discussiepunt binnen het onderwijsveld (KNAW, 2012; Thijs, Fisser & van der Hoeven, 2014). Maar ook buiten het onderwijsveld wordt er gediscussieerd over wat de belangrijkste vaardigheden zijn die nu nodig zijn binnen een bedrijf (PW de Gids, 2016). Naast het Platform hebben de KNAW (2012) en de SLO (Thijs, Fisser & van der Hoeven, 2014) onderzoek gedaan naar wat de belangrijkste 21e eeuwse vaardigheden zijn. Hier werd onder andere uit geconcludeerd dat er te weinig aandacht wordt besteed aan de digitale geletterdheid in het Nederlandse onderwijs: digitale geletterdheid komt “weinig doelgericht en weinig structureel aan de orde” (KNAW, 2012; Thijs, Fisser & van der Hoeven, 2014). Binnen dit literatuuronderzoek wordt er als reactie op deze stelling geanalyseerd wat het effect van programmeren op het computational thinking is. Om vervolgens in kaart te brengen hoe dit het beste gestructureerd kan worden in het onderwijs.
Figuur 1. De 21e eeuwse vaardigheden.
Computational thinking
Het computational thinking (CT) is een onderdeel van de digitale geletterdheid (zie Figuur 1). De ontwikkeling hiervan is een onderwerp die door de KNAW, de SLO en andere onderwijskundige instanties wordt besproken. Het begrip CT is niet eenduidig: het is een manier van denken bij het oplossen van een probleem, maar het
bestaat niet uit een lijst van vaardigheden die hier verplicht gebruikt moeten worden (Voogt, Fisser, Good, Mishra & Yadav, 2015). Met andere woorden, als een van deze vaardigheden niet wordt gebruikt betekent dat niet meteen dat er geen sprake is van CT. Daarom moet er worden gekeken naar de overeenkomsten en de relaties die de verschillende begrippen van CT om dit te kunnen analyseren.
Het begrip CT werd voor het eerst geïntroduceerd door Papert (1980). Hij stelt dat dit een manier van denken is die leerlingen ontwikkelen als zij leren programmeren. En dat deze manier van denken ook in het dagelijkse leven toegepast kan worden (Selwyn, 2011). Het gaat hier om het aanleren van een tekstuele programmeertaal waarbij er gebruik wordt gemaakt van een bepaalde volgorde van codes, ook wel programmeersyntax genoemd. Het aanleren van programmeren om CT te ontwikkelen is later weggevallen omdat het tekstueel programmeren te moeilijk bleek te zijn voor jonge leerlingen (Leron, 1983; Sutherland, 1994). Een aantal jaren geleden werd het begrip CT weer door Wing (2006) gebruikt. Zij heeft het echter over een andere ontwikkeling van CT, namelijk over het denken volgens concepten die binnen het programmeren worden gebruikt maar niet worden aangeleerd door het leren programmeren. Volgens Wing is CT een denkproces waarbij er gebruik wordt gemaakt van computationele stappen om te bepalen wat het probleem is en wat de oplossing zou kunnen zijn (Wing, 2008; Aho, 2012 aangehaald in Grover & Pea, 2013).
De bovenstaande definities van CT komen overeen in “the focus on the skills, habits and dispositions needed to solve complex problems with the help of computing and computers”, maar verschillen in hoe deze “skills, habits and dispositions” worden ontwikkeld (Voogt et al., 2015). Papert en Wing zien het CT allebei als een manier van denken waarbij er gebruik wordt gemaakt van concepten of strategieën die bij het programmeren worden gebruikt om problemen op te lossen, maar zij hebben verschillende ideeën over hoe dit worden aangeleerd. Papert (1980) stelt dat leerlingen CT ontwikkelen door te leren programmeren, Wing (2006) stelt dat het ook mogelijk is om CT te ontwikkelen zonder een programmeertaal aan te leren. Sterker nog, Wing stelt dat het mogelijk is om het CT aan te leren zonder een computer te gebruiken.
Programmeren
Op basis van het bovenstaande kan er worden gesteld dat het aanleren van CT zonder een computer een beter alternatief is. Het tekstueel programmeren is namelijk
te moeilijk voor jonge leerlingen. Uit onderzoek blijkt dat leerlingen pas in staat zijn om tekstueel te programmeren als zij 10 jaar oud zijn (McNerney, 2004). Leerlingen zij niet bekend met de programmeersyntax, daarom wordt het al moeilijk ervaren. Lu en Fletcher (2009) stellen dat leerlingen daarom pas moeten leren programmeren als zij op een hoger niveau van informatica (computer science) zitten. Het kan namelijk moeilijk zijn om woorden in een andere taal toe te passen of te gebruiken als de taal nog niet wordt beheerst. Lu en Fletcher (2009) zien het programmeren als een verdieping in de informatica.
Aan de andere kant kan het programmeren worden gezien als een manier om creatieve ideeën te uiten (Resnick et al., 2009) en als een middel om leerlingen niet alleen tot gebruikers van technologie maar ook tot makers van technologie op te leiden (Wyeth, 2008). Om deze redenen zou het wel van belang zijn om leerlingen het programmeren aan te leren. Hier moet er rekening gehouden worden met hoe onbekend een programmeertaal is voor leerlingen. De moeilijkheid van het tekstueel programmeren wordt mogelijk vermeden als leerlingen leren programmeren in een taal die dicht bij de taal ligt die zij dagelijks spreken (Lye & Koh, 2014).
Grover en Pea (2013) stellen dat er sprake moet zijn van een low floor en een high ceiling om het programmeren op jonge leeftijd aan te leren. Dit betekent dat het makkelijk toegankelijk moet zijn, maar dat leerlingen wel veel over het programmeren leren. Dit is vergelijkbaar met het rekenonderwijs. Hier wordt er in het begin vaak gebruik gemaakt van concreet materiaal (low floor) om abstracte wiskundige concepten (high ceiling) uit te leggen. Leerlingen zijn hierdoor in staat om deze concepten toe te passen zonder de ingewikkelde wiskundige symbolen te begrijpen (Kennedy & Tipps, 1994; Uttal, Scudder & DeLaoche, 1997). Zo zou er ook bij het vormgeven van programmeren binnen het primaire en het secundaire onderwijs de ingewikkelde abstracte programmeer concepten in het begin op een concrete manier worden aangeleerd. Wing (2016) zegt hier het volgende over:
Consider an analogy to mathematics. We teach numbers to 5-year-olds, algebra to 12-year-olds and calculus to 18-year-olds. We have somehow figured out the progression of concepts to teach in mathematics, where learning one new concept builds on understanding the previous concept, and where the progression reflects the progression of mathematical sophistication of a child as he or she matures. (Wing, 2016)
Zoals er in het leren van wiskunde een opbouw is moet er ook in het leren van programmeren een opbouw zijn. Leerlingen moeten hierbij niet meteen leren welke codes er gebruikt kan worden in een programma, maar ze moeten eerst leren wat de logica achter het gebruik van bepaalde codes in het programmeren is (Filiz, Korhan & Arabacioglu, 2009 aangehaald in Oluk & Saltan, 2015). Een mogelijkheid om deze logica aan te leren en om het programmeren makkelijk toegankelijk te maken is door het gebruik van visuele representaties en concrete materialen. Hierdoor wordt de cognitieve belasting verminderd doordat leerlingen niet hoeven na te denken over de betekenis van de codes zoals in een tekstuele programmeertaal gedaan moet worden (Kelleher & Pausch, 2005; Maches, O’Mally & Benford, 2009).
Om te kunnen analyseren of er sprake is van een ontwikkeling van het CT bij het leren programmeren moet er geanalyseerd worden of er sprake is van een ontwikkeling in het gebruik of het begrip van de “skills, habits and dispositions”. Waarbij er een onderscheid wordt gemaakt tussen de verschillende manieren waarop deze worden aangeleerd (visueel programmeren, tastbaar programmeren, unplugged programmeren). Brennan en Resnick (2012) hebben een kader ontwikkeld waar de verschillende dimensies van het CT (“skills, habits and dispositions”) op een rij staan. Ze hebben het onder andere over het begrijpen en het toepassen van de programmeerconcepten en –programmeerstrategieën.
Programmeerconcepten zijn de ideeën waar leerlingen mee te maken krijgen als zij leren programmeren. Het gaat hier bijvoorbeeld om het denken in stappen als een robot (algoritmen). Of om een reactie die alleen gebeurt bij een bepaalde voorwaarde: ‘als’ dit er is, ‘dan’ gebeurt dit. Maar het gaat hier ook herhalingen, variabelen en patronen (zie Tabel 1). Programmeerstrategieën zijn “problem-solving practices that occurs in the process of programming”. Er wordt hier gekeken naar de manieren waarop de programmeerconcepten worden toegepast om een probleem op te lossen. Hierbij kan er gedacht worden aan het iteratief denken of het oplossen van een probleem door te debuggen (zie Tabel 1).
Brennan en Resnick (2012) stellen dat CT ook vanuit een derde dimensie bekeken kan worden. Ze hebben het hier over het perspectief dat leerlingen van het programmeren hebben. Leerlingen kunnen het programmeren als een middel zien om hun ideeën te uiten. Of leerlingen kunnen een perspectief ontwikkelen over hoe goed of hoe slecht zij kunnen programmeren. Of ze kunnen een perspectief ontwikkelen over het programmeren met anderen of het programmeren voor anderen. Zien ze het
als een manier om samen te werken. Zien ze het als een manier om iets voor anderen te programmeren.
Tabel 1
De dimensies van het computational thinking (Brennan en Resnick, 2012) Computational thinking Omschrijving
Concepten Algoritmen Een reeks instructies, het denken in stappen als een robot
Voorwaarden Er wordt iets gedaan als er aan een bepaalde voorwaarde wordt voldaan (‘als’ dit er is ‘dan’ gebeurt dit)
Herhalingen Een loop waarin iets wordt herhaald
Variabelen Een waarde die kan worden opgeslagen om te kunnen vergelijken met andere waarden Patronen Het herkennen van patronen
Operators Wiskundige operators zoals +, -, Strategieën Iteratief zijn Een proces herhalen
Testen en debuggen Fouten opsporen en oplossen, hierbij kan er gebruik gemaakt worden van reflectie
Hergebruiken Een oplossing voor een probleem opnieuw toepassen of kennis wat eerder is opgedaan gebruiken
Abstractie De overbodige informatie bij een probleem weglaten om zo het probleem algemeen te maken
Perspectieven Hoe ziet de leerling (1) het programmeren, (2) zichzelf in relatie tot het programmeren, (3) het programmeren met anderen.
Onderzoeksvraag en belangrijke begrippen
Binnen dit literatuuronderzoek wordt er in kaart gebracht wat het effect van programmeren op de ontwikkeling van CT kan zijn. Hierbij wordt er zowel gekeken naar het programmeren met een computer (visueel en tastbaar programmeren) als het ‘programmeren’ zonder een computer (unplugged programmeren) (zie Figuur 2). De volgende vraag staat centraal: “Wat is het effect van visueel, tastbaar en unplugged programmeren op het computational thinking van leerlingen binnen het primair en het
secundair onderwijs?”. Visueel programmeren is het programmeren waarbij er geen gebruik wordt gemaakt van tekst of codes maar van visuele representaties van stukjes codes. Tastbaar programmeren is het programmeren waarbij er gebruik wordt gemaakt van concrete materialen die gemanipuleerd kunnen worden door leerlingen. Unplugged programmeren is hier het ‘programmeren’ waarbij de programmeerconcepten en –strategieën worden aangeleerd zonder het gebruik van een computer. CT is de mate waarin leerlingen in staat zijn om problemen op te lossen door het gebruik van concepten en strategieën uit de informatica. Om het CT te analyseren wordt er gebruik gemaakt van het kader van Brennan en Resnick (2012). Er wordt een onderscheid gemaakt tussen studies die zich focussen op de mate waarin leerlingen een begrip ontwikkelen over de programmeerconcepten, de mate waarin leerlingen gebruik maken van programmeerstrategieën en de mate waarin leerlingen zich ontwikkeling in het perspectief en de houding naar de technologie en anderen. Daarnaast wordt er ook meegenomen welke andere factoren hier mogelijk een rol in spelen.
In het volgende hoofdstuk wordt er eerst besproken hoe er naar literatuur is gezocht. Vervolgens wordt er in drie hoofdstukken in kaart gebracht wat er gevonden is over het effect van (1) het visueel programmeren, (2) het tastbaar programmeren en (3) het unplugged programmeren op het CT van leerlingen. Hier zal er een uitleg worden gegeven over wat deze vorm van programmeren precies inhoudt, hoeveel studies hier onderzoek naar hebben gedaan en wat het resultaat hiervan is. Het literatuuronderzoek wordt afgesloten met een conclusie- en een discussiehoofdstuk.
Figuur 2. De relatie tussen het programmeren, het computational thinking en het oplossen van problemen.
probleem oplossing • programmeerconcepten • programmeerstrategieën • perspectieven computational thinking • tekstueel programmeren • visueel programmeren • tastbaar programmeren
Methode literatuurverzameling
Voor de literatuurverzameling is er gebruik gemaakt van verschillende zoekmachines: ScienceDirect, Web of Science, Elsevier, Scopus en Google Scholar. In dit hoofdstuk zullen de aantal artikelen die met de betreffende zoekterm zijn gevonden tussen haakjes worden aangegeven. Eerst is er gezocht met de zoekterm “computational thinking” (3) en de zoektermen “thinking” “computing education” (1). Op dit moment was het nog onduidelijk welke variabelen gerelateerd waren aan deze term. Toen duidelijk werd dat CT vaak als het probleemoplossend vermogen werd onderzocht, is er verder gezocht met de kernwoorden “computational thinking” en “problem solving” (3). Uit de artikelen die hier werden gevonden bleek het programmeren ook een gerelateerde variabele te zijn. En hieruit bleek dat veel studies CT meten door het probleemoplossend vermogen van leerlingen te meten. Er werd verder gezocht met “programming” en “problem solving” (1). Hieruit bleek dat er een onderscheid gemaakt kon worden tussen visueel programmeren en tastbaar programmeren. Daarna is er gezocht naar visueel programmeren en het probleemoplossend vermogen met de kernwoorden “computational thinking” en “visual programming” (3). Er is ook gezocht naar tastbaar programmeren en het probleemoplossend vermogen met de kernwoorden “computational thinking” en “tangible programming” (1), maar ook met “computational thinking” en “robotics” (1). Later bleek uit verschillende studies en bronnen uit de omgeving dat unplugged programming een onmisbaar onderdeel is van het programmeren in het onderwijs. De studies over unplugged programmeren zijn gevonden met enkel de zoekterm “unplugged programming” (8). Daarnaast is er bij het lezen van de studies ook rekening gehouden met mogelijk relevante studies die relevant zijn om helemaal te lezen. In plaats van alleen de informatie die in de desbetreffende studie staat vermeld (9).
Om te bepalen of een artikel geschikt was voor dit literatuuronderzoek werden de volgende vragen gesteld. Is er hier sprake van een visuele, tastbare of unplugged programmeertaal? Wordt hier een programmeerconcept, een programmeerstrategie of het perspectief van de leerling gemeten of geobserveerd? Hierbij wordt het kader van Brennan en Resnick (2012) in meegenomen.
Het effect van visueel programmeren op het computational thinking
Visueel programmeren is het programmeren waarbij er geen gebruik wordt gemaakt van syntax in de vorm van tekst en codes, maar van syntax in de vorm van visuele representaties van stukjes codes. Een programma dat vaak wordt gebruikt om leerlingen kennis te laten maken met het programmeren is Scratch. Binnen dit programma is het mogelijk om met puzzelstukjes een spelletje of een digital story te maken. Een puzzelstukje stelt een stukje code voor, dit kan bijvoorbeeld een ‘als-dan’ conditie zijn (als er op de linkermuisknop wordt geklikt, dan springt het poppetje omhoog). Leerlingen kunnen zo kennis maken met de logica achter het programmeren zonder dat ze kennis over syntax nodig hebben (Wang, Huang & Hwang, 2014). Binnen dit hoofdstuk worden studies vergeleken waarbij het gebruik van een visuele programmeertaal (Scratch) de onafhankelijke variabele is en het CT van leerlingen de afhankelijke variabele. Er wordt in kaart gebracht welke uitvoering van het visueel programmeren een significant effect heeft en welke uitvoeringen een klein tot geen effect laten zien. Eerst worden de resultaten uit het primaire onderwijs besproken, dan de resultaten uit het secundaire onderwijs om vervolgens een conclusie te trekken.
In totaal zijn er zeven studies geanalyseerd: vijf studies binnen het primaire onderwijs (Kalelioglu & Gulbahar, 2014; Brown, Mongan, Kusic, Garbarine, Fromm & Fontecchio, 2013; Lai & Yang, 2011; Calao, Moreno-Leon, Correna & Robles, 2015; Calder, 2010) en twee studies binnen het secundaire onderwijs (Oluk & Sultan, 2015; Wang, Huang & Hwang, 2014). De studies verschillen in hoe Scratch wordt toegepast binnen het onderwijs, welke experimentele activiteiten er zijn en hoe er wordt bepaald in welke mate er sprake is van een ontwikkeling in het CT.
Primair onderwijs (Brown et al., 2013; Calder, 2010; Calao et al., 2015; Kalelogiu & Gulbahar, 2014; Lai & Yang, 2011)
Programmeerconcepten. Uit het onderzoek van Calao et al. (2015) blijkt er een kleine toename te zijn als er naar het begrip van programmeerconcepten over het algemeen wordt gekeken (algoritmen, herhaling, voorwaarden, variabelen). En een grote toename als er specifiek wordt gekeken naar het begrip dat leerlingen ontwikkelen over het gebruik van algoritmen. Dit resultaat is tegenstrijdig met het resultaat uit het onderzoek van Kalelogliu & Gulbahar (2014). Hier blijkt er geen significant effect te zijn van het programmeren op het begrip over programmeerconcepten. Beide studies maken gebruik van een introductieles voordat de leerlingen met het programma Scratch gaan werken. In de studie van Calao et al.
(2015) maken zij na de introductieles kennis met de werking van Scratch. Ze leren wat herhalingen, voorwaarden en variabelen inhouden en hoe deze gebruikt kunnen worden om zo een eigen spel of simulatie te maken in Scratch. Een mogelijke verklaring voor de verschillende effecten is dat er binnen het onderzoek van Kalelogliu en Gulbahar (2014) al snel werd overgestapt naar het daadwerkelijk gebruik van Scratch. Leerlingen lijken de programmeerconcepten hier aan te leren door meteen te programmeren binnen Scratch. Daarnaast nemen de opdrachten die worden gegeven toe in moeilijkheidsgraad. Het is mogelijk dat het niveau van de uitleg van de programmeerconcepten niet aansluit bij het niveau van de opdrachten.
In de studie van Calder (2010) kregen de leerlingen ook een introductieles waar de leerlingen meteen aan de slag gingen met Scratch. Hier kregen ze de opdracht om hun groepsnaam in Scratch te presenten. Vervolgens werd er een spel gemaakt in het programma. Leerlingen waren hier wel in staat om hun ideeën in Scratch uit te werken. Ze konden een verbinding maken tussen wat ze in het programma schreven en wat er op het scherm gebeurde. Vergeleken met het onderzoek van Kalelogliu en Gulbahar (2014) kan er worden gesteld dat het aanleren van de programmeerconcepten door meteen met het programma bezig te zijn effectief is als de opdracht waarmee het begrip wordt gemeten niet te moeilijk is.
In een andere studie werd er onderzocht of het visualiseren van strategieën om rekenproblemen op te lossen invloed heeft op de mate waarin leerlingen voor een efficiënte strategie kiezen om rekensommen op te lossen (Brown et al., 2013). Denk hierbij aan het vermenigvuldigen als een efficiëntere techniek van het continu optellen. Er is een significante toename van 9% te zien. Met andere woorden, er is een significante vooruitgang te zien in de mate waarin leerlingen begrijpen welke math operator het meest geschikt is.
Programmeerstrategieën. De meeste studies die onderzoek doen naar deze dimensie van CT doen onderzoek naar de mate waarin leerlingen in staat zijn om een programma te testen en te debuggen (Lai & Yang, 2011; Calder, 2010). Uit deze studies blijkt dat het programmeren hier een significant effect op heeft. In beide studies werd het reflecteren als een hulpmiddel gebruikt om het testen en debuggen te stimuleren. Calder (2010) heeft ruimte gemaakt voor reflectie tijdens de les. Leerlingen reflecteren door hun opdracht in Scratch te presenteren en hierbij te onderbouwen waarom zij bepaalde keuzes hebben gemaakt. Maar ook door te
luisteren naar feedback die zij vanuit de klas kregen. Door te reflecteren op deze feedback waren leerlingen in staat om het programma in Scratch te debuggen.
Lai en Yang (2011) hebben zich gericht op het onderwijzen van de vaardigheden die leerlingen nodig hebben om een probleem op te lossen in Scratch. Vaardigheden zoals bepalen wat het probleem is, deze analyseren, een oplossing bedenken en deze uitvoeren binnen Scratch, de oplossing testen en aanpassen indien nodig. Ze hebben ervoor gekozen om deze door scaffolding aan te leren. Daarnaast wordt er gereflecteerd op wat ze hebben gemaakt en ontvangen zij peerfeedback. Uit de resultaten blijkt dat dit voornamelijk een effect heeft op de mate waarin leerlingen in staat zijn om een voorspelling te doen over de werking van een programma.
Perspectieven. Over het algemeen hebben de leerlingen een positief perspectief op het programmeren (Lai & Yang, 2011). Met uitzondering van de leerlingen die slecht presteren in het werken met Scratch. Het is mogelijk dat deze groep leerlingen op een andere manier leert. Daarom zou het aanbieden van verschillende leerstijlen een oplossing kunnen zijn. Daarnaast is er een ontwikkeling te zien in het zelfvertrouwen dat leerlingen hebben in het eigen vermogen om problemen op te lossen met Scratch (Kalelogliu & Gulbahar, 2014). In het onderzoek van Calder (2010) is er een verbetering te zien in het perspectief dat leerlingen hebben over het samenwerken in het programmeren. Het programma bevordert de mate waarin er wordt samengewerkt en gecommuniceerd binnen de klas.
Secundair onderwijs (Oluk & Saltan, 2015; Wang, Huan & Hwang, 2014)
Programmeerconcepten. Uit onderzoek naar het effect van het visueel programmeren op het begrip van algoritmen blijkt dat er geen effect is (Oluk & Saltan, 2015). Binnen dit onderzoek werd er onderzocht of het visueel programmeren een toegevoegde waarde heeft in een informaticales waarin het concept algoritmen werd uitgelegd aan de hand van flowcharts. Dit blijkt niet zo te zijn. Een mogelijke verklaring is dat de algoritmen te moeilijk waren voor de leerlingen.
Programmeerstrategieën. Het leren programmeren in combinatie met het Project Based Learning (PBL) blijkt een significant effect te hebben op het CT (Wang, Huan & Hwang, 2014). Ten eerste is er een ontwikkeling te zien in de mate waarin leerlingen in staat zijn om te reflecteren (testen en debuggen). Ten tweede moesten de leerlingen ook kennis die ze eerder hadden opgedaan toepassen om een probleem op te lossen (hergebruiken). Er werd hier benadrukt hoe belangrijk het is dat leerlingen die niet bekend zijn met technologie genoeg begeleiding krijgen.
Perspectieven. Er is een significante positieve ontwikkeling te zien in de motivatie en de houding van leerlingen naar Scratch (Wang, Huan & Hwang, 2014). Conclusie
In de studies naar het effect van programmeren op het begrip van programmeerconcepten in het primair onderwijs zijn er verschillende resultaten te zien. Als het om het begrip van programmeer concepten over het algemeen gaat (herhalingen, voorwaarden, variabelen) is er een kleine tot geen toename te zien (Kalelogliu & Gulbahar, 2014; Calao et al., 2015; Calder, 2010). Maar er is een grote toename te zien als er specifiek wordt gekeken naar het begrip dat leerlingen over algoritmen ontwikkelen (Calao et al., 2015). In een ander onderzoek is er een toename te zien als er specifiek wordt gekeken naar de mate waarin leerlingen begrijpen welke math operator zij het beste het beste kunnen gebruiken om een probleem op te lossen (Brown et al., 2013).
Een mogelijke verklaring voor het resultaat uit de studie van Kalelogliu en Gulbahar (2014) is dat het niveau van de introductieles waar leerlingen leren wat de concepten inhouden niet aansluit op het niveau waarop de ontwikkeling van deze kennis wordt gemeten. Dit sluit aan bij de verklaring die in het onderzoek van Oluk en Saltan (2015) wordt genoemd. Zij deden onderzoek binnen het secundair onderwijs. Ook hier is er geen effect te zien van het visueel programmeren op het begrip van het programmeerconcept algoritmen. Hier werd er genoemd dat de algoritmen waarschijnlijk te moeilijk waren voor de leerlingen.
Als het gaat om het effect van visueel programmeren op het gebruik van programmeerstrategieën, dan kan er gesteld worden dat het visueel programmeren zowel in het primair als het secundair onderwijs een effect heeft op het testen en debuggen (Lai & Yang, 2011; Calder, 2010; Wang, Huan & Wang, 2014). Het gaat hier echter niet om een effect van alleen het visueel programmeren. In alle studies wordt er namelijk naast het visueel programmeren gebruik gemaakt van reflectie om het debuggen te stimuleren (Lai & Yang, 2011; Calder, 2010; Wang, Huan & Wang, 2014). Het gaat hier vooral om het zelf reflecteren op het proces, maar ook om het reflecteren op feedback vanuit de groep (Calder, 2010).
Uit de resultaten blijkt dat leerlingen een positief perspectief ontwikkelen over het eigen kunnen in Scratch (Kalelogliu & Gulbahar, 2014) en over het samenwerken tijdens het werken met Scratch (Calder, 2010). Over het algemeen is er een positieve houding naar Scratch (Lai & Yang, 2011; Wang, Huan & Hwang, 2014). Hier zijn
een aantal uitzonderingen. Leerlingen die niet goed presteren in het programma laten deze positieve houding niet zien. Een mogelijke verklaring is dat deze leerlingen moeite hebben met het programma omdat zij een andere leerstijl hebben. Daarom zou er ook aandacht moeten komen voor de verschillende leerstijlen in de groep.
Het effect van tastbaar programmeren op het computational thinking Tastbaar programmeren is het programmeren waarbij er gebruik wordt gemaakt van concrete materialen om een voorwerp te manipuleren. In tegenstelling tot de gebruikte methode van een visuele programmeertaal (Scratch) worden er bij een tastbare programmeertaal gebruik gemaakt van verschillende methodes (Tangible K, Lego Mindstorms). Het materiaal dat binnen deze methodes gebruikt wordt is vaak hetzelfde. Dit zijn blokken waar sensoren in zijn verwerkt die voor een reactie op een van de blokken zorgen (een blok maakt geluid of een blok geeft licht) of voor een reactie op een apparaat (een robot die beweegt). Het tastbaar programmeren kan ook gebruikt worden in combinatie met het visueel programmeren, maar omdat het hier voornamelijk draait om het tastbaar programmeren worden deze methodes ook als een tastbare programmeertaal gezien en niet als visuele programmeertaal. Binnen dit hoofdstuk is tastbaar programmeren de onafhankelijke variabele en de ontwikkeling van het CT de afhankelijke variabele. Eerst zullen de resultaten van de studies binnen het primaire onderwijs besproken worden, vervolgens de resultaten van de studies binnen het secundaire onderwijs en als laatste volgt er een conclusie over alle studies. Er zijn in totaal drie studies binnen het primaire onderwijs geanalyseerd (Flannery & Bers, 2013; Sipitakiat & Nusen, 2012; Wyeth, 2008) en drie studies binnen het secundaire onderwijs (Lindh & Holgersson, 2007; Chambers, Carbonaro & Rex, 2007; Sullivan, 2005). Binnen alle studies wordt er een vorm van tastbaar programmeren onderwezen en binnen alle studies wordt er een programmeerconcept of –strategie onderzocht. Ook binnen dit hoofdstuk worden eerst de resultaten uit het primair onderwijs besproken, vervolgens de resultaten uit het secundair onderwijs en als laatste een globale conclusie.
Primair onderwijs (Flannery & Bers, 2013; Sipitakiat & Nusen, 2012; Wyeth, 2008) Programmeerconcepten. Het is van belang dat leerlingen genoeg begeleiding krijgen tijdens het tastbaar programmeren. Leerlingen hebben vaak moeite met het begrijpen van het tastbaar programmeren en zijn snel hun aandacht kwijt als ze geen vooruitgang zien (Sipitakiat & Nusen, 2012). En soms snappen leerlingen wel wat de
functie van een variabele is, maar ze zijn dan niet in staat om te bepalen waar het probleem door wordt veroorzaakt (Wyeth, 2008). Of soms zien ze wel waar het probleem door veroorzaakt wordt, maar weten dan niet wat de juiste oplossing is. Er is hier wel een verbetering in te zien naarmate de leerlingen meer opdrachten uitvoeren.
Programmeerstrategieën. Net zoals in het vorige hoofdstuk is het debuggen een populaire strategie die wordt gestimuleerd bij leerlingen. Wat hier opvalt is dat het systematisch nadenken een effectieve manier is om te debuggen. Flannery en Bers (2013) stellen dat leerlingen die het programma vaak werkend krijgen eerder gebruik maken van een systematische benadering dan van een trial-and-error benadering. Sipitakiat en Nusen (2012) ondersteunen de leerlingen met twee strategieën om het systematisch denken te stimuleren. Ook Wyeth (2008) biedt leerlingen strategieën aan om leerlingen te helpen en maakt hier gebruik van scaffolding.
Flannery en Bers (2013) maken een onderscheid tussen de verschillende cognitieve ontwikkelingsfasen waar leerlingen in zitten bij het analyseren van de resultaten. Hieruit blijkt dat het effect dat het tastbaar programmeren heeft op het debuggen afhankelijk is van de cognitieve ontwikkelingsfase waar een leerling in zit. Leerlingen in de derde cognitieve ontwikkelingsfase zijn in staat om een programma werkend te krijgen. Leerlingen in de eerste en tweede cognitieve ontwikkelingsfase blijken moeite te hebben met het bepalen van het probleem en het bedenken van een oplossing. Ze vonden het makkelijker om opnieuw te beginnen dan uit te zoeken waar het probleem door veroorzaakt wordt. Zij hebben waarschijnlijk meer profijt van het leren programmeren als zij eerst bekend worden met de methode en het materiaal en vervolgens kleine problemen oplossen. Leerlingen in de derde cognitieve ontwikkelingsfase maakte vooral gebruik van systematisch benaderingen om te debuggen. Maar ook door het programma door te lezen en in hun hoofd erbij benoemen wat er zou moeten gebeuren en kijken of het overeenkomt.
Een andere optie om leerlingen tegemoet te komen in het testen en debuggen is het aanreiken van een debug model (Sipitakiat & Nusen, 2012). Met dit debug model is het mogelijk om het programma stap voor stap te doorlopen en is het makkelijker om te bepalen waar een probleem ligt. Hoe leerlingen gebruik maken van dit debug model wordt pas uitgelegd als leerlingen vast komen te zitten in de opdracht. Eerst werden er kritische vragen gesteld om de leerlingen op weg te helpen, maar als dit niet hielp dan kregen ze het model enzo.
Daarnaast kan het tastbaar programmeren ook een effect hebben op de mate waarin de leerling iteratief werkt (Sipitakiat & Nusen, 2012). Leerlingen zijn het meest gemotiveerd door het zien bewegen van hun robot. Dit doen ze daarom ook zo snel mogelijk. Hierdoor programmeren de leerlingen hun ideeën vaak op zo’n manier dat de meest belangrijke onderdelen er in staan, maar hierdoor werkt het niet meteen correct. Vervolgens passen ze het programma steeds een beetje aan totdat het goed werkt.
Een andere strategie die leerlingen ontwikkelen is toepassen van kennis dat eerder is opgedaan (hergebruiken) (Sipitakiat & Nusen, 2012). Om dit te kunnen doen moeten leerlingen in staat zijn om onderdelen uit een eerder problemen te herkennen in het probleem waar ze op dat moment mee te maken hebben.
Perspectieven. Leerlingen vinden het interessant om te zien hoe hun robot functioneert en wat er gebeurt als zij aanpassingen maken (Sipitakiat & Nusen, 2012). Secundair onderwijs (Lindh & Holgersson, 2005; Chambers, Carbonaro & Rex, 2007; Sullivan, 2005)
Programmeerconcepten. Uit het onderzoek van Chambers, Carbonaro en Rex (2007) blijkt dat het begrip van algoritmen bevorderd kan worden door het tastbaar programmeren. Hierbij wordt er wel gesteld dat dit het beste werkt door het gebruik van flowcharts. Hierdoor zijn leerlingen bezig met het structureren van hun ideeën door alles stap voor stap uit te plannen (algoritmen). Door commando’s (‘gaat naar links’) en conditionele checks (‘is de ondergrond geel?’) wordt het gedrag van de robots in kaart gebracht en kunnen de leerlingen hun ideeën te structuren.
Als het gaat om het effect van het tastbaar programmeren op het begrijpen van programmeerconcepten is de begeleiding van de leerling essentieël. Dit kan door leerlingen een logboek te laten bijhouden (Chambers, Carbonaro & Rex, 2007). Hierdoor kan een leerkracht in de gaten houden waar een leerling tegen aanloopt en kan er zo begeleiding op maat worden aangeboden. In de studie van Chambers, Carbonaro en Rex (2007) werd deze begeleiding in de vorm van scaffolding gedaan. Een andere manier van begeleiding is het aansluiten op de verschillende manieren waar leerlingen van hun fouten leren (Lindh & Holgersson, 2005). Leerlingen leren bijvoorbeeld door trial-and-error, door samenwerking of door de instructies van de leerkracht te lezen. Uit het onderzoek van Lindh en Holgersson (2005) is er echter geen duidelijke aanwijzing dat het tastbaar programmeren daadwerkelijk invloed
heeft op het begrip van programmeerconcepten. Of deze vorm van begeleiding werkt kan dus ook niet met zekerheid worden gezegd.
Daarnaast lijkt het uitleggen van de programmeerconcepten door leerlingen een positief effect te hebben op de mate waarin leerlingen deze concepten begrijpen (Chambers, Carbonaro & Rex, 2007). De leerlingen werden in groepen verdeeld en elke groep moest uitzoeken wat een bepaald concept precies was en de bevindingen presenteren.
Programmeerstrategieën. Volgens Chambers, Carbonaro en Rex (2007) en Sullivan (2007) heeft het tastbaar programmeren invloed op de mate waarin leerlingen testen en debuggen. Leerlingen zijn steeds bezig met aanpassen van het programma van hun robot totdat deze naar behoren werkt. Debuggen werd vaak gedaan door reflectie (Sullivan, 2007). Hier valt op dat leerlingen eerder een onderdeel veranderen en de uitkomst hiervan observeren, dan twee onderdelen veranderen en hier de uitkomst van observeren. Alle leerlingen hebben hun programma geobserveerd en de oplossing geëvalueerd (Sullivan, 2007).
Deze resultaten zijn tegenstrijdig met het resultaat van Lindh en Holgersson (2005). In dit onderzoek is er geen significant effect te zien van het tastbaar programmeren op het debuggen. Een verklaring die hiervoor wordt genoemd is de heterogene groep in het onderzoek en de verschillende niveaus van het debuggen die daardoor aanwezig zijn in het onderzoek maar waar geen rekening mee wordt gehouden. Leerlingen die het debuggen al redelijk beheersen laten mogelijk geen vooruitgang zien omdat ze het al kunnen. Leerlingen die het debuggen nog niet beheersen laten mogelijk geen vooruitgang zien omdat het te moeilijk is.
Een andere factor die kan bijdragen aan de effectiviteit van het tastbaar programmeren op het gebruik van programmeerstrategieën is het expliciet aandacht hebben voor de kennis waar een leerling over beschikt. Chambers, Carbonaro en Rex (2007) hebben aandacht voor het hergebruiken van kennis als strategie bij het oplossen van problemen. Zij zorgen ervoor dat de leerlingen op het juiste niveau worden onderwezen. Hierdoor wordt er een goede basis van kennis gevormd waar leerlingen later op kunnen voortbouwen of wordt er voortgebouwd op kennis waar een leerling al over beschikt. Chambers, Carbonaro en Rex (2007) hebben het hier over het aanbieden van de juiste uitdagingen tijdens het tastbaar programmeren. Andere factoren die van belang zijn voor de effectiviteit zijn de benadering in de les en de inrichting van de omgeving (Sullivan, 2007). Het is belangrijk dat leerlingen de
mogelijkheid hebben om direct feedback te krijgen en dat leerlingen zich in een rijke leeromgeving bevinden.
Perspectieven. Tijdens het tastbaar programmeren krijgen leerlingen de mogelijkheid om samen te werken (Chambers, Carbonaro & Rex, 2007). Ook Lindh & Holgersson (2005) concluderen dat het samenwerken een positieve bijdrage levert aan “the feeling of a community”. En daarmee met het perspectief dat leerlingen hebben in relatie tot anderen. Daarnaast is het belangrijk dat het leermateriaal aansluit bij de interesse van de leerling (Lindh & Holgersson, 2005). Hiermee kan er voorzichtig geconcludeerd worden dat dit een positief effect heeft op het perspectief dat een leerling over het leermateriaal (van het programmeren) vormt.
Conclusie
Er is een ontwikkeling te zien in de mate waarin leerlingen de programmeerconcepten begrijpen, maar er is geen sprake van een groot effect. Dit kan door een aantal dingen veroorzaakt worden. In het primair onderwijs hebben leerlingen vaak moeite met het begrijpen hoe het tastbaar programmeren werkt. En als ze geen vooruitgang zien zijn ze snel hun aandacht kwijt. In het secundair onderwijs is wel sprake van een effect (Chambers, Carbonaro & Rex, 2007). De ontwikkeling van het begrip van algoritmen wordt hier gestimuleerd door het gebruik van flowcharts. Hierdoor kunnen leerlingen hun ideeën structureren.
Het begeleiden van de leerlingen in het begrijpen van CT en het gebruik van hulpmiddelen is dus een bepalende factor in het effect dat het tastbaar programmeren heeft. In tegenstelling tot de studies in het primaire onderwijs heeft de studie uit het secundaire onderwijs flowcharts gebruikt om het concept algoritmen duidelijk te maken. Andere begeleiding die ook effectief is is overzicht houden over wat een leerling kan door het lezen van logboeken die zij bijhouden en aan de hand hiervan begeleiding op maat aanbieden.
Het testen en debuggen is ook bij het tastbaar programmeren een strategie die wordt ontwikkeld. Uit de studies binnen het primair onderwijs valt op dat het systematisch nadenken een manier is waar het testen en debuggen mee wordt gestimuleerd (Flannery & Bers, 2013; Sipitakiat & Nusen, 2012; Wyeth, 2008). Een ander hulpmiddel is het aanreiken van een debug model (Sipitakiat & Nusen, 2012). Of door te reflecteren op het proces (Sullivan, 2007).
Het is wel belangrijk om onderscheid te maken tussen de verschillende niveaus van leerlingen. Als leerlingen het tastbaar programmeren op een te hoog
niveau krijgen is het mogelijk dat er geen ontwikkeling is van het CT omdat het te moeilijk is (Lindh & Holgersson, 2005). Als leerlingen het tastbaar programmeren op een te laag niveau krijgen is het mogelijk dat er geen ontwikkeling is van het CT omdat ze het al kunnen. Leerlingen die in de eerste en twee cognitieve fase zitten meer profijt hebben van het leren programmeren als zij eerst bekend worden met de methode en het materiaal en vervolgens kleine problemen oplossen (Flannery & Bers, 2013). Het tastbaar programmeren draagt bij aan de samenwerking binnen de groep (Chambers, Carbonaro & Rex, 2007; Lindh & Holgersson, 2005).
Het effect van unplugged programmeren op het computational thinking Unplugged programmeren is het programmeren waarbij er geen gebruik wordt gemaakt van technologie. Net zoals in het visueel en het tastbaar programmeren leren leerlingen wat de logica achter het programmeren is. Leerlingen maken kennis met de programmeerconcepten en –strategieën door het spelen van verschillende spellen. Hierbij kan er gedacht worden aan een spel waarbij leerlingen in groepen van twee elkaar instructies geven waarbij een van de leerlingen geblindoekt is. De leerling die instructies geeft stelt de input voor en de leerling die geblindoekt is voert deze instructies uit en stelt dus de output voor. Of een spel waarbij leerlingen
Een methode die vaak wordt gebruikt bij het unplugged programmeren is Computer Science Unplugged (CSU) (Bell, 1998). Dit is ook de methode die in veel studies wordt onderzocht als er onderzoek wordt gedaan naar het unplugged programmeren. Binnen dit hoofdstuk wordt er daarom geanalyseerd wat het effect van de CSU methode op het computational thinking is. Niet alle onderdelen van de CSU methode zijn binnen deze analyse meegenomen. Het is namelijk een methode met een breed onderwerpsveld, zo komt de werking van een computer ook aan bod in deze methode. Binnen deze analyse wordt er alleen gekeken naar onderdelen die aansluiten bij het CT kader van Brennan en Resnick (2012).
In het primair onderwijs blijken er nog niet veel studies te zijn die expliciet onderzoek hebben gedaan naar het effect van unplugged programming op de ontwikkeling van CT. Er is wel onderzoek gedaan naar het effect van unplugged programming in combinatie met het visueel en het tastbaar programmeren. Om toch een beeld te geven van wat het effect van het unplugged programmeren zou kunnen zijn, zijn deze studies meegenomen in de analyse. Er zijn drie studies binnen het primair onderwijs geanalyseerd (Wohl, Porter & Clinch, 2015; Sabitzer, Antonitsch &
Pasterk, 2014; Capay, 2015) en zes studies binnen het secundair onderwijs (Feaster, Segars, Wahba & Hallstrom, 2011; Taub, Ben-Ari & Armoni, 2009; Thies, 2012; Nishida, Idosaka, Hofuku, Kanemune & Kuno, 2008; McInerney, 2010; Voigt, Bell & Aspvall, 2009).
Primair onderwijs (Wohl, Porter & Clinch, 2015; Sabitzer, Antonitsch & Pasterk, 2014; Capay, 2015)
Programmeerconcepten. Het unplugged programmeren heeft een effect op de mate waarin leerlingen het begrip algoritmen begrijpen (Wohl, Porter & Clinch, 2015). Maar of leerlingen een ontwikkeling laten zien in het toepassen van steeds complexere vormen van algoritmen is niet vanzelfsprekend (Sabitzer, Antonitsch & Pasterk, 2014). Leerlingen passen eerder de basisuitvoering toe in plaats van een stapje hoger te gaan. Zij stellen dat leerlingen niet bekend zijn met “these formalized forms of data representation”. En daarom is het belangrijk om ervoor te zorgen dat leerlingen niet alleen makkelijke opdrachten maken om een programmeerconcept te leren begrijpen. Er zou standaard opbouw moeten zijn waar leerlingen met hetzelfde programmeerconcept te maken hebben, maar met een opdracht die moeilijker is. Het is belangrijk om ervoor te zorgen dat er een toenemende moeilijkheidsgraad is om de ontwikkeling van het begrip van algoritmen te stimuleren.
Programmeerstrategieën. Net zoals in de vorige hoofdstukken wordt ook bij het unplugged programmeren het testen en debuggen aangeleerd. In de studie van Wohl, Porter en Clinch (2015) wordt dit gedaan door deze strategie aan het begin van het onderzoek uit te leggen aan de hand van een voorbeeld. Leerlingen krijgen hier de opdracht om met hun ogen dicht stap voor stap door de algoritme te gaan om zo erachter te komen waar het mis is gegaan. Vervolgens wordt het spel ‘Simon zegt’ gespeeld. Hierbij geeft een leerling instructies aan een mede-leerling.
Dat leerlingen in staat zijn om het spel ‘Simon zegt’ te spelen impliceert dat dit unplugged programmeren een effect heeft op het begrip van zowel de debug-strategie als de hergebruik-debug-strategie. Want leerlingen zijn hier in staat om de kennis die zij aan het begin van het onderzoek hebben opgedaan in dit spel toe te passen.
Perspectieven. Leerlingen zijn over het algemeen actief betrokken bij het unplugged programmeren (Capay, 2015). Uit de resultaten blijkt dat leerlingen allemaal even goed werken. Er is wel verschil in de hoeveelheid tijd die zij nodig hebben om een probleem op te lossen.
Secundair onderwijs (Feaster, Segars, Wahba & Hallstrom, 2011; Taub, Ben-Ari & Armoni, 2009; Thies, 2012; Nishida, Idosaka, Hofuku, Kanemune & Kuno, 2008; McInerney, 2010; Voigt, Bell & Aspvall, 2009)
Programmeerconcepten. Een onderdeel dat vaak terugkomt in het onderwijzen van unplugged programmeren is het aanleren van algoritmen. Dit wordt gedaan aan de hand van het spel ‘Battleships’ waar de leerling moet uitzoeken waar een boot met een bepaald nummer ligt. Alleen de mede-leerling weet wat de locatie van deze boot is (Thies, 2012; Nishida et al., 2008; McInerney, 2010). Leerlingen leren hier verschillende algoritmen om deze boot te zoeken. Ze kunnen er bijvoorbeeld voor kiezen om lineair te zoeken (alle verschillende nummers af gaan tot het juiste nummer is gekozen) of ze kunnen ervoor kiezen om binair te zoeken (hierbij wordt er het middelste nummer gekozen, vervolgens het middelste nummer van dit nummer, totdat het juiste nummer is gekozen). Uit de resultaten blijkt dat leerlingen in staat zijn om dit spel uit te spelen. In het onderzoek van McInerney (2010) lijken leerlingen het spel in het begin niet te begrijpen. Maar naarmate ze het spel vaker spelen worden ze er beter in. Bovendien leren de leerlingen hier ook samen te werken. Uit de verschillende studies wordt er echter niet genoemd of leerlingen algoritmen ook begrijpen. Er wordt wel genoemd dat er maar een paar momenten waren tijdens het spel waar leerlingen iets niet snapten, maar dit gebeurde maar twee keer (McInerney, 2010).
De bovenstaande resultaten zijn tegenstrijdig met het resultaat uit de studie van Feaster et al. (2010). Hier blijkt er geen significant effect te zijn. Een mogelijke verklaring die hier wordt genoemd is dat leerlingen binnen het secundair onderwijs die al eerder informatica les hebben gehad het unplugged programmeren niet nuttig vinden. Omdat ze veel dingen al weten en snappen. Daarom is het ook belangrijk om rekening te houden met wat een leerling al wel en niet weet. Een andere verklaring is dat leerlingen de spellen uit de unplugged programmeermethode niet nuttig vinden omdat ze niet zien waar het goed voor is. Binnen het onderzoek werd er namelijk genoemd dat leerlingen het lastig vinden om een koppeling te maken tussen de programmeerconcepten en dat wat zij in een spel leren (Feaster et al., 2010). In dit geval zou het van belang zijn om leerlingen te ondersteunen in het maken van deze connectie.
Programmeerstrategieën. Er blijkt weinig aandacht te zijn voor de ontwikkeling van het gebruik van programmeerstrategieën. Thies (2012) heeft het
over de CSU methode en stelt dat “it is almost impossible to achieve learning objectives related to metacognitive knowledge, especially not for the younger part”. Met metacognitieve kennis bedoelt hij de kennis die leerlingen hebben om een probleem op te lossen. Er bestaat wel een spel (card flip magic) waar leerlingen zich bewust worden van manieren waarop zij veranderingen of fouten kunnen ontdekken (Voigt, Bell & Aspvall, 2009). Dit spel wordt gespeeld met kaarten die aan een kant zwart zijn en aan de andere kan wit. In het spel krijgt de leerling een aantal van deze kaarten te zien, deze worden in een willekeurige volgorde neergelegd, een van deze kaarten wordt omgedraaid (de leerling ziet niet welke) en vervolgens moet de leerling raden welke kaart dit is geweest. Leerlingen blijken hierdoor significant meer juiste antwoorden te geven op de post-test.
Perspectieven. In het onderzoek van Taub, Ben-Ari en Armoni (2009) werd er onderzocht of de spellen uit het unplugged programmeren invloed heeft op het perspectief dat leerlingen op het programmeren hebben en van het informatica-werkveld. Hieruit blijkt dat dit niet het geval is. Zij stellen dat er meer aandacht moet komen voor het niveau van de leerling en het perspectief dat ze hebben van de informatica. Om vervolgens op dit niveau en dit perspectief voort te bouwen. Hierdoor
In het onderzoek van Nishida et al. (2008) laten een aantal leerlingen een negatieve houding zien naar het unplugged programmeren. Ze noemen dat ze het niet leuk vonden omdat het spel te moeilijk was.
Conclusie
Het unplugged programmeren heeft een effect op het begrip dat leerlingen van algoritmen ontwikkelen. Maar het is niet vanzelfsprekend dat leerlingen zich hier in blijven ontwikkelen (Sabitzer, Antonitsch & Pasterk, 2014). Daarom is het belangrijk om aandacht te hebben voor een toenemende moeilijkheidsgraad om ervoor te zorgen dat leerlingen dingen blijven leren over algoritmen.
In het secundaire onderwijs is er ook sprake van een ontwikkeling van het begrip van algoritmen (Thies, 2012; Nishida et al., 2008; McInerney, 2010). Hier zijn leerlingen bezig met unplugged programmeren door het spel ‘Battleships’. Met uitzondering van een studie die gedaan is in een informaticaklas waar leerlingen al bezig waren met programmeren voor het unplugged programmeren (Feaster et al., 2010). Een mogelijke verklaring hier is dat deze leerlingen het unplugged programmeren niet nuttig vonden omdat ze de meeste concepten al kennen. Ook hier
blijkt dus dat het belangrijk is om op het niveau van een leerling aan te sluiten om een ontwikkeling te stimuleren. Een aandachtspunt bij het aanleren van programmeerconcepten is het maken van een koppeling tussen het programmeerconcept en dat wat een leerling leert.
Het effect van het unplugged programmeren lijkt een hulpmiddel op zich om de debug-strategie te ontwikkelen. In tegenstelling tot het visueel en het tastbaar programmeren waar er vaak hulpmiddelen aanwezig moeten zijn om een effect te hebben op de ontwikkeling van programmeerstrategieën. Een zo’n spel is bijvoorbeeld ‘Card flip magic’. Hier krijgen leerlingen een aantal zwarte en witte vierkanten te zien. Ze krijgen een aantal minuten de tijd om deze te observeren, dan moeten ze hun ogen dicht doen, een van vierkantjes wordt veranderd en de leerlingen moeten aangeven welke dit is. De debug-strategie hier is kijken waar er onregelmatigheden zijn in het zwart-witte patroon van vierkanten en deze onthouden.
Bij het unplugged programmeren wordt er ook ondersteuning geboden om de debug-strategie te ontwikkelen. Om een probleem op te lossen doen leerlingen hun ogen dicht om zo stap voor stap door de algoritme te gaan.
Het doel van het unplugged programmeren is het beïnvloeden van het perspectief dat leerlingen hebben van het programmeren. Dit doen ze door concepten en strategieën aan te leren in de vorm van spellen. Leerlingen ontwikkeling wel een positieve houding naar het unplugged programmeren zelf. Maar er blijkt geen ontwikkeling te zijn in het perspectief dat leerlingen over het programmeren over het algemeen hebben (Taub, Ben-Ari & Armoni, 2009).
Wat voor effect het programmeren heeft op CT hangt af van de manier waarop het programmeren is vorm gegeven in de klas. In verschillende studies wordt er genoemd dat de inrichting van de omgeving een grote bijdrage levert aan het succes (of het falen). De leerlingen in het onderzoek van Wohl, Porter & Clinch (2015) de mogelijkheid om even terug te gaan naar wat ze precies hadden geleerd aan het begin van het onderzoek. Hierdoor konden ze dit waarschijnlijk makkelijker toepassen.
Conclusie en discussie
Het ontwikkelen van het CT wordt als een belangrijke vaardigheid gezien voor in de huidige en toekomstige samenleving. Het tekstueel programmeren heeft een positief effect op de ontwikkeling van dit CT. Deze vorm van programmeren is echter moeilijk voor leerlingen binnen het primair en het secundair onderwijs. Dit komt mogelijk door de onbekende taal van het programmeren dat hier wordt gebruikt. Een andere optie om leerlingen het programmeren toch aan te leren is door het gebruik van programmeersyntax waarbij leerlingen niet te maken hebben met codes, maar met visuele representaties van stukjes code of met concrete materialen. Dit is mogelijk door het visueel en tastbaar programmeren. Daarnaast stelt Wing (2006) dat het ook mogelijk is om het CT te ontwikkelen zonder te programmeren. Binnen dit literatuuronderzoek werd in kaart gebracht welke uitvoeringen van visueel, tastbaar en unplugged programmeren een effect hebben op het CT van leerlingen binnen het primaire en het secundaire onderwijs. In de volgende alinea’s worden de bevindingen van dit literatuuronderzoek besproken, de sterke en de zwakke punten van het onderzoek op een rij gezet, implicaties voor het onderwijs en aanbevelingen voor vervolgonderzoek gegeven.
Uit de resultaten blijkt dat begeleiding en aansluiting op het juiste niveau de belangrijkste factoren zijn die bijdragen aan een ontwikkeling van zowel het visueel, tastbaar als het unplugged programmeren (Sabitzer, Antonitsch & Pasterk, 2014; Lindh & Holgersson, 2005). Het visueel programmeren heeft voornamelijk invloed op de ontwikkeling van algoritmen. Het is hier wel belangrijk om aan te sluiten op het niveau van de leerling. Ook uit het onderzoek naar het effect van tastbaar programmeren blijkt dat begeleiding en aansluiting op niveau essentieël is. Leerlingen hebben vaak moeite met begrijpen hoe het tastbaar programmeren werkt. En als ze geen vooruitgang zien zijn ze snel hun aandacht kwijt. Het unplugged programmeren heeft ook een effect op de ontwikkeling van het begrip van algoritmen. Een aandachtspunt hier is het begeleiden van de leerling met het maken van een koppeling tussen het programmeerconcept en het Computer Science Unplugged spel. Dit geldt voor de meeste studies die zijn geanalyseerd. Er is een uitzondering bij een groep die al bekend was met de programmeerconcepten. Zij vonden het waarschijnlijk niet nuttig. Hier ook het belang van aansluiting op niveau, op wat ze al wel en niet weten. Er zijn verschillende vormen van begeleiding die effectief blijken te zijn. Allereerst is het gebruik van flowcharts een handig hulpmiddel om leerlingen te
ondersteunen in het structureren van hun ideeën (Chambers, Carbonaro & Rex, 2007). Een ander hulpmiddel is het bijhouden van een logboek door de leerling. Hierdoor heeft de leerkracht zicht op waar de leerling tegenaan loopt en kan er adequaat worden ingegrepen indien nodig.
Een programmeerstrategie die in bijna elk onderzoek terugkomt is de ontwikkeling van het testen en debuggen door het programmeren. De studies verschillen in hoe zij de ontwikkeling van deze strategie hebben gestimuleerd. Bij het visueel programmeren wordt het reflecteren op het leerproces als hulpmiddel genoemd (zelfreflectie of reflectie op basis van feedback) (Lai & Yang, 2011; Calder, 2010; Wang, Huan & Wang, 2014). Bij het tastbaar programmeren is het systematisch nadenken een hulpmiddel dat vaak terugkomt (Flannery & Bers, 2013; Sipitakiat & Nusen, 2012; Wyeth, 2008) of het reflecteren (Sullivan, 2007). In tegenstelling tot het visueel en tastbaar programmeren lijkt het unplugged programmeren een hulpmiddel opzich om de ontwikkeling van de debug-strategie te stimuleren.
Het effect van programmeren op de ontwikkeling van het perspectief van leerlingen blijkt niet altijd zo duidelijk te zijn. Over het algemeen is er een positieve ontwikkeling te zien in de houding die leerlingen naar het programmeren hebben (Lai & Yang, 2011; Wang, Huan & Hwang, 2014), in het vertrouwen in het eigen kunnen in Scratch (Kalelogliu & Gulbahar, 2014) en in het samenwerken (Calder, 2010; Chambers, Carbonaro & Rex, 2007; Lindh & Holgersson, 2005). Er zijn echter wel een aantal uitzonderingen leerlingen waar er geen ontwikkeling te zien is (Taub, Ben-Ari & Armoni, 2009)
Om antwoord te geven op de vraag wat het effect van visueel, tastbaar en unplugged programmeren het CT is, kan er gezegd worden dat het programmeren een effect heeft op de ontwikkeling van het CT. Een voorwaarde is hier wel dat er goede begeleiding bij aanwezig is en het programmeren op het niveau van de leerling wordt aangeboden. Dit is vooral belangrijk bij het onderwijs van tastbaar programmeren aan jonge leerlingen. Daarnaast hebben zij het nodig om veel te kunnen oefenen met het tastbaar programmeren om zo het probleemoplossend vermogen te ontwikkelen. Dit zijn dus ook de punten waar rekening mee gehouden moeten worden bij het implementeren van het visueel, tastbaar en unplugged programmeren binnen het onderwijs. Voorbeelden van hulpmiddelen die gebruikt kunnen worden bij het onderwijzen van het visueel en het tastbaar programmeren zijn het reflecteren, debugmodellen, scaffolding, flowcharts en Project Based Learning.
Een sterk punt van dit onderzoek is dat de doelgroepen uit de geanalyseerde studies een brede leeftijdsgroep bestaat. Hierdoor werd duidelijk voor welke leeftijdsgroepen het visueel, tastbaar en unplugged programmeren waarschijnlijk wel effectief zal zijn (en in welke leeromstandigheden) en voor welke leeftijdsgroepen dit niet effectief zal zijn (of waar er rekening mee gehouden moet worden). Er is echter ook een beperking in dit onderzoek. De geanalyseerde studies gaan namelijk over het onderwijs in verschillende landen. Hierdoor is er sprake van verschillende onderwijssystemen en deze kunnen impliciet invloed hebben op de uitvoering van het visueel en het tastbaar programmeren in het onderwijs. In vervolgonderzoek zou er daarom een groep scholen geanalyseerd moeten worden die hetzelfde onderwijssysteem hebben of waarvan de onderwijssystemen bijna hetzelfde zijn.
Een ander punt dat interessant kan zijn voor vervolgonderzoek is het effect van het tastbaar programmeren binnen het Montessori onderwijs. Uit de geanalyseerde studies blijkt dat het tastbaar programmeren vaak gekoppeld wordt aan de theorie van Piaget. Piaget stelt dat leerlingen pas echt leren als zij hier actief mee bezig zijn. Een van de uitgangspunten binnen het Montessori onderwijs is dat leerlingen vaardigheden efficiënter leren als cognitie en fysieke beweging gecombineerd worden (Montessori, 1912). In tegenstelling tot het traditionele onderwijs waar leerlingen vaak passief leren, wordt er binnen het Montessori onderwijs actief geleerd. Het is mogelijk dat leerlingen uit het Montessori onderwijs al overweg kunnen met het tastbaar programmeren omdat zij al vanaf het eerste schooljaar bezig zijn met actief leren.
Uit dit onderzoek kan worden meegenomen dat visueel, tastbaar en unplugged programmeren een effect heeft op de ontwikkeling van het CT. Maar het is hier wel belangrijk dat er wordt aangesloten op het niveau van de leerling en dat er goede begeleiding aanwezig is. Daarnaast blijkt het unplugged programmeren vooral effectief te zijn in het secundaire onderwijs.
Literatuurlijst
Bell, T. C., Witten, I. H., & Fellows, M. R. (1998). Computer Science Unplugged:
Off-line activities and games for all ages. Computer Science Unplugged. Brennan, K., & Resnick, M. (2012). New frameworks for studying and assessing the
development of computational thinking. In Proceedings of the 2012 annual meeting of the American Educational Research Association, Vancouver, Canada.
Brown, Q., Mongan, W., Kusic, D., Garbarine, E., Fromm, E., & Fontecchio, A. (2013). Computer aided instruction as a vehicle for problem solving: Scratch programming environment in the middle years classroom.
Calao, L. A., Moreno-León, J., Correa, H. E., & Robles, G. (2015). Developing Mathematical Thinking with Scratch. In Design for Teaching and Learning in a Networked World (pp. 17-27). Springer International Publishing.
Calder, N. (2010). Using Scratch: An Integrated Problem-Solving Approach to Mathematical Thinking. Australian Primary Mathematics Classroom, 15(4), 9-14.
Cápay, M. (2015). Engaging games with the computer science underlying concepts. In Interactive Collaborative Learning (ICL), 2015 International Conference
on (pp. 975-979). IEEE.
Chambers, J., Carbonaro, M., & Rex, M. (2007). Scaffolding knowledge construction through robotic technology: A middle school case study.Electronic Journal for the Integration of Technology in Education, 6, 55-70.
Flannery, L. P., & Bers, M. U. (2013). Let’s dance the “robot hokey-pokey!” children’s programming approaches and achievement throughout early cognitive development. Journal of research on technology in education,46(1), 81-101.
Feaster, Y., Segars, L., Wahba, S. K., & Hallstrom, J. O. (2011). Teaching CS unplugged in the high school (with limited success). In Proceedings of the
16th annual joint conference on Innovation and technology in computer science education (pp. 248-252). ACM.
Grover, S., & Pea, R. (2013). Computational Thinking in K–12 A Review of the State of the Field. Educational Researcher, 42(1), 38-43.
Kalelioğlu, F., Gülbahar, Y., Akçay, S., & Doğan, D. (2014). Curriculum integration ideas for improving the computational thinking skills of learners through
programming via scratch. In Local proceedings of the 7th international conference on informatics in schools: Situation, evolution and perspectives (pp. 101-112).
Kelleher, C., & Pausch, R. (2005). Lowering the barriers to programming: A taxonomy of programming environments and languages for novice programmers. ACM Computing Surveys (CSUR), 37(2), 83-137.
Kennedy, L., & Tipps, S. (1994). Guiding children'slearning of mathematics , Belmont, CA: Wadswort h.
KNAW (2012). Digitale geletterdheid in het voortgezet onderwijs: Vaardigheden en attitudes voor de 21ste eeuw. Amsterdam: KNAW.
Lai, A. F., & Yang, S. M. (2011). The learning effect of visualized programming learning on 6 th graders' problem solving and logical reasoning abilities. In Electrical and Control Engineering (ICECE), 2011 International Conference on (pp. 6940-6944).
Leron, U. (1983). Structuring mathematical proofs. The American Mathematical Monthly, 90(3), 174-185.
Lindh, J., & Holgersson, T. (2007). Does lego training stimulate pupils’ ability to solve logical problems?. Computers & education, 49(4), 1097-1111.
Lu, J. J., & Fletcher, G. H. (2009). Thinking about computational thinking.ACM
SIGCSE Bulletin, 41(1), 260-264.
Lye, S. Y., & Koh, J. H. L. (2014). Review on teaching and learning of computational thinking through programming: What is next for K-12?.Computers in Human
Behavior, 41, 51-61.
Manches, A., O’Malley, C., & Benford, S. (2010). The role of physical representations in solving number problems: A comparison of young children’s use of physical and virtual materials. Computers & Education,54(3), 622-640.
McInerney, C. (2010). Having fun with computer programming and games: teacher and student experiences. In International Conference on Informatics in
Secondary Schools-Evolution and Perspectives (pp. 136-142). Springer Berlin
Heidelberg.
McNerney, T. S. (2004). From turtles to Tangible Programming Bricks: explorations in physical language design. Personal and Ubiquitous Computing, 8(5), 326-337.
Nishida, T., Idosaka, Y., Hofuku, Y., Kanemune, S., & Kuno, Y. (2008). New methodology of information education with “computer science unplugged”. In International Conference on Informatics in Secondary Schools-Evolution
and Perspectives (pp. 241-252). Springer Berlin Heidelberg.
Oluk, A., & Saltan, F. (2015). Effects of Using the Scratch Program in 6th Grade Information Technologies Courses on Algorithm Development and Problem Solving Skills.
Onderwijs2032, P. (2016). Ons onderwijs2032: Eindadvies.
Papert, S. (1980). Mindstorms: Children, computers, and powerful ideas. Basic Books, Inc.
PW de Gids. (2016, 01 juni). Manager snapt zelfsturing (nog) niet. PW de Gids. Geraadpleegd van http://pwdegids.nl/artikel/manager-snapt-zelfsturing-nog/
Resnick, M., Maloney, J., Monroy-Hernández, A., Rusk, N., Eastmond, E., Brennan, K., Millner, A., Rosenbaum, E., Silver, J., Silverman, B. and Kafai, Y. (2009). Scratch: programming for all. Communications of the ACM, 52(11), 60-67.
Thijs, A., Fisser, P., & Hoeven, M. van der (2014). 21e eeuwse vaardigheden in het curriculum van het funderend onderwijs. Enschede: SLO.
Voogt, J., Fisser, P., Good, J., Mishra, P., & Yadav, A. (2015). Computational thinking in compulsory education: Towards an agenda for research and practice. Education and Information Technologies, 20(4), 715-728.
Resnick, M., Maloney, J., Monroy-Hernández, A., Rusk, N., Eastmond, E., Brennan, & Kafai, Y. (2009). Scratch: programming for all. Communications of the ACM, 52(11), 60-67.
Sabitzer, B., Antonitsch, P. K., & Pasterk, S. (2014). Informatics concepts for primary education: preparing children for computational thinking. In Proceedings of
the 9th Workshop in Primary and Secondary Computing Education (pp.
108-111). ACM.
Selwyn, N. (2011). Education and technology: Key issues and debates. A&C Black. Sipitakiat, A., & Nusen, N. (2012). Robo-Blocks: designing debugging abilities in a
tangible programming system for early primary school children. In Proceedings of the 11th International Conference on Interaction Design and Children (pp. 98-105). ACM.
