Hoe leer je eigenlijk programmeren?
Als ik te brak ben om over softwareontwikkeling te lezen tijdens mijn ontbijt (de wekker gaat vroeg als mijn vrouw een ochtenddienst heeft), zet ik een filmpje op YouTube op.
Laatst keek ik deze van Felienne Hermans, universitair docent op het Leiden Institute of Advanced Computer Science:
Het was een prettig ontbijt, want Hermans is een enthousiaste, aanstekelijke spreekster. Een aantal jaar geleden zag ik haar op een conferentie in Arnhem, waar ze haar toehoorders aanspoorde hun code eens door een poëtische bril te bekijken. Erg gecharmeerd van de dichterlijke kwaliteiten van mijn eigen code ben ik niet, maar het zou zomaar kunnen dat haar vrolijke lezing het zaadje bij mij plantte waar een stuk of wat hopelijk humoristische haiku’s over softwareontwikkeling uit zijn gegroeid (en laterna ook wat sonnetten).
Experimenteer, maak fouten
Maar ook los van haar koddige presentatiestijl is de video hierboven de moeite waard. Een vraag die Hermans in haar lezing opwerpt, is hoe iemand leert programmeren. Ze stelt deze vraag naar aanleiding van een persoonlijke anekdote over de tijd dat ze jonge kinderen lesgaf over het onderwerp. Ze geeft ruiterlijk toe, als onbewust onbekwame leraar, in eerste instantie terug te vallen op de manier waarop ze zelf leerde programmeren: door het te doen. Anders gezegd: begin maar een applicatie te bouwen, en laten we hopen dat je leert van de fouten die je onderweg onvermijdelijk zult maken.
Dat Hermans zo leerde programmeren, hoeft niet te verbazen. Het was vóór de tijd van YouTube-tutorials en helpende handjes op Stack Overflow. Het enige wat ze had was een boek waar ze code uit kon overtypen. En als ze afweek van het voorbeeld en iets stukmaakte, moest ze zelf uitvinden waar het mis was gegaan.
Maar deze manier van leren is niet beperkt gebleven tot de tijd waarin Hermans zich het vak eigen maakte. Ze geeft enkele voorbeelden van lesboeken voor kinderen waarin hetzelfde sentiment expliciet wordt overgedragen: experimenteer, maak fouten en probeer daarvan te leren. Soms geven de auteurs zelfs toe: programmeren is vaak moeilijk en frustrerend. Daarmee implicerend: en er is niets wat we daar aan kunnen doen.
Ontdekkend leren
In de onderwijswereld bestaat er een term voor de manier van leren die Hermans beschrijft: ontdekkend leren. Het idee achter die theorie is dat je meer leert van de dingen die je ervaart, dan van de dingen die anderen je vertellen. Met andere woorden: je leert meer uit de eerste dan uit de tweede hand, of: ervaring is de beste leraar.
Er zit een kern van waarheid in die theorie, dat kan iedereen bevestigen die ooit goed advies de wind in heeft geslagen. Soms is het nodig om sommige lessen te ervaren, in plaats van ze slechts aan te horen, om ze je eigen te kunnen maken.
Maar is ontdekkend leren de beste manier om te leren programmeren? Te oordelen naar het succes van haar leerlingen, concludeert Hermans: nee, bepaald niet.
Stressvol
En haar ervaring kan ik onderschrijven. Ik heb leren programmeren tijdens een acht wekend durende cursus, die eindigde met de presentatie van een bescheiden applicatie die ik en een medeleerling in elkaar hadden gehackt. Omdat onze ambities groter waren dan onze vaardigheden, waren dat behoorlijk stressvolle weken.
Toen ik daarna als amateurprofessional het werkveld in werd geslingerd, werd me aangeraden één dag in de week aan het coderen van demo-applicaties te besteden, om het vak in de vingers te krijgen. Ik herinner me die vrijdagen als frustrerend en vermoeiend. Ik schreef een paar regels code, stuitte op een probleem, kon daar uren op vastzitten en sloot, als ik pech had, de dag af zonder echte vooruitgang te hebben geboekt.
Heb ik dingen geleerd op die zelfstudiedagen? Jazeker. Vond ik het leuk om ze te leren? Meestal niet. De inzichten die je als totale nieuweling via ontdekkend leren opdoet, worden op zo’n pijnlijke manier verkregen, dat het afhakers nauwelijks kwalijk te nemen valt als ze hun heil ergens anders zoeken.
Leren van fouten
Er is geen enkel vak dat op dezelfde manier wordt onderwezen als programmeren, merkt Hermans op. Er is geen timmerman die zich de kneepjes van het vak eigen heeft gemaakt door maar gewoon te beginnen met zagen en kijken waar ‘ie uitkomt. Vóór je met je materiaal aan de slag gaat, moet je als timmerman voldoende kennis hebben van de gereedschappen en materialen waar je mee werkt, wil je iets voor elkaar krijgen.
En vooral: wil je leren van de fouten die je gaat maken. Iemand die maar iets doet, maakt fouten zonder op te merken dat ze gemaakt worden, zonder te weten waarom ze fout zijn, en zonder een idee te hebben wat er voor nodig is om ze recht te zetten. Wanneer de fout uiteindelijk opgemerkt wordt, is zo iemand hulpeloos, niet eens in staat hem te diagnosticeren, laat staan recht te zetten.
Experimenteren en fouten maken is zo moeilijk niet, als je niet weet waar je mee bezig bent. Maar zonder de vereiste achtergrondkennis is het heel moeilijk om lessen te kunnen trekken uit die fouten.
Vloek van kennis
Volgens mij lijden voorstanders van ontdekkend leren aan de vloek van kennis. Hun onbewuste bekwaamheid zorgt ervoor dat ze zich niet meer in kunnen leven in iemand die niet over dezelfde kennis, vaardigheden en aannames beschikt als zij.
Omdat ze zelf prima met experimenten uit de voeten kunnen, zien ze over het hoofd hoe hun advies overkomt op een nieuweling. Namelijk: als een zwaktebod. Als je zegt: “Experimenteer, maak fouten en leer daarvan”, dan horen nieuwkomers: “Ik weet niet (meer) hoe je dit leert, zoek het maar zelf uit.”
Begin
Wie iets nieuws leert, moet beginnen bij het begin. Wat is het begin? Niet iets bouwen, zoveel is duidelijk. We leren scholieren ook geen Frans door een verhaal in die taal te schrijven.
Vóórdat je kunt schrijven, moet je eerst leren lezen. Presenteer een nieuwe programmeur met stukken code, en leg uit wat daar staat. Als ze dat begrijpen, presenteer je ze nieuwe stukken code, en vraag je hen wat er staat. Op die manier ga je na of en hoe ze je uitleg hebben begrepen.
Je hebt achtergrondkennis nodig van programmeren in het algemeen en programmeertalen in het bijzonder, vóórdat je zelf kunt beginnen met programmeren. Dat is de les (of liever: één van de lessen) uit Hermans’ lezing.
Leren lezen
Na een hele tijd - hoe lang zal het zijn geweest? Een halfjaar? Een jaar? - frustrerend falen, besloot ik mijn zelfstudie over een andere boeg te gooien. In plaats van demo-applicaties te bouwen, besloot ik me in te lezen. Ik bestelde boeken via mijn werkgever over de breedst mogelijke reeks onderwerpen, en schreef op vrijdagen geen regel code meer.
En in plaats van tegen die dagen op te zien, keek ik naar uit. Hoe meer ik las, hoe beter ik begreep tegen welke dingen ik aan was gelopen. Hoe sterker het theoretisch kader van waaruit ik werkte, hoe makkelijker ik me de rest van de week door bugs en features heensloeg.
Want dat ontdekte ik ook: ik had die vrijdagen helemaal niet nodig om code te leren schrijven. Ik moest leren, lezen; code schrijven deed ik de rest van de week immers al!
De plek van ontdekkend leren
Is er dan helemaal geen plek voor ontdekkend leren? Jawel, maar alleen voor hen die over voldoende kennis beschikken om te kunnen leren van hun experimenten. De rest doet er goed aan zich te bezinnen, vóór ze code beginnen te schrijven.
Ontdekkend leren de default maken, is een goede manier om potentieel vaardige programmeurs in een vroeg stadium af te schrikken. We kunnen en moeten beter dan dat. Hoe? Daar ben ik nog niet uit. Maar Hermans' boek, The Programmer’s Brain staat bij dezen op mijn verlanglijstje.