Computationeel denken: oplossingen plannen voordat je programmeert

Computationeel denken betekent dat je een probleem en de oplossing duidelijk genoeg beschrijft om die uit te voeren. Een mens, een computer of allebei kunnen het plan volgen. Informaticus Jeannette Wing hielp de term bekend te maken bij een breed publiek in een essay uit 2006.

Vier werkwijzen die samenwerken

Deze werkwijzen zijn geen stappen die je in één vaste volgorde moet afronden. Terwijl je instructies schrijft, kun je een ontbrekend onderdeel opmerken. Dan ga je terug naar decompositie. Sommige cursussen noemen ook generalisatie, patronen omzetten in bredere regels, en evaluatie, een oplossing beoordelen.

Plan een bakverkoop voor de klas

Begin met de taak op te splitsen: kies producten, bepaal prijzen, maak bordjes, handel geld af en ruim op. Elk onderdeel heeft nu een kleiner doel.

Herken daarna een patroon. Elk product heeft ingrediënten nodig en moet worden gebakken, verpakt en van een etiket voorzien. Eén checklist kan voor meerdere producten dienen.

Voor de prijs behoud je de kosten van de ingrediënten en het aantal stuks. De kleur van de gebaksbordjes heeft geen invloed op deze prijsregel, dus laat je die weg. Die keuze is abstractie.

Schrijf nu het prijsalgoritme: “Deel de kosten van de ingrediënten door het aantal stuks. Rond naar boven af op de eerstvolgende 25 cent. Tel er 50 cent bij op.” Voor brownies waarvan de ingrediënten € 9,00 kosten voor 24 stuks:

1. Deel € 9,00 door 24. Dat is € 0,375 per stuk.
2. Rond naar boven af op € 0,50.
3. Tel er € 0,50 bij op. De verkoopprijs wordt € 1,00.

Voer het plan uit

Bij programmeren schrijf je instructies in een taal die een computer kan uitvoeren. Scratch gebruikt blokken; Python gebruikt tekst. Het plan kan al bestaan voordat je een van beide programma's maakt.

Voor een opdracht zonder computer gebruik je geen apparaat. Je kunt kaarten sorteren of een klasgenoot tekeninstructies geven. Met Bebraspuzzels oefen je deze vaardigheden ook. Bij een opdracht op een digitaal apparaat kun je het plan bijvoorbeeld omzetten in een Scratch-spel. Beide vragen om helder nadenken.

Door te plannen kun je fouten gemakkelijker vinden voordat veel code ervan afhangt. Met een schema of geschreven algoritme kunnen teamleden hetzelfde idee bespreken en het werk verdelen. Als iedereen vanuit een ander idee begint te programmeren, passen de voltooide onderdelen misschien niet op elkaar.

Een computer volgt de instructies die hij krijgt. Hij vult de ontbrekende stappen in je plan niet zelf aan.

“De klassenbibliotheek is een rommeltje” benoemt een probleem, maar laat veel vragen open. Zijn boeken moeilijk te vinden? Ontbreken er gegevens over uitgeleende boeken? Door het probleem te omschrijven maak je van die zorg een duidelijk doel voor benoemde gebruikers.

Stel vragen voordat je een oplossing kiest

Vraag bij vergeten huiswerk wie hulp nodig heeft, wat ze vergeten en wanneer ze een herinnering nodig hebben. Stel daarna kleinere vragen: welke vakken? Wie voert de inleverdatums in? Kunnen leerlingen al op een gezamenlijk bord kijken?

De antwoorden kunnen wijzen op een papieren agenda, een bord in de klas of een app. Als je eerst een app kiest, kan de werkelijke behoefte verborgen blijven. Houd het doel beperkt genoeg om het af te ronden, bijvoorbeeld brugklassers helpen het huiswerk voor morgen op één plek te zien.

Volg de informatie door de oplossing

Voor een huiswerkherinnering:

Dit helpt je te zien welke informatie beschikbaar moet zijn. Een herinnering kan de opdrachten voor morgen niet kiezen als die geen inleverdatums ontvangt.

Onderscheid behoeften van grenzen

Een eis geeft aan wat de oplossing moet doen: “Toon al het huiswerk dat morgen af moet zijn.” Een randvoorwaarde begrenst de oplossing: “Werk op de tablets van school”, “Kost niets” of “Wees binnen drie weken klaar”. Eisen en randvoorwaarden vormen de ontwerpcriteria.

Een gebruikersverhaal beschrijft een behoefte vanuit iemands perspectief:

“Als brugklasser wil ik het huiswerk voor morgen in één lijst, zodat ik mijn avond kan plannen.”

Het noemt de gebruiker, het doel en de reden. Een ouder heeft misschien juist een weekoverzicht nodig. Dat zijn verschillende verhalen, ook als één oplossing beide gebruikers helpt.

Maak succes controleerbaar

Bij “gemakkelijk te gebruiken” beoordelen mensen verschillende dingen. “Een leerling kan binnen 30 seconden een opdracht toevoegen” geeft een meetbare controle. “Alles wat morgen af moet zijn, verschijnt in de lijst” geeft er nog een.

Schrijf succescriteria voordat je gaat bouwen. Bepaal bij elk criterium welk bewijs laat zien dat eraan is voldaan. Je kunt meten hoe lang een leerling erover doet om iets toe te voegen en daarna de herinneringslijst vergelijken met een voorbereide lijst met inleverdatums.

Aan het begin vertelt de probleemdefinitie je welk werk je in onderdelen moet verdelen. Aan het einde sturen dezelfde verhalen en criteria het testen en de evaluatie. Een breed doel zoals “los huiswerk op” moet je afbakenen voordat een van beide mogelijk is.

Decompositie splitst een probleem of systeem op in kleinere delen. Elk deelprobleem heeft een doel dat je kunt begrijpen, bereiken en controleren. Door die kleinere oplossingen te combineren, voltooi je de grotere taak.

Maak een decompositieboom

Schrijf het hele probleem bovenaan. Benoem daaronder de belangrijkste onderdelen. Vraag je af of elk onderdeel klein genoeg is om direct op te lossen. Als er nog meerdere taken in verborgen zitten, splits je het verder op.

Voor “Maak een quizspel” kunnen de eerste takken zijn:

• Toon de vragen.
• Controleer elk antwoord.
• Houd de score bij.
• Toon het eindresultaat.

De tak “Controleer elk antwoord” kun je verder opsplitsen:

• Ontvang het antwoord van de speler.
• Vergelijk het met het juiste antwoord.
• Toon “Goed!” of laat het juiste antwoord zien.

Een decompositieschema toont deze takken als een boomstructuur. De lijnen betekenen “dit is onderdeel van die taak”. Ze tonen niet welke instructie daarna wordt uitgevoerd. Het algoritme geeft de volgorde.

Kies onderdelen met een bruikbare omvang

“Maak het spel” is te groot om iemand als duidelijke taak te geven. “Druk op een toets” is meestal te klein voor een eigen tak. “Controleer een antwoord” heeft een bruikbaar doel, met een korte reeks stappen erachter.

De juiste omvang hangt af van wat het team begrijpt. Als niemand weet hoe je antwoorden moet verwerken, splits je die tak op totdat het werk duidelijk is. Stop wanneer je elk onderdeel met een duidelijke stap of een kort algoritme kunt oplossen.

Gebruik dezelfde aanpak zonder scherm

Een museumuitje kan vijf hoofdonderdelen hebben:

Verschillende mensen kunnen verantwoordelijkheid nemen voor verschillende takken. Decompositie werkt ook voor systemen: een fiets heeft een frame, wielen, remmen en versnellingen. Als je een onderdeel begrijpt, kun je bepalen waar een reparatie of verbetering nodig is.

Controleer of er niets ontbreekt

Ga terug naar elke eis en elk gebruikersverhaal. Zoek de tak die bij elk ervan hoort. Als een quizspeler een eindscore moet zien, is alleen “Houd de score bij” niet genoeg: iets moet die score tonen.

Door onderdelen afzonderlijk te testen kun je ook gerichter naar fouten zoeken. Als het controleren van antwoorden werkt maar de score verkeerd is, kun je de scoreberekening en de verbinding ertussen onderzoeken. Je hoeft niet met elk onderdeel van het spel opnieuw te beginnen.

Afzonderlijke onderdelen hebben duidelijke verbindingen nodig. Het ene onderdeel kan informatie opleveren die een ander onderdeel nodig heeft. Er is een afhankelijkheid als een onderdeel het resultaat van een ander onderdeel nodig heeft.

Volg uitvoer naar invoer

In een quiz levert het controleren van een antwoord “goed” of “fout” op. Het onderdeel dat de score bijhoudt, ontvangt dat resultaat en werkt een getal bij. Het onderdeel dat het resultaat toont, ontvangt de eindscore.

Spreek precies af wat elk onderdeel verstuurt en ontvangt:

Als het ene teamlid het woord “vijf” verstuurt maar een ander het getal 5 verwacht, kunnen beide onderdelen afzonderlijk werken en samen toch misgaan. Door de gegevens vroeg af te spreken voorkom je dat ze niet op elkaar aansluiten.

Zoek uit wat eerst bekend moet zijn

Voor een uitje hangt het innen van betalingen af van de kosten per leerling. De bus kost € 450. Kaartjes kosten € 8 per stuk voor 25 leerlingen.

1. Kosten van de kaartjes: 25 keer € 8 is € 200.
2. Totale kosten: € 450 plus € 200 is € 650.
3. Kosten per leerling: € 650 gedeeld door 25 is € 26.

Nu kunnen de betalingen voor het juiste bedrag worden geïnd. Vervoer boeken en toestemmingsformulieren ontwerpen kunnen onafhankelijke taken zijn: geen van beide heeft het resultaat van de andere nodig.

Je kunt een programmaonderdeel bouwen voordat het onderdeel dat gegevens levert klaar is. Geef een voorbeeldscore van 4 om een scoreweergave te testen. Zo controleer je de weergave zonder op het scoreonderdeel te wachten. Als het volledige spel draait, moet de echte score van het scoreonderdeel komen.

Voeg onderdelen beetje bij beetje samen

Controleer eerst elk onderdeel afzonderlijk met bekende invoer. Verbind daarna twee onderdelen en controleer de informatie die ertussen wordt doorgegeven. Voeg het volgende onderdeel toe als die verbinding werkt.

Als het scoreonderdeel een voorbeeldresultaat “goed” accepteert maar niet werkt met het onderdeel dat antwoorden controleert, onderzoek dan hun verbinding. Misschien verstuurt het ene onderdeel “Goed” terwijl het andere een andere waarde verwacht. Als je wacht tot elk onderdeel is gebouwd, zijn zulke problemen moeilijker te vinden.

Hergebruik een benoemde reeks stappen

Een subroutine is een benoemde groep stappen die je één keer schrijft en aanroept wanneer die nodig is. Veel talen gebruiken de namen procedure of functie. Een quiz kan “Controleer een antwoord” voor elke vraag aanroepen.

Als je herkent dat vraag 1 en vraag 2 dezelfde controle nodig hebben, verbind je decompositie met patroonherkenning. De gegevens veranderen; de stappen kunnen hetzelfde blijven. Eén gedeelde subroutine geeft je ook één plek om een fout in de controle te verhelpen.

Patroonherkenning betekent dat je overeenkomsten binnen een probleem of tussen problemen opmerkt. Herhaalde stappen, overeenkomende berekeningen en trends in gegevens kunnen wijzen op een oplossing die je kunt hergebruiken.

Maak van herhaalde stappen een lus

Een tekenfiguur maakt een vierkant door 50 stappen vooruit te gaan en 90 graden naar rechts te draaien. De figuur voert dat paar handelingen vier keer uit:

REPEAT 4 TIMES
  MOVE FORWARD 50 STEPS
  TURN RIGHT 90 DEGREES
END REPEAT

De lus beschrijft het herhaalde paar één keer. Om de lengte te veranderen hoef je nu maar één ding aan te passen, zonder acht afzonderlijke instructies te wijzigen.

Zoek wat tussen gevallen verandert

Een regelmatige veelhoek heeft gelijke zijden en gelijke hoeken. Een figuur die zo'n veelhoek tekent, maakt in totaal een volledige draai: 360 graden. Verdeel die draai gelijk over de hoeken:

Een driehoek heeft per draai 120 graden nodig, een vierkant 90 graden en een zeshoek 60 graden. De figuur draait bij elke hoek over de buitenhoek.

Generalisatie zet dit patroon om in een regel voor veel gevallen. Herhaal één keer per zijde: ga de gekozen lengte vooruit en draai 360 gedeeld door het aantal zijden. De waarden die veranderen kunnen parameters worden: invoer voor een subroutine zoals drawShape(sides, length).

Zoek gemeenschappelijke berekeningen

Vijf bioscoopkaartjes van € 8 per stuk kosten € 40. Drie pizza's van € 12 per stuk kosten € 36. De voorwerpen verschillen, maar beide gebruiken:

Eén algoritme kan het aantal en de prijs als invoer ontvangen. Het heeft geen nieuwe reeks stappen nodig voor elk product.

Patronen komen ook in gegevens voor. De getallen 3, 7, 11, 15 worden steeds 4 groter. Door 4 op te tellen krijg je het volgende getal, 19. Een directe regel geeft de waarde op elke positie:

Positie 1 geeft 3. Positie 5 geeft 19. Positie 100 geeft 399 zonder de eerdere waarden op te schrijven.

Controleer de regel voordat je die gebruikt

Het begin 1, 2, 4 kan bij verschillende regels passen. Als je verdubbelt, gaat het verder met 8, 16. Als je eerst 1, dan 2, dan 3 en dan 4 optelt, gaat het verder met 7, 11. Meer voorbeelden of een reden voor de regel helpen bepalen welk patroon bedoeld is.

Abstractie richt zich op de informatie die nodig is voor een doel. Andere details laat je weg of verberg je, zodat je met een eenvoudigere beschrijving kunt werken. Je moet nog steeds nauwkeurig zijn over de details die je behoudt.

Laat het doel de details bepalen

Harry Becks kaart van de Londense metro uit 1933 toonde stations, hun volgorde op lijnen en plaatsen om over te stappen. Rechte lijnen onder enkele hoeken maakten de routes gemakkelijker te volgen. De afstanden tussen stations op de kaart gaven niet de werkelijke afstanden weer.

Die abstractie helpt bij het plannen van een metrorit. Je kunt er niet betrouwbaar mee bepalen hoe ver je moet lopen. Een fietskaart heeft fietspaden en heuvels nodig. Een bezorgkaart heeft adressen en eenrichtingsstraten nodig. Een detail kan voor het ene doel belangrijk en voor een ander doel onnodig zijn.

Kies gegevens voor een zitplaatsenplan in de bus

Het doel is geschikte plaatsen toe te wijzen zonder een plaats twee keer te boeken. Begin met de beschikbare details:

De kleur van de stoelen en de naam van de chauffeur helpen niet bij deze boekingen. Laat ze weg uit dit plan.

Controleer nu de kleinere beschrijving aan de hand van het doel. Kun je ermee een vrije plaats vinden, een boeking maken en voldoen aan behoeften rond toegankelijkheid? Als je informatie over toegankelijke plaatsen weglaat, wordt de beschrijving te eenvoudig. Een leerling die zo'n plaats nodig heeft, kan dan een ongeschikte plaats krijgen.

Beschrijf een hele soort gevallen

“De kluiscode van Jordan is 4-7-2” is specifieke informatie over één kluis. “Een kluiscode bestaat uit drie cijfers, elk van 0 tot en met 9” is algemene informatie over de hele soort codes.

Voor elk cijfer zijn er 10 keuzes, waaronder een voorloopnul:

De mogelijke codes lopen van 000 tot en met 999. Een algemene controle voor codes heeft de regel van drie cijfers nodig, niet Jordans specifieke code.

Verberg details achter een bruikbare naam

Een variabele met de naam score staat voor de huidige waarde van de score. Met een subroutine met de naam drawSquare(size) kun je om een vierkant vragen zonder elke tekenstap te lezen. Een knop “Opslaan” verbergt op vergelijkbare wijze de opslagstappen voor de gebruiker.

Dit zijn abstractieniveaus. “Maak een quizspel” is een hoog niveau. “Controleer elk antwoord” is een kleinere taak op het middenniveau. “Vergelijk getypte tekst met het opgeslagen antwoord” is een lager niveau. Decompositie creëert de onderdelen; abstractie laat je over één niveau nadenken zonder elk detail daaronder bij te houden.

Een model is een vereenvoudigde weergave van een echt voorwerp of een echte situatie. Het behoudt de kenmerken die nodig zijn om een vraag te beantwoorden. Een simulatie voert een model stap voor stap uit om te onderzoeken wat er in de loop van de tijd gebeurt.

Beschrijf een toestand en regels voor verandering

De toestand van een model bestaat uit de waarden op één moment. Het gedrag is de verzameling regels die die waarden verandert. Zo bouw je een model:

1. Formuleer de vraag.
2. Kies de grootheden die je wilt weergeven en geef ze een naam.
3. Stel hun beginwaarden in.
4. Schrijf de regels die ze veranderen.
5. Voer de regels stap voor stap uit en noteer de waarden.
6. Vergelijk voorspellingen met echte waarnemingen.

Modelleer een telefoonbatterij

De batterij begint op 80%. Gamen kost elk uur 15 procentpunt. Hoeveel volledige uren verstrijken voordat de lading onder 20% komt?

Elke rij gebruikt de vorige lading min 15. Na vier uur is de lading gelijk aan 20%; die is niet lager dan 20%. Volgens het model zijn dus vier volledige uren mogelijk voordat de lading tijdens het vijfde uur onder dat niveau komt.

De regel gaat uit van hetzelfde verbruik per uur. Een helderder scherm kan meer batterij verbruiken. Als de werkelijke lading na drie uur 30% is, was de voorspelling van 35% te hoog. Het waargenomen gemiddelde verbruik is:

Probeer een regel van ongeveer 17 procentpunt per uur en test die daarna met nieuwe waarnemingen.

Modelleer sparen

Een leerling begint met € 10. Elke week komt er € 5 bij en gaat er € 2 naar tussendoortjes. De verandering per week is € 3.

Na week 1 is het saldo € 13. Na week 8 is het € 34. Een koptelefoon kost € 40. Week 9 geeft € 37; week 10 geeft € 40, dus de leerling kan de koptelefoon na tien weken kopen.

Dit model gaat ervan uit dat de inkomsten en uitgaven per week gelijk blijven. Een cadeau of een overgeslagen tussendoortje verandert het werkelijke saldo. Aannames zijn de voorwaarden die het model als waar beschouwt; ze helpen je beoordelen wanneer de voorspelling bruikbaar is.

Kies genoeg details om de vraag te beantwoorden

Een model van een kantinerij heeft aankomsttijden en bedieningstijden nodig om de wachttijd te voorspellen. Kleuren van dienbladen helpen niet bij die vraag. Meer details kosten meer werk om te bouwen en te controleren, dus behoud wat de voorspelling beïnvloedt.

Een bordspel kan verkeer zonder computer modelleren. Een spreadsheet kan één rij per week vastleggen. Een Scratch-simulatie kan het aantal vissen in een vijver bijwerken. Elk model heeft een begintoestand, duidelijke regels en controles aan de hand van de situatie die het weergeeft nodig.

Een algoritme is een eindige verzameling nauwkeurige, ondubbelzinnige instructies of regels voor een taak. Het heeft een duidelijk begin, volgt een vaste volgorde en eindigt met een resultaat. Iemand die het volgt, zou niet naar ontbrekende details hoeven raden.

Maak een instructie nauwkeurig

“Doe pindakaas op brood” laat verschillende keuzes open. Een duidelijkere versie is:

1. Open de pot.
2. Neem met het mes ongeveer één lepel pindakaas.
3. Smeer die uit over één kant van één snee brood.

Vervang bij een bewegingstaak “loop een stukje” door “loop 20 stappen”. Vervang bij herhaling “een paar keer” door “3 keer”. Bij een opdracht zonder computer kan iemand anders de instructies letterlijk volgen om ontbrekende stappen te ontdekken.

Volg een beslissing tot een resultaat

Om het grootste van twee getallen te vinden:

INPUT a
INPUT b
IF a > b THEN
  OUTPUT a
ELSE
  OUTPUT b
END IF

Bij 7 en 12 is de voorwaarde onwaar, dus is de uitvoer 12. Bij 5 en 5 is die ook onwaar: de tweede 5 wordt als uitvoer gegeven. Dat is nog steeds de grootste waarde, omdat beide waarden gelijk zijn.

Kies een manier om de stappen te tonen

In een eenvoudig stroomdiagram geeft een ovaal of afgeronde rechthoek het begin of einde aan. Een rechthoek toont verwerking. Een ruit bevat een beslissing, met uitvoeringspaden met de labels “Ja” en “Nee”. Een parallellogram toont invoer of uitvoer. Pijlen tonen waar je verdergaat.

Er is niet één officiële stijl voor pseudocode. Duidelijke, consistente instructies zijn belangrijk omdat iemand anders het plan moet kunnen volgen. Een programma drukt algoritmen uit in een programmeertaal die een computer kan uitvoeren. Hetzelfde plan kun je in verschillende talen uitvoeren of door een mens laten volgen.

Geef herhaling een manier om te eindigen

“Blijf roeren” zegt niet wanneer je moet stoppen. Een lus heeft een vast aantal herhalingen of een bereikbare stopvoorwaarde nodig. “Roer 30 seconden” geeft een grens.

Een WHILE-lus stopt wanneer de voorwaarde onwaar wordt. Een REPEAT UNTIL-lus stopt wanneer de voorwaarde waar wordt. De herhaalde stappen moeten dat stoppunt kunnen bereiken.

Meerdere algoritmen kunnen één probleem oplossen. Een routebeschrijving via de trap en een routebeschrijving met de lift kunnen allebei bij een bibliotheek uitkomen. Of ze geschikt zijn, hangt af van de gebruiker: een leerling met krukken heeft misschien de route met de lift nodig.

Algoritmen combineren drie basisstructuren: sequentie, selectie en iteratie. Met benoemde waarden houd je bij wat verandert, terwijl je met subroutines een groep stappen kunt hergebruiken.

Volgorde en beslissingen

Sequentie voert stappen na elkaar uit. Trek sokken aan vóór schoenen. Zelfs correcte instructies kunnen misgaan in de verkeerde volgorde.

Selectie kiest stappen met behulp van een voorwaarde die waar of onwaar is. Vergelijkingen zijn onder andere =, <, >, <= en >=. De laatste twee betekenen “kleiner dan of gelijk aan” en “groter dan of gelijk aan”.

Voor bioscoopkaartjes betalen kinderen onder 13 jaar € 8, mensen van 65 jaar en ouder € 9 en alle anderen € 12:

IF age < 13 THEN
  SET price TO 8
ELSE IF age >= 65 THEN
  SET price TO 9
ELSE
  SET price TO 12
END IF

Leeftijd 12 geeft € 8. Leeftijden 13 en 40 geven € 12. Leeftijd 65 geeft € 9. De voorwaarden worden van bovenaf gecontroleerd en de eerste ware voorwaarde kiest de tak. Als je < 13 verandert in <= 13, hoort leeftijd 13 ten onrechte bij de goedkopere groep.

Herhaal de juiste stappen

Iteratie herhaalt werk. Een telgestuurde lus heeft een vast aantal herhalingen, zoals REPEAT 4 TIMES. Een voorwaardegestuurde lus hangt af van een veranderende voorwaarde, zoals WHILE lives > 0.

Gebruik een vast aantal als je weet hoeveel herhalingen nodig zijn. Gebruik een voorwaarde als het aantal afhangt van wat er gebeurt. Een herhaald paar tekeninstructies kun je één keer aanpassen binnen een lus, zodat je geen afzonderlijke kopieën nodig hebt.

Sla waarden op met namen

Een variabele slaat een waarde op die kan veranderen. SET score TO 0 geeft een beginwaarde. SET score TO score + 1 leest de huidige score, telt er één bij op en slaat de nieuwe score op.

Waarden hebben gegevenstypen. Een geheel getal is een getal zonder breukdeel, zoals 42. Een tekenreeks bevat tekst, zoals “Ana”. Een booleaanse waarde is waar of onwaar.

Een constante is een benoemde waarde die tijdens een uitvoering gelijk blijft. CONSTANT MAX_LIVES = 3 maakt de grens gemakkelijk te herkennen. Hoofdletters zijn een gebruikelijke manier om namen te schrijven, geen algemene regel voor alle talen.

Combineer de structuren

SET score TO 0
REPEAT 5 TIMES
  SHOW NEXT QUESTION
  INPUT answer
  IF answer = correctAnswer THEN
    SET score TO score + 1
  END IF
END REPEAT
OUTPUT score

De beginwaarde komt vóór de lus. Alleen een juist antwoord verandert de score. De einduitvoer komt na alle vijf vragen. Als je die uitvoer binnen de lus zet, wordt na elk antwoord een score getoond.

Zet de score aan het begin van elk spel terug. Scratch kan een waarde van het vorige spel bewaren. Python geeft een foutmelding als je een naam gebruikt die nooit een waarde heeft gekregen.

Een subroutine zoals drawSquare(size) bevat herbruikbare stappen. De parameter size levert de veranderlijke lengte. Volg bij een aanroep de subroutine met die waarde en ga daarna terug naar de instructie na de aanroep.

Traceren betekent dat je een algoritme met de hand volgt, stap voor stap. Noteer de waarden wanneer ze veranderen. Een tracetabel maakt het gemakkelijker te zien waar de werkelijke stappen niet meer overeenkomen met het bedoelde resultaat.

Traceer een lopend totaal

SET total TO 0
SET n TO 1
WHILE n <= 4
  SET total TO total + n
  SET n TO n + 1
END WHILE
OUTPUT total

Elke doorgang telt de huidige waarde van n op en verhoogt daarna n. Wanneer n 5 wordt, is de voorwaarde onwaar. De uitvoer is 10, de som van 1, 2, 3 en 4.

Spring bij het traceren niet direct naar het bedoelde antwoord. Volg de geschreven stappen, inclusief fouten. Een tabel is nuttig omdat die het punt toont waar voor het eerst een verkeerde waarde verschijnt.

Kies tests voordat je ze uitvoert

Testen vergelijkt werkelijke resultaten met vooraf berekende verwachte resultaten. Neem op:

• Normale gegevens: een gewone geldige invoer.
• Gegevens rond grenswaarden: waarden rond een grens waar het gedrag verandert.
• Onverwachte gegevens: een leeg antwoord, een onmogelijke waarde of het verkeerde soort invoer.

Bij de regel voor kaartjes hoort leeftijd 30 € 12 te kosten. Leeftijden 12 en 13 horen € 8 en € 12 te kosten. Leeftijden 64 en 65 horen € 12 en € 9 te kosten. Deze paren grenswaarden controleren beide prijsveranderingen.

Leeftijd −5 moet worden afgewezen. Zonder extra controle accepteert age < 13 die leeftijd en rekent € 8. Een normale test alleen zou dit probleem missen.

Zoek en verhelp een programmeerfout

Een algoritme dat 1 tot en met 10 moet tonen, luidt:

SET count TO 1
WHILE count < 10
  OUTPUT count
  SET count TO count + 1
END WHILE

Het toont 1 tot en met 9. Zodra count 10 is, slaagt de controle niet en volgt er geen uitvoer. Verander de voorwaarde in count <= 10 of count < 11. Dit is een off-by-one-fout: de lus loopt één keer te weinig.

Om te debuggen zoek je invoer die de fout telkens veroorzaakt. Traceer tot de eerste onverwachte waarde. Bedenk een oorzaak, verander één ding en herhaal die test. Voer daarna eerdere tests opnieuw uit om te controleren of de verbetering werkend gedrag niet heeft stukgemaakt.

Door elke instructie hardop uit te leggen kun je een ontbrekende stap ontdekken. Dezelfde methode werkt als een klasgenoot tekeninstructies volgt. Als gevarieerde tests slagen, geeft dat meer vertrouwen, maar invoer die je niet hebt geprobeerd, kan nog steeds een fout blootleggen.

Een volledig plan verbindt het doel van de gebruikers met kleinere taken, bruikbare gegevens, algoritmen en tests. De fasen kunnen overlappen. Een test die een ontbrekend geval aan het licht brengt, kan je terugsturen naar de probleemdefinitie of decompositie.

Omschrijf een inzamelwedstrijd

Klassen zamelen elke schooldag blikjes in. De leerlingenraad heeft weektotalen en een winnaar nodig. Een bruikbaar verhaal is:

“Als lid van de leerlingenraad wil ik de weektotalen van de blikjes zien, zodat ik op vrijdag de winnende klas kan bekendmaken.”

De succescriteria vereisen het totaal van elke klas, de winnaar en een melding van een gelijke stand wanneer meerdere klassen samen het hoogste totaal hebben.

Verdeel het werk en zoek gemeenschappelijke stappen

De belangrijkste onderdelen zijn de aantallen per dag vastleggen, het totaal per klas berekenen, het hoogste totaal zoeken en de resultaten tonen. Voor elke klas moet je op dezelfde manier vijf dagtotalen optellen. Eén lus of subroutine kan die herhaalde taak uitvoeren.

Behoud de namen van de klassen en de aantallen per dag. De merken van de blikjes en de mensen die de zakken dragen, hebben geen invloed op de totalen. Die abstractie vertelt het team welke gegevens het moet vastleggen.

Test het plan met een gelijke stand

Een eerste algoritme onthoudt één winnaar. Het vervangt die winnaar alleen als het een groter totaal vindt. Klas 14 vervangt klas 12, maar klas 15 vervangt klas 14 niet: 61 is niet groter dan 61. Het algoritme mist een verplichte melding van een gelijke stand.

Verbeter het ontwerp door alle namen met het hoogste totaal te bewaren. Begin met het totaal en de naam van de eerste klas. Voor elke overige klas:

• Een groter totaal wordt het nieuwe hoogste totaal, met een nieuwe lijst die die klas bevat.
• Bij een gelijk totaal voeg je die klas toe aan de huidige lijst.
• Bij een kleiner totaal blijft de lijst ongewijzigd.

De test geeft nu klas 14 en 15 samen als resultaat. Plan ook hoe je aantallen van nul en ontbrekende daggegevens verwerkt. Een ontbrekende invoer mag je niet ongemerkt als een bekende nul behandelen.

Leg genoeg vast zodat een team kan bouwen

Bewaar het decompositieschema, de benoemde waarden, de algoritmen voor elk onderdeel en de tests met verwachte resultaten. Wijs teamtaken toe aan personen en geef ze deadlines. Een mogelijke tijdplanning is week 1 voor plannen, week 2 voor onderdelen bouwen en week 3 voor samenvoegen en testen.

Je kunt het plan uitvoeren op een turflijst met een rekenmachine, in een spreadsheet of in Scratch of Python. De uitvoeringswijze verandert; correcte totalen en een eerlijke afhandeling van een gelijke stand blijven nodig.

Evaluatie beoordeelt hoe goed een oplossing aan de probleemdefinitie voldoet. Gebruik bewijs uit tests en van echte gebruikers. Leg vast of aan elk succescriterium is voldaan, samen met het resultaat dat die beoordeling ondersteunt.

Beoordeel de oplossing aan de hand van het doel

Een inzamelsysteem dat alle totalen correct optelt maar een gelijke stand verbergt, voldoet nog steeds niet aan een succescriterium. Een huiswerkherinnering die de juiste opdrachten toont, kan nog steeds te langzaam zijn in het gebruik. Controleer elk criterium afzonderlijk.

Vraag gebruikers de oplossing te proberen. Een kleine knop of verwarrend bericht kan een behoefte aan het licht brengen die het team heeft gemist. Zet die bevinding om in een duidelijk gebruikersverhaal en een meetbare controle voor de volgende versie.

Vergelijk algoritmen eerlijk

Correctheid komt eerst. Een sneller algoritme dat het verkeerde resultaat geeft, is geen aanvaardbare oplossing. Vergelijk bij correcte oplossingen de efficiëntie en duidelijkheid met wat het project nodig heeft.

Vergelijk twee raadmethoden

Een geheim geheel getal ligt in het bereik van 1 tot en met 100. Bij elke verkeerde gok krijg je een waarheidsgetrouwe aanwijzing “te hoog” of “te laag”.

Als je eerst 1, dan 2, dan 3 enzovoort raadt, kun je 100 pogingen nodig hebben. Als je het midden van het resterende bereik raadt, valt telkens ongeveer de helft van de mogelijkheden af. Voor dit bereik zijn hoogstens 7 pogingen nodig.

Voor het geheime getal 37:

1. Raad 50. “Te hoog” laat 1 tot en met 49 over.
2. Raad 25. “Te laag” laat 26 tot en met 49 over.
3. Het midden is 37,5. Rond naar beneden af en raad 37: goed.

De bereiken worden kleiner omdat elke aanwijzing waarden wegneemt die het geheime getal niet kunnen zijn. Door pogingen te tellen kun je de efficiëntie eenvoudig vergelijken.

Kies een passende verbetering

De snelste correcte methode past niet altijd het best bij een klein team. Een iets langzamere methode kan voor iedereen gemakkelijker te begrijpen en te veranderen zijn. Bedenk hoeveel gegevens de oplossing zal verwerken en wat de succescriteria vereisen.

Verbeter in kleine cycli: ontwerp, bouw, test, evalueer en pas aan. Kies het belangrijkste gevonden probleem, verander dat en herhaal de eerdere tests. Als je meerdere dingen die niets met elkaar te maken hebben tegelijk verandert, wordt een nieuwe fout moeilijker te verklaren.

Leg het bewijs voor elke verbetering vast. “De test met een gelijke stand noemt nu beide winnende klassen” geeft een bruikbaar resultaat. Bij “het werkte één keer” blijven de meeste succescriteria ongecontroleerd.