Handboek · hoofdstuk 22Computationeel denken
Denken als een programmeur, nog voor je één regel code schrijft
Een computer is snel en gehoorzaam, maar hij bedenkt niets zelf: hij volgt precies de stappen die jij opschrijft. Computationeel denken is de manier van denken waarmee je een probleem zo opdeelt en beschrijft dat een machine het kan uitvoeren. Je leert vier gereedschappen, tekent stroomdiagrammen, speelt algoritmen na op papier en zoekt er de fouten in. En je ontdekt het verschil tussen een regel die een mens schrijft en een regel die een computer zelf leert uit voorbeelden: de kern van wat men AI noemt.
- Je kan een probleem opdelen in deelproblemen (decompositie) en herhalingen in een probleem herkennen (patroonherkenning).
- Je kan bij een probleem aangeven welke gegevens ertoe doen en welke je mag weglaten (abstractie).
- Je kan een algoritme schrijven als genummerde stappen en tekenen als stroomdiagram met de juiste symbolen.
- Je kan een algoritme stap voor stap naspelen in een trace-tabel en zo de uitkomst voorspellen.
- Je kan fouten in een algoritme vinden en verbeteren: verkeerde volgorde, ontbrekende stap, oneindige lus, verkeerde vergelijking.
- Je kan het verschil uitleggen tussen een vast algoritme en een systeem dat een regel leert uit gelabelde voorbeelden, en zeggen wat AI wel en niet kan.
- Je kan het algoritme 'water geven' voor de meetkas als stroomdiagram tekenen en naspelen.
Een woord uit Bagdad
Rond het jaar 825 schreef de wiskundige Muhammad ibn Musa al-Khwarizmi in Bagdad een boek over rekenen met de Indische cijfers: de tien tekens 0 tot 9 die jij vandaag gebruikt. Hij legde uit hoe je met die cijfers optelt, aftrekt, vermenigvuldigt en deelt, stap voor stap, zodat iedereen die de stappen volgt het juiste antwoord vindt. Het boek werd in de twaalfde eeuw in het Latijn vertaald. Het oudste bewaarde handschrift begint met de woorden Dixit Algorizmi: 'zo sprak Algorizmi'. Van die verlatijnste naam (ook als Algoritmi geschreven) komt ons woord algoritme.
Een algoritme is dus veel ouder dan de computer. De staartdeling die je in de lagere school leerde, is een algoritme: je hoeft niet te begrijpen waarom ze werkt om ze foutloos uit te voeren. Precies dat maakt algoritmen zo krachtig: wie de stappen volgt, mens of machine, komt tot hetzelfde resultaat.
In 1843 schreef de Britse wiskundige Ada Lovelace lange noten bij een artikel over de Analytical Engine, een rekenmachine die Charles Babbage ontworpen had maar nooit afwerkte. In haar laatste noot beschreef ze stap voor stap hoe die machine een reeks ingewikkelde getallen (de getallen van Bernoulli) kon berekenen, met herhalingen erin. Ze zag ook al dat zo'n machine meer kon dan rekenen: alles wat je in symbolen kan vastleggen, zoals muziek, kan ze bewerken.
Tussen al-Khwarizmi en Ada Lovelace liggen duizend jaar, maar het idee is hetzelfde: een probleem zo precies beschrijven dat je het kan uitbesteden. In dit hoofdstuk leer je dat zelf, eerst op papier. In de volgende hoofdstukken besteed je het uit aan een computer en een microcontroller.
Vier gereedschappen om te denken
Computationeel denken is niet 'denken zoals een computer', maar denken zodat een computer je kan helpen. Programmeurs, ingenieurs en wetenschappers gebruiken er vier gereedschappen voor. Je hebt ze niet altijd alle vier nodig, en ze lopen door elkaar, maar samen maken ze een groot probleem hanteerbaar.
- Decompositie: een groot probleem opdelen in deelproblemen die je apart kan aanpakken.
- Patroonherkenning: zien wat telkens terugkomt, zodat je één oplossing meerdere keren kan gebruiken.
- Abstractie: alleen overhouden wat ertoe doet voor het probleem, en de rest weglaten.
- Algoritme: een stappenplan maken dat het probleem altijd oplost, zo precies dat een machine het kan uitvoeren.
In de figuur zie je ze toegepast op de meetkas van Habitat. De opdracht 'zorg voor de planten' is te groot om in één keer te programmeren. Na de vier stappen blijft er een kort stappenplan over dat een microcontroller (hoofdstuk 24) kan uitvoeren.
Decompositie: van groot naar klein
Een probleem dat te groot is om te overzien, knip je in stukken. Elk stuk knip je opnieuw, tot elk deel klein genoeg is om in één keer op te lossen. Zo ontstaat een boom: bovenaan het hele probleem, onderaan de kleine taken.
Decompositie heeft drie voordelen. Je ziet wat er allemaal moet gebeuren (en vergeet minder). Je kan het werk verdelen: in een team neemt elk lid een tak. En je kan elk deel apart testen: werkt het vochtmeten, dan pas koppel je er de pomp aan.
Als je het in één zin kan beschrijven met een werkwoord en je weet hoe je het doet: 'vocht meten', 'pomp schakelen'. Kan je dat nog niet, knip dan verder.
Robot spelen op ruitjespapier
Hoe precies moeten instructies zijn opdat iemand ze uitvoert zonder te raden, zoals een machine?
- ruitjespapier (2 vellen per duo)
- potlood en gom
- een map of boek als schermpje tussen de twee leerlingen
- 1Leerling A tekent in het geheim een figuur van 6 tot 10 lijnstukken langs de lijnen van het ruitjespapier.
- 2Ronde 1. A beschrijft de figuur in gewone woorden; B tekent zonder te kijken. Vergelijk daarna.
- 3Ronde 2. Een nieuwe figuur. Nu mag A alleen vier commando's gebruiken: VOORUIT n (n hokjes), LINKS en RECHTS (een kwartdraai ter plaatse) en een startpunt met een kijkrichting. A schrijft het hele programma eerst op, B voert het letterlijk uit.
- 4Tel in beide rondes het aantal lijnstukken dat verkeerd staat. Wissel daarna van rol.
- 5Zoek in je programma van ronde 2 een stukje dat zich herhaalt en schrijf het korter met HERHAAL.
In ronde 1 gaat het vaak mis bij woorden als 'een beetje naar rechts', 'schuin' of 'terug'. In ronde 2 staan de meeste figuren meteen juist. De fouten die overblijven, zijn tel- en draaifouten: vooral LINKS en RECHTS verwisselen als de 'robot' naar beneden kijkt. Een trap wordt met HERHAAL drie keer korter (zie figuur).
Gewone taal is vol dubbelzinnigheid: een mens vult aan wat bedoeld wordt, een machine niet. Een programmeertaal is net een kleine verzameling commando's die elk maar één betekenis hebben. Wat overblijft zijn bugs: fouten in het programma zelf. Je vindt ze door het programma stap voor stap na te spelen, precies wat B deed. Het korter schrijven met HERHAAL is patroonherkenning; in het volgende hoofdstuk heet dat blok herhaal.
Patronen zien en weglaten wat niet telt
Patroonherkenning. Kijk nog eens naar de boom van het vorige blad. Water, licht en temperatuur werken alle drie op dezelfde manier: meet iets, vergelijk het met een grens, schakel iets aan of uit. Wie dat patroon ziet, hoeft het maar één keer goed uit te denken en kan het drie keer gebruiken. In hoofdstuk 25 krijgt dat patroon een naam: meten, beslissen, doen.
Abstractie. Een echte plantenbak heeft honderd eigenschappen: de kleur van de pot, de soort plant, de vorm van de bladeren. Voor het algoritme 'water geven' tellen er maar twee: hoe vochtig de grond is, en of er water in het reservoir zit. De rest laat je weg. Dat is geen slordigheid, het is net de kunst: een goede abstractie maakt een probleem eenvoudig zonder dat je iets belangrijks verliest.
Je kent abstracties al: een metrokaart toont de stations op rechte lijnen, zonder straten en zonder de echte afstanden. Voor een reiziger is dat net handiger dan een echte kaart (de schematische kaart van de Londense metro, ontworpen door Harry Beck, verscheen in 1933). Ook een schakelschema (hoofdstuk 18) is een abstractie: het toont verbindingen, niet hoe de draden echt lopen.
Laat je 'water in het reservoir' weg, dan pompt de kas ook als het reservoir leeg is: de pomp draait droog en gaat stuk. Een abstractie is goed als ze alles bevat wat de beslissing kan veranderen.
Algoritmen in het dagelijks leven
Een algoritme is een stappenplan met vier eigenschappen:
- eenduidig: elke stap kan maar op één manier begrepen worden ('bak de pannenkoek tot hij goudbruin is' is voor een mens duidelijk genoeg, voor een machine niet);
- vaste volgorde: de stappen staan in de juiste volgorde, en bij een keuze staat er wat je doet bij 'ja' en bij 'nee';
- eindig: het algoritme stopt na een eindig aantal stappen (behalve als het met opzet eindeloos doorgaat, zoals een thermostaat);
- invoer en uitvoer: het krijgt gegevens binnen en levert een resultaat.
| algoritme | invoer | stappen | uitvoer |
|---|---|---|---|
| recept voor pannenkoeken | bloem, melk, eieren | mengen, rusten, bakken, keren | pannenkoeken |
| route van een gps | vertrekpunt, bestemming, kaart | zoek de kortste weg langs de wegen | de route |
| kaarten sorteren | een stapel kaarten | zoek telkens de kleinste en leg hem vooraan | een gesorteerde rij |
| staartdeling | deeltal en deler | schatten, vermenigvuldigen, aftrekken, cijfer bijhalen | quotiënt en rest |
Een gps kiest de kortste route door telkens de weg uit te breiden die tot nu toe het kortst is, tot hij de bestemming bereikt. Een sorteeralgoritme zet een stapel in volgorde. Die algoritmen werken voor elke kaart en elke stapel: dat bedoelen we met 'een stappenplan dat altijd werkt'.
'Voeg een snuifje zout toe' en 'bak tot goudbruin' zijn voor een kok duidelijk, maar niet eenduidig. Een machine heeft een getal nodig ('2 g zout') of een meting ('bak tot de onderkant 160 °C heeft'). Hoe preciezer, hoe dichter bij een echt algoritme.
Kaarten sorteren met een algoritme
Sorteer de kaarten 7, 3, 9, 1, 5 van klein naar groot met selectiesorteren: zoek in het ongesorteerde deel de kleinste kaart en wissel ze met de eerste kaart van dat deel. Hoeveel keer vergelijk je twee kaarten? En hoeveel keer bij 100 kaarten?
- rij: 7, 3, 9, 1, 5
- regel: zoek de kleinste in het ongesorteerde deel en wissel naar voren
- de rij na elke ronde
- het aantal vergelijkingen voor 5 en voor 100 kaarten
- 1Ronde 1. Zoek de kleinste van 7, 3, 9, 1, 5: dat is 1 (4 vergelijkingen). Wissel met 7: 1, 3, 9, 7, 5.
- 2Ronde 2. Kleinste van 3, 9, 7, 5: dat is 3 (3 vergelijkingen). Hij staat al vooraan: niets wisselen.
- 3Ronde 3. Kleinste van 9, 7, 5: dat is 5 (2 vergelijkingen). Wissel met 9: 1, 3, 5, 7, 9.
- 4Ronde 4. Kleinste van 7, 9: dat is 7 (1 vergelijking). De laatste kaart staat dan vanzelf goed.
- 5Tellen. vergelijkingen. Voor 100 kaarten: .
Het stroomdiagram
Een algoritme in genummerde zinnen wordt snel onoverzichtelijk zodra er keuzes en herhalingen in zitten. Daarom teken je het als stroomdiagram, met vaste symbolen die iedereen kent:
| symbool | betekenis | voorbeeld |
|---|---|---|
| afgeronde rechthoek (ovaal) | start of stop | Start |
| rechthoek | handeling: doe iets | zet de pomp aan |
| ruit | beslissing: een vraag met ja of nee | vocht < 30 %? |
| parallellogram | invoer of uitvoer: meet, lees, toon | meet het vocht |
| pijl | de volgorde: wat komt erna |
Vijf afspraken maken een stroomdiagram leesbaar:
- Er is precies één Start.
- Uit een ruit vertrekken altijd twee pijlen, met 'ja' en 'nee' erbij.
- Uit een rechthoek of parallellogram vertrekt precies één pijl.
- Een pijl die terugloopt naar een eerder punt maakt een lus (herhaling).
- Lees van boven naar onder; kruisende pijlen vermijd je.
Schrijf in een ruit altijd een vraag die je met ja of nee kan beantwoorden: 'vocht < 30 %?', niet 'vocht'. Zo zie je meteen welke pijl bij welk antwoord hoort.
Raad het getal als stroomdiagram
In het spel raad het getal kiest de computer een geheim getal van 1 tot 100. De speler raadt; de computer antwoordt 'hoger', 'lager' of 'Juist!'. Teken het algoritme van de computer als stroomdiagram.
- geheim getal van 1 tot 100
- antwoorden: 'hoger', 'lager', 'Juist!'
- stroomdiagram met de juiste symbolen
- 1Decompositie. Wat doet de computer? (1) een getal kiezen; (2) een gok vragen; (3) de gok vergelijken; (4) een antwoord tonen; (5) opnieuw beginnen bij (2), tot het getal geraden is.
- 2Symbolen kiezen. Kiezen is een handeling (rechthoek). Een gok vragen en een antwoord tonen zijn invoer en uitvoer (parallellogram). Vergelijken is een beslissing (ruit).
- 3Twee vragen na elkaar. Eén ruit kan maar twee uitgangen hebben, en er zijn drie antwoorden. Daarom vraag je eerst 'gok = geheim?' en pas bij 'nee' 'gok < geheim?'.
- 4De lus. Na 'hoger' of 'lager' loopt de pijl terug naar 'vraag een gok'. Het algoritme stopt alleen bij 'Juist!'.
Naspelen met een trace-tabel: slim raden
Er bestaat een slimme manier om te raden: gok telkens het midden van wat nog mogelijk is. Speel die strategie na voor het geheime getal 71. Hoeveel pogingen heb je nodig? En hoeveel hoogstens, voor elk getal van 1 tot 100?
- ondergrens 1, bovengrens 100
- gok = midden van onder- en bovengrens (naar beneden afgerond)
- bij 'hoger': ondergrens = gok + 1; bij 'lager': bovengrens = gok − 1
- trace-tabel voor het geheime getal 71
- het grootste aantal pogingen voor 1 tot 100
- 1Maak een tabel met een kolom voor elke variabele (een naam met een waarde die kan veranderen): ondergrens, bovengrens en gok. Na elke stap schrijf je de nieuwe waarden op een nieuwe rij.
- 2Poging 1: , dus 50. Het antwoord is 'hoger': de ondergrens wordt 51.
- 3Poging 2: , dus 75: 'lager', de bovengrens wordt 74. Zo verder, zie de tabel.
- 4Elke poging halveert (ongeveer) het aantal getallen dat nog kan: 100, 50, 25, 12, 6, 3, 1. Na 7 halveringen blijft er één getal over. Omgekeerd: is het eerste tweemacht groter dan 100.
- 5
poging ondergrens bovengrens gok = midden antwoord 1 1 100 (1 + 100) : 2 → 50 hoger 2 51 100 (51 + 100) : 2 → 75 lager 3 51 74 (51 + 74) : 2 → 62 hoger 4 63 74 (63 + 74) : 2 → 68 hoger 5 69 74 (69 + 74) : 2 → 71 juist! Geheim getal: 71. Bij een oneven som rond je naar beneden af.
Fouten zoeken: debuggen op papier
Een fout in een algoritme heet een bug, het zoeken en verbeteren debuggen. De krachtigste methode kost niets: speel het algoritme na met een trace-tabel en kijk waar het iets anders doet dan je verwacht. Vijf fouten komen steeds terug:
| soort fout | voorbeeld | zo vind je ze |
|---|---|---|
| verkeerde volgorde | eerst pompen, dan meten | vraag bij elke stap: weet ik al wat ik hier nodig heb? |
| ontbrekende stap | de teller nooit op 0 zetten | kijk of elke variabele een beginwaarde krijgt |
| oneindige lus | de voorwaarde om te stoppen wordt nooit waar | kijk of de lus de variabele in de juiste richting verandert |
| verkeerde vergelijking | < waar ≤ moest, of een grensgeval vergeten | test precies op de grens: wat gebeurt er bij 30 %? |
| pijl die nergens heen gaat | een ruit met maar één uitgang | tel de pijlen: twee uit elke ruit |
In de figuur moet het algoritme aftellen van 10 naar 0. Speel het links na: n wordt 10, 11, 12, 13 ... en de vraag 'n = 0?' is nooit ja. Het algoritme stopt nooit: een oneindige lus. Rechts is één teken verbeterd: n = n − 1. Nu toont het 10, 9, ..., 1 en stopt het bij 0.
Nee: hij doet wat je schrijft. Een computer ziet niet dat 'n = n + 1' een vergissing is. Hij telt vrolijk verder, miljoenen keren per seconde. Daarom test je elk algoritme met gewone gevallen, met grensgevallen (precies 30 %) en met rare gevallen (een lege lijst, een sensor die 0 geeft).
Habitat: het algoritme 'water geven'
De meetkas moet zelf water geven. Er is een bodemvochtsensor in een van de bakjes, een pompje dat 8,0 mL/s levert (hoofdstuk 4) en een reservoir met een vlotter die meldt of het leeg is. Het water heeft na het gieten een tijd nodig om naar de sensor te zakken. Ontwerp het algoritme en speel een ochtend na.
- drempel: water geven onder 30 % bodemvocht
- pompje 8,0 mL/s
- vlotter: reservoir leeg ja/nee
- na het gieten 15 min wachten voor je opnieuw meet
- stroomdiagram
- hoeveel water per beurt als de pomp 30 s draait
- trace van een ochtend
- 1Decompositie. Meten, beslissen, reservoir controleren, pompen, wachten, opnieuw.
- 2Abstractie. Twee gegevens: het vocht en 'reservoir leeg ja/nee'.
- 3Volgorde. Eerst meten, dan beslissen. Het reservoir controleer je vóór je pompt, anders draait de pomp droog (in de kas beveiligt een vlotterschakelaar in serie met de pomp dat ook elektrisch, hoofdstuk 18).
- 4Pompbeurt. , verdeeld over 12 bakjes: 20 mL per bakje. Voor 1,8 L per dag zijn dat beurten per dag.
- 5De lus. Na elke beslissing wacht het algoritme 15 minuten en begint het opnieuw. Deze lus stopt met opzet nooit: de kas werkt dag en nacht. Een eindeloze lus is hier dus geen bug.
- 6Trace van een ochtend. In dit voorbeeld daalt het vocht ongeveer 1 procentpunt per kwartier; een pompbeurt maakt de grond ongeveer 16 procentpunten natter.
- 7
tijd v (%) v < 30 %? reservoir leeg? actie 07:00 32 nee (niet gevraagd) wacht 15 min 07:15 31 nee (niet gevraagd) wacht 15 min 07:30 30 nee (niet gevraagd) wacht 15 min 07:45 29 ja nee pomp 30 s, wacht 15 min 08:00 44 nee (niet gevraagd) wacht 15 min
Een vaste regel of leren uit voorbeelden?
Tot nu toe schreef een mens de regel: 'geef water als het vocht lager is dan 30 %'. Maar waar komt die 30 % vandaan? Misschien weet een ervaren tuinier het niet als getal, maar ziet hij het wel aan de plant. Dan kan je het ook anders aanpakken: laat de computer de regel leren uit voorbeelden.
De tuinier meet zeventien keer het bodemvocht en zegt telkens of de plant op dat moment water nodig had. Zo'n voorbeeld met het juiste antwoord erbij heet een gelabeld voorbeeld. De computer probeert dan elke mogelijke drempel en telt hoeveel voorbeelden de regel 'water als vocht < drempel' fout voorspelt. Hij houdt de drempel met de minste fouten. Dat is machinaal leren in zijn eenvoudigste vorm.
In de grafiek zie je het resultaat: met een drempel van 10 % zijn er 8 fouten (alle droge planten krijgen geen water), met 60 % zijn er 9 (alle natte planten krijgen toch water). Het minimum, 2 fouten, ligt tussen 29 en 31 %: de computer kiest het midden, 30 %. Twee voorbeelden blijven fout: een plant die bij 38 % toch dorst had (ze stond in de volle zon) en een die bij 19 % nog niet klaagde. Geen enkele drempel krijgt alles juist.
Testen. Of de geleerde regel deugt, weet je pas met nieuwe voorbeelden die de computer nooit gezien heeft. Van zes nieuwe metingen (15, 27 en 32 % met dorst; 34, 45 en 50 % zonder) voorspelt de regel er vijf juist: de plant met dorst bij 32 % krijgt geen water.
Wat AI wel en niet is
Artificiële intelligentie (AI) is een verzamelnaam voor computersystemen die taken doen waarvoor mensen hun verstand gebruiken: een gezicht herkennen, een tekst vertalen, een route voorspellen. Bijna alle moderne AI werkt met machinaal leren, zoals de drempel hierboven, maar dan met duizenden tot miljarden getallen tegelijk, geleerd uit enorme hoeveelheden voorbeelden.
| vast algoritme | systeem dat leert uit voorbeelden | |
|---|---|---|
| wie maakt de regel? | een mens | de computer, uit voorbeelden met het juiste antwoord |
| wat heb je nodig? | kennis van het probleem | veel goede, gelabelde voorbeelden |
| kan je uitleggen waarom? | ja, de regel staat er | bij één drempel wel; bij grote AI-systemen vaak niet |
| wanneer het beste? | als je de regel kent en ze eenvoudig is | als de regel te ingewikkeld is om op te schrijven (een ziek blad herkennen op een foto) |
| typische fout | een vergeten geval in de regel | slechte of eenzijdige voorbeelden: het systeem leert de fout mee |
Drie dingen om te onthouden:
- Een lerend systeem is zo goed als zijn voorbeelden. Zijn de voorbeelden slordig of eenzijdig (allemaal uit de zomer, allemaal van één soort plant), dan leert het die fout mee.
- Het maakt fouten, ook als het zeker lijkt. Ook de beste drempel had hier 2 fouten op 17. Een AI-systeem zegt zelden 'ik weet het niet'.
- Het begrijpt niet wat het doet. De computer weet niet wat een plant of water is; hij zoekt een getal dat de voorbeelden zo goed mogelijk scheidt. Een mens blijft verantwoordelijk voor wat er met de uitkomst gebeurt.
Een AI-systeem dat een ziek blad herkent op een foto, heeft geleerd welke patronen van pixels vaak samengaan met het label 'ziek'. Het weet niets van schimmels of plantencellen. Het kan daardoor dingen zien die een mens mist, maar ook domme fouten maken die een mens nooit zou maken, bijvoorbeeld als de foto van een andere camera komt dan de voorbeelden.
Voor de meetkas is de vaste regel de beste keuze: ze is eenvoudig, uit te leggen en te controleren. Lerende systemen komen terug in Intermediate (een beslisboom die voorspelt of de planten water nodig hebben) en in Expert (neurale netwerken).
Overzicht: computationeel denken
De gereedschappen, de symbolen en de regels om een algoritme na te spelen en te verbeteren.
| gereedschap | vraag die je stelt | resultaat |
|---|---|---|
| decompositie | Uit welke deelproblemen bestaat dit? | een boom van kleine taken |
| patroonherkenning | Wat komt telkens terug? | één oplossing die je vaker gebruikt (een lus) |
| abstractie | Welke gegevens veranderen de beslissing? | een eenvoudig model |
| algoritme | Welke stappen, in welke volgorde? | een stappenplan of stroomdiagram |
| symbool | betekenis | pijlen eruit |
|---|---|---|
| ovaal | start of stop | Start: 1; Stop: 0 |
| rechthoek | handeling | 1 |
| ruit | beslissing (ja/nee-vraag) | 2, met 'ja' en 'nee' |
| parallellogram | invoer of uitvoer | 1 |
| naspelen met een trace-tabel | debuggen |
|---|---|
| één kolom per variabele (en eventueel voor de uitvoer) | speel na en vergelijk met wat je verwacht |
| één nieuwe rij na elke stap die iets verandert | test gewone gevallen, grensgevallen en rare gevallen |
| schrijf elke waarde op, ook als ze niet verandert | verander één ding tegelijk en test opnieuw |
Waar computationeel denken naartoe leidt
Dit hoofdstuk is het begin van de leerlijn programmeren en computationeel denken. Alles wat volgt, van blokken tot Python en C++, is een manier om een algoritme op te schrijven voor een machine. Het raakt ook de leerlijn wiskundig modelleren (abstractie is modelleren; tweemachten tellen de stappen van binair zoeken) en de leerlijn data en AI: je zag hoe een regel geleerd wordt uit gelabelde voorbeelden, en waarom goede voorbeelden zo belangrijk zijn.
Systeemdenken: invoer, proces, uitvoer en terugkoppeling, de basis van elk algoritme dat iets bestuurt.
Debuggen is onderzoeken: één ding veranderen, testen, besluiten.
Schakelaars in serie en parallel zijn EN en OF: dezelfde logica als twee ruiten na elkaar.
Van stroomdiagram naar blokprogramma: raad het getal en een simulatie van de kas in Scratch.
Het algoritme 'water geven' draait echt, met een sensor, een relais en een pomp.
Dezelfde algoritmen in tekst: if, while en for in Python.
Trainen en testen, een beslisboom die leert of de planten water nodig hebben, en bias in data.
Hoe snel is een algoritme? Sorteren en zoeken met de O-notatie.
Machinaal leren met veel kenmerken tegelijk, en hoe je meet hoe goed een model is.
In het kort
- Computationeel denken gebruikt vier gereedschappen: decompositie (opdelen), patroonherkenning (herhalingen zien), abstractie (weglaten wat niet telt) en algoritme (een stappenplan).
- Een algoritme is eenduidig, heeft een vaste volgorde, stopt (tenzij het met opzet eindeloos doorgaat) en zet invoer om in uitvoer.
- Een stroomdiagram gebruikt een ovaal (start/stop), rechthoek (handeling), ruit (beslissing met ja en nee) en parallellogram (invoer/uitvoer); een pijl terug maakt een lus.
- Met een trace-tabel speel je een algoritme stap voor stap na: één kolom per variabele, één rij per stap.
- Veelvoorkomende bugs: verkeerde volgorde, ontbrekende beginwaarde, oneindige lus, verkeerde vergelijking op de grens, een ruit met één uitgang.
- Een vaste regel schrijft een mens; bij machinaal leren zoekt de computer de regel met de minste fouten op gelabelde voorbeelden. Een lerend systeem is zo goed als zijn voorbeelden en begrijpt niet wat het doet.
- De meetkas geeft 30 s water (240 mL) als het bodemvocht onder 30 % zakt en het reservoir niet leeg is, en wacht dan 15 minuten.
Wat je nu kent
- computationeel denken
- Een probleem zo opdelen, vereenvoudigen en beschrijven dat een computer (of een mens) het met een stappenplan kan oplossen.
- decompositie
- Een groot probleem opdelen in kleinere deelproblemen die je apart kan oplossen.
- patroonherkenning
- Zien welke stappen of situaties telkens terugkomen, zodat je één oplossing vaker kan gebruiken.
- abstractie
- Alleen de gegevens overhouden die voor het probleem tellen, en de rest weglaten.
- algoritme
- Een eindig, eenduidig stappenplan dat bij dezelfde invoer altijd tot dezelfde uitkomst leidt.
- stroomdiagram
- Tekening van een algoritme met vaste symbolen: ovaal (start/stop), rechthoek (handeling), ruit (beslissing), parallellogram (invoer/uitvoer) en pijlen.
- lus
- Een deel van een algoritme dat herhaald wordt, tot een voorwaarde bereikt is (of altijd).
- trace-tabel
- Tabel waarin je bij het naspelen van een algoritme na elke stap de waarde van de variabelen noteert.
- bug
- Een fout in een algoritme of programma; debuggen is die fout opsporen en verbeteren.
- machinaal leren
- Een computer zoekt zelf een regel uit voorbeelden waarvan het juiste antwoord gegeven is (gelabelde voorbeelden).
- artificiële intelligentie (AI)
- Verzamelnaam voor computersystemen die taken doen waarvoor mensen intelligentie gebruiken; de meeste moderne AI werkt met machinaal leren.