Selecteer een pagina

 

Ik leer mezelf JavaScript, met een boek (zie boven). Het gaat langzaam, heel erg langzaam. Ik zit nu zelfs een beetje vast. Ik snap de code hierboven, maar ik heb mezelf opgedragen om het dieper te snappen dan ik het nu snap. Het wordt straks alleen nog maar moeilijker, en dan is het beter om een goede basis te hebben en niet te snel over dingen heen te stappen.

Als je geen zin hebt in wat uitleg over programmeren, kun je het cursieve stuk overslaan.

Over dat plaatje hierboven. Dat gaat over recursie, het Droste effect zeg maar. Een stukje code dat steeds zichzelf oproept totdat het een resultaat heeft. De opdracht is om bijvoorbeeld 24 te vinden door te beginnen met 1, en dan OF +5 te doen OF *3. Dat doet de code hierboven door eerst +5 te doen.  Als het dan nog niet bij 24 is, roept het zichzelf op, en komt dus weer bij de keuze om +5 te doen of *3. Die * 3 komt pas aan bod als de +5 zijn doel voorbij schiet (groter dan 24).  Intussen houdt de code ook nog bij welke stappen er gemaakt zijn door aan het zinnetje dat de oplossing moet laten zien (hierboven ‘history’ geheten) steeds +5 of *3 toe te voegen (met haakjes).

Het zoeken naar de oplossing gaat dus op een domme manier: gewoon alle mogelijkheden uitproberen tot je er eentje vindt die het goede antwoord geeft. Geen slimme shortcuts. Geen spoortje kunstmatige intelligentie. Makkie dus. Maar toch.

Wat me dwars zit is dat je een hele reeks foute +5-en en *3-en doet voordat je bij de goede oplossing komt. Dus steeds als je een doodlopende weg tegenkomt, moet je de boel weer oprollen en terug naar de splitsing die je nog niet uitgeprobeerd hebt. Dus de code heeft bijvoorbeeld  1+5+5+5+5+5+5 “genoteerd” in de ‘history’ en komt er dan pas achter dat dit niet werkt. Het moet al die verkeerde stappen als het ware weer vergeten en uitgaan van het punt waarop het opnieuw begint, en de ‘history’ die daarbij hoort.

Javascript onthoudt die dingen voor je. Elke keer als je een functie aanroept (een stukje code dat is voor je doet en dan het antwoord terug geeft) onthoudt het de beginsituatie. Dat heet een “STACK”. Mooi woord want het stapelt steeds gevevens van de nieuwste situatie bovenop de oude, en het kan er ook weer stuk voor stuk afhalen, zodat die ‘history’ niet ook nog alle foute geprobeerde oplossingen aangeeft. JavaScript weet dus waar je gebleven bent. Dus het doet wel die eindeloze plus vijven (en zelfs de nodige *3en tussendoor) maar daar merk je niks van, het antwoord dat je krijgt is “+ 5 gaat hem niet worden” (NULL in computertaal, niet te verwarren met 0) . Het heeft een stapeltje briefjes geschreven om bij te houden waar het is, en zelf ook weer het hele stapeltje één voor één afgelegd. Je hoeft je daar helemaal niet druk over hoeven maken.

Die || betekent OF. Maar het is in combinatie met de STACK wel een heel krachtige OF. Het zegt: “als die +5 na al dat uitproberen niks wordt, vergeet al dat uitproberen , gooi alles wat je aan oplossingen opgeschreven hebt maar weg en doe dan maar * 3  en dan gaan we op dezelfde voet vrolijk verder”

Mooi, maar dat is voor mij een black box die ik wil begrijpen. Hiervoor programmeerde ik in Basic, en die taal hield dat allemaal niet voor me bij, die had niet zo’n mooie || . Ik moest zelf zorgen dat de gegevens van elke stap bijgehouden werden, en ik moest er zelf voor zorgen dat alles wat bijgehouden werd én dat op niks uitliep ook weer verdween.

Wat ik nu aan het doen ben is de code hierboven aan het herschrijven in mijn eigen oude basic, zodat ik snap hoe die STACK van JavaSvript werkt. Ik raak steeds verdwaald. In welke lus zit ik, en hoe geef ik de juiste informatie door die zowel werkt op de heenweg, als bij het stap voor stap terugrollen. Ik moet nu zelf tegen de computer zeggen: “dat laatste stapje moet je even vergeten, we beginnen opnieuw, we zitten bij stap 5, we waren bij antwoord 26, we hebben net +5+5+5+5+5 gedaan, vergeet die maar, we gaan terug naar stap 4 en we gaan nu +5+5+5+5* 3 proberen.” (Had ik al gezegd dat deze code de domme aanpak gebruikte?)

Ik breek echt mijn hoofd hier op, en ik weet dat het antwoord uiteindelijk simpel en elegant is. Ik ben nu zover dat ik post-its ga kopen om letterlijk een stapeltje, een STACK te maken.

Ik ben er nu al dagen mee bezig. En áls het me lukt dat heb ik nog al die accolades, haakjes en puntkomma’s  om aan te wennen. Ik heb er laatst een hele dag over gedaan om uit te vinden dat mijn code niet werkte omdat ik ergens = had getypt in plaats van ==. 

Soms raak in een beetje ontmoedigt.

 

Geef niet op.

Dat is een mooie, maar dat betekent dat ik het volgende moet kunnen:

  1. Omgaan met mijn frustratie. Ik bedenk iets, vergeet ergens rekening mee te houden, en moet dan gaan zoeken wat ik over het hoofd zag. Ik moet ook leren om niet te mezelf te zeggen dat het dom was dat ik dat niet eerder zag. Ik begin hier steeds beter in te worden. 
  2. Accepteren dat dit moeilijke tijden zijn die ervoor zorgen dat mijn concentratie niet altijd even scherp is. Ik moet af en toe alles helemaal wegleggen en iets anders gaan doen, soms zelfs voor de rest van de dag. Ook dit begin ik te leren.
  3. Accepteren dat mijn hersenen door alle burn-outs en door mijn leeftijd gewoon een stuk minder scherp zijn.
    Dát is de moeilijke. Dat betekent steeds balanceren tussen hoop en verdriet. Hoop dat ik door bezig te zijn weer scherper wordt en verdriet vanwege het afscheid nemen van dingen die me niet meer (zo snel) lukken.

Ik leer JavaScript maar intussen leer ik hele andere dingen. Misschien leer ik voor het eerst in mijn leven wel wat leren nu eigenlijk is.

 

 

Naschrift:

Een dag later . . .  so much for “elegant en simpel”
Ik ben zover dat hij keurig het rijtje +5  afwerkt, tot 26. Hij gaat dan ook nog netjes een stapje terug en doet dan 20 * 3 . . .  en daar blijft het hangen.

We blijven lekker doormodderen

 

 

halve dag later …. alweer een stuk verder
Dit begint er op te lijken.
Morgen kijken waarom de laatste stap fout gaat.