Handboek · hoofdstuk 23Programmeren met blokken
Sequentie, herhaling, keuze en variabelen: programmeren door blokken te stapelen
In het vorige hoofdstuk tekende je algoritmen op papier. Nu voer je ze uit op een computer. Met blokken programmeer je zonder typfouten: elk blok is een commando, en ze passen alleen in elkaar als het klopt. Je leert de bouwstenen van elk programma kennen (volgorde, herhaling, keuze, variabelen en gebeurtenissen), je zet een stroomdiagram om in blokken en je jaagt op bugs. Tot slot bouw je een simulatie van de meetkas, zodat je het algoritme 'water geven' kan testen voor er één druppel water valt.
- Je kan de soorten blokken (hoed-, stapel-, C-, waarde-, ja/nee- en eindblok) herkennen en hun categorie benoemen.
- Je kan een programma bouwen met een sequentie, een herhaling (herhaal, herhaal tot, eindeloos) en een keuze (als ... dan ... anders).
- Je kan een variabele gebruiken als teller: een beginwaarde geven, verhogen of verlagen, en de waarde gebruiken.
- Je kan uitleggen wat een gebeurtenis is en scripts laten samenwerken met signalen.
- Je kan een stroomdiagram omzetten in een blokprogramma en omgekeerd.
- Je kan een programma naspelen en fouten vinden en verbeteren (debuggen), met een trace-tabel en door één ding tegelijk te veranderen.
- Je kan het algoritme 'water geven' testen in een simulatie van de meetkas in blokken.
Programmeren zonder te typen
Lang was programmeren iets voor wie foutloos lange regels tekst kon typen, met haakjes, puntkomma's en woorden als while. Eén vergeten teken en het programma werkte niet. In het Media Lab van het MIT in Boston zocht een groep rond Mitchel Resnick een manier om kinderen te laten programmeren zoals ze met bouwstenen spelen. In mei 2007 ging Scratch online: commando's zijn gekleurde blokken die als puzzelstukken in elkaar klikken. Een blok dat niet past, klikt niet vast. De huidige versie, Scratch 3.0, verscheen op 2 januari 2019. Scratch is gratis, bestaat in tientallen talen (ook het Nederlands) en wordt wereldwijd gebruikt door tientallen miljoenen jongeren.
Het idee sloeg aan. Google maakte met Blockly een bibliotheek om zelf blokeditors te bouwen, en Microsoft bouwde daarmee MakeCode. In 2016 kregen ongeveer een miljoen Britse leerlingen een BBC micro:bit, een klein bordje met 25 lampjes, twee knoppen en sensoren, dat je met MakeCode in blokken programmeert. Voor de Arduino bestaan dan weer blokeditors zoals mBlock.
Achter elk blok zit gewone programmacode. In MakeCode kan je met één klik wisselen tussen blokken en JavaScript of Python. Wat je hier leert (volgorde, lussen, keuzes, variabelen), gebruik je later in elke programmeertaal: in Python (Intermediate, hoofdstuk 27) en in C++ voor de Arduino (hoofdstuk 24 en Intermediate, hoofdstuk 29).
De blokken van Scratch
Een Scratch-programma bestaat uit sprites (figuurtjes op het speelveld) met elk hun eigen scripts. De blokken zitten in categorieën met een eigen kleur: Beweging (blauw), Uiterlijken (paars), Geluid (roze), Gebeurtenissen (geel), Besturen (oranje), Waarnemen (lichtblauw), Functies (groen), Variabelen (donkeroranje) en Mijn blokken (rood). De vorm van een blok zegt waar het past.
- 1Hoedblok
Staat bovenaan en start het script als er iets gebeurt (hier: een klik op de groene vlag). Er kan niets boven.
- 2Stapelblok
Een gewoon commando. De inkeping bovenaan en het nokje onderaan klikken in de blokken erboven en eronder.
- 3C-blok
Heeft een mond waarin andere blokken passen: herhaal, herhaal tot, als ... dan. Het pijltje rechtsonder toont een lus.
- 4Invoervak
Een wit vak waarin je een getal of tekst typt. Je kan er ook een rond blok in slepen.
- 5Ja/nee-blok
Zeshoekig: een voorwaarde die waar of niet waar is. Past alleen in een zeshoekige opening (als, herhaal tot, wacht tot).
- 6Waardeblok
Rond: geeft een getal of tekst terug, zoals de waarde van een variabele. Past in elk rond of wit vak.
- 7Eindblok
Onderaan plat: er kan niets meer onder. 'stop alle' beëindigt alle scripts.
Sequentie: de volgorde telt
De eenvoudigste structuur is de sequentie: de blokken worden van boven naar onder uitgevoerd, één na één. Een blok begint pas als het vorige klaar is. Bij 'zeg Hallo! 2 sec.' wacht het script dus twee seconden voor het volgende blok aan de beurt is.
Script A en script B bevatten dezelfde vier blokken, in een andere volgorde. De sprite start ergens op het speelveld. Script A zet ze eerst in het midden (x = 0, y = 0), zegt 'Hallo!' en loopt dan 100 stappen naar rechts: ze eindigt op x = 100. Script B loopt eerst 100 stappen vanaf waar ze toevallig stond, zegt daar 'Hallo!' en springt dan naar het midden: ze eindigt op x = 0. Zelfde blokken, ander resultaat.
Het speelveld van Scratch is 480 stappen breed en 360 hoog. Het midden is x = 0, y = 0; rechts is x positief, boven is y positief. Eén stap is één beeldpunt.
Herhaling: herhaal, herhaal tot en eindeloos
Wie een vierkant wil lopen, herhaalt vier keer hetzelfde paar: 100 stappen, kwartdraai. Dat patroon (hoofdstuk 22) zet je in een lus. Scratch heeft drie soorten:
| blok | wat het doet | voorbeeld |
|---|---|---|
| herhaal (10) | voert de mond een vast aantal keer uit | vier zijden van een vierkant |
| herhaal tot <voorwaarde> | herhaalt tot de voorwaarde waar is; de voorwaarde wordt vóór elke ronde gecontroleerd | aftellen tot 0 |
| herhaal (zonder getal) | herhaalt eindeloos, tot je op het stopteken klikt | een animatie, een thermostaat |
In de Nederlandse Scratch heet het blok voor een vast aantal keer herhaal (10), en het eindeloze blok gewoon herhaal, zonder getal. Het eindeloze blok heeft onderaan geen nokje: er kan niets onder, want het houdt nooit op. In het Engels heten ze repeat en forever.
Het derde script toont een animatie: steeds het volgende uiterlijk, met een korte pauze. Zonder het blok 'wacht 0.5 sec.' wisselt het uiterlijk zo snel dat je niets ziet bewegen.
Hoeveel keer loopt de lus?
Een sprite moet een regelmatige zeshoek lopen met zijden van 80 stappen. (a) Welk getal zet je in 'herhaal' en in 'draai'? (b) Hoeveel stappen legt de sprite in totaal af? (c) Hoeveel blokken bespaar je met de lus?
- zeshoek: 6 gelijke zijden van 80 stappen
- na een volledige toer kijkt de sprite weer dezelfde kant op
- getallen in herhaal en draai
- totale afstand
- bespaarde blokken
- 1Een zeshoek heeft 6 zijden: herhaal (6).
- 2Na zes keer draaien heeft de sprite één volle toer gedraaid: per keer, dus draai (60) graden.
- 3Afstand: stappen, precies de breedte van het speelveld.
- 4Zonder lus: 6 × 2 = 12 blokken. Met lus: herhaal + 2 blokken = 3 blokken. Je bespaart 9 blokken, en om een achthoek te maken verander je maar twee getallen (8 en 45).
Keuze: als ... dan ... anders
Met een keuze doet het programma iets anders naargelang de situatie. Het blok als <voorwaarde> dan voert zijn mond alleen uit als de voorwaarde waar is. Het blok als ... dan ... anders heeft twee monden: de eerste als de voorwaarde waar is, de tweede als ze niet waar is. Het is de ruit van het stroomdiagram.
Een voorwaarde is een zeshoekig blok. Je maakt er een met een vergelijking uit Functies (<, =, >) of met een vraag uit Waarnemen: is een toets ingedrukt, raakt de sprite de rand? Met en, of en niet combineer je voorwaarden, zoals schakelaars in serie (EN) en parallel (OF) in hoofdstuk 18.
In het script hiernaast is 'antwoord < 12' niet waar voor 12. Wie 12 is, krijgt dus 'Veel plezier!'. Wil je 12 ook laten wachten, dan schrijf je 'antwoord < 13'. Scratch heeft geen blok voor ≤: test daarom altijd precies op de grens.
Variabelen en tellers
Een variabele is een doos met een naam, waarin het programma een waarde bewaart. Je maakt ze bij Variabelen met 'Maak een variabele'. Drie blokken doen het werk:
- maak [score] (0): leeg de doos en stop er 0 in (de beginwaarde);
- verander [score] met (1): tel 1 bij wat erin zit (met −1 tel je af);
- (score): het ronde blok geeft de inhoud, om te tonen of te vergelijken.
Een teller is een variabele die bij elke gebeurtenis met dezelfde stap verandert: punten in een spel, pogingen bij raad het getal, pompbeurten in de meetkas. De vaste volgorde is: beginwaarde geven vóór de lus, veranderen in de lus, gebruiken na (of in) de lus.
'maak [score] (0)' betekent niet 'score is 0' zoals in een wiskundige gelijkheid, maar: 'zet vanaf nu 0 in de doos score'. Daarom mag 'verander [score] met (1)' gewoon: de nieuwe inhoud is de oude plus 1. Vergelijken doe je met het groene blok 'score = 10'.
In een invoervak van Scratch typ je een decimaal getal met een punt: 0.24, niet 0,24. Met een komma begrijpt Scratch het getal niet.
Aftellen met een teller
Speel het aftelscript na. Wat zegt de sprite, en hoe lang duurt het voor 'Start!' verschijnt? Hoeveel keer wordt de mond van de lus uitgevoerd?
- beginwaarde tijd = 10
- herhaal tot tijd = 0: zeg tijd 1 sec., verander tijd met −1
- wat de sprite zegt
- hoe lang het duurt
- aantal rondes
- 1Voor de eerste ronde: is tijd = 0? Nee (10). De sprite zegt 10 en tijd wordt 9.
- 2
ronde tijd vóór de ronde tijd = 0? sprite zegt tijd na de ronde 1 10 nee 10 9 2 9 nee 9 8 ... ... ... ... ... 10 1 nee 1 0 (11) 0 ja: lus stopt Start! - 3Elke ronde duurt 1 seconde (het zeg-blok wacht). Tien rondes: 10 s, daarna meteen 'Start!'.
Gebeurtenissen: wanneer ...
Een script start pas als er iets gebeurt: een gebeurtenis (in het Engels event). Het gele hoedblok bepaalt welke: de groene vlag, een toets, een klik op de sprite, of een signaal van een ander script. Scripts die door dezelfde gebeurtenis starten, lopen tegelijk.
Met zend signaal laat je scripts samenwerken, ook van verschillende sprites. De kat zegt 'Klaar?' en zendt dan het signaal 'start'. De hond wacht daarop en loopt pas dan weg. Zo bepaal je de volgorde tussen sprites zonder met wachttijden te moeten rekenen.
Ook een microcontroller werkt met gebeurtenissen. In MakeCode voor de micro:bit start het blok bij opstarten één keer als het bordje stroom krijgt, en wanneer knop A wordt ingedrukt telkens als je op knop A drukt. Het blok de hele tijd is de eindeloze lus van de micro:bit.
Maak liever drie korte scripts met elk hun eigen gebeurtenis dan één lang script dat alles controleert. Zo zie je meteen welk script wat doet, en kan je elk apart testen.
Van stroomdiagram naar blokken: raad het getal
Zet het stroomdiagram van raad het getal uit hoofdstuk 22 om in een Scratch-programma. Tel ook het aantal pogingen en toon het op het einde.
- het stroomdiagram uit hoofdstuk 22
- Scratch-blokken: vraag ... en wacht, antwoord, willekeurig getal tussen ... en ...
- een werkend blokprogramma met een teller voor de pogingen
- 1Start → hoedblok 'wanneer op de groene vlag wordt geklikt'.
- 2Kies een geheim getal (rechthoek) → een variabele: 'maak [geheim] (willekeurig getal tussen 1 en 100)'. Voor de teller: 'maak [pogingen] (0)'.
- 3De lus met de ruit 'gok = geheim?' → 'herhaal tot <antwoord = geheim>'. Zolang het antwoord niet juist is, loopt de lus. De ja-uitgang van de ruit is het einde van de lus.
- 4Vraag een gok (parallellogram) → 'vraag [Raad mijn getal!] en wacht'; het ronde blok 'antwoord' bevat wat de speler typt. Meteen daarna: 'verander [pogingen] met (1)'.
- 5De ruit 'gok < geheim?' → 'als <antwoord < geheim> dan zeg hoger, anders ...'. In de anders-mond komt nog een 'als <antwoord > geheim> dan zeg lager': bij een juiste gok moet de sprite niets zeggen, want de lus stopt dan.
- 6Toon 'Juist!' → na de lus: 'zeg (voeg [Juist! Pogingen: ] en (pogingen) samen)'.
Hetzelfde spel in tekst
Programmeertalen zoals Python gebruiken dezelfde bouwstenen, maar dan in tekst. Leg het programma naast de blokken: random.randint(1, 100) is 'willekeurig getal tussen 1 en 100', while antwoord != geheim: is 'herhaal tot antwoord = geheim' (!= betekent 'is niet gelijk aan'), input is 'vraag en wacht' en if / elif is 'als ... dan ... anders als'. De inspringing (vier spaties) doet wat de mond van een C-blok doet. Je hoeft dit nog niet te kunnen schrijven: in Intermediate (hoofdstuk 27) leer je het.
import random geheim = random.randint(1, 100) # willekeurig getal tussen 1 en 100pogingen = 0antwoord = 0while antwoord != geheim: # herhaal tot antwoord = geheim antwoord = int(input("Raad mijn getal (1 tot 100): ")) pogingen = pogingen + 1 if antwoord < geheim: print("hoger") elif antwoord > geheim: print("lager")print("Juist! Pogingen:", pogingen)Zo verloopt een spelletje (gecontroleerd door het programma te draaien; geheim getal 31, de speler raadt met halveren):
Raad mijn getal (1 tot 100): 50 lager Raad mijn getal (1 tot 100): 25 hoger Raad mijn getal (1 tot 100): 37 lager Raad mijn getal (1 tot 100): 31 Juist! Pogingen: 4
Eén verschil: int(...) zet de getypte tekst om in een getal. Typt de speler 'appel', dan stopt Python met een foutmelding, waar Scratch gewoon verder doet.
Debuggen: fouten vinden en verbeteren
Een programma doet zelden meteen wat je wil. Debuggen is geen falen, het is de helft van het werk. Het script in de figuur moet van 10 aftellen, maar er zitten drie fouten in:
- Geen hoedblok. Het script start nooit vanzelf. Zet 'wanneer op de groene vlag wordt geklikt' erboven.
- De beginwaarde staat in de lus. Elke ronde wordt tijd opnieuw 10. Het blok hoort vóór de lus (het staat er al; dit tweede exemplaar moet weg).
- Verkeerde richting. 'verander tijd met 1' telt op: tijd wordt nooit 0. Maak er −1 van.
Zes gewoonten maken debuggen sneller:
- Lees hardop wat er staat, niet wat je bedoelde.
- Toon je variabelen: zet het vinkje naast de variabele aan, dan zie je haar waarde op het speelveld veranderen.
- Vertraag: een 'wacht 1 sec.' in de lus laat je elke stap zien.
- Speel na met een trace-tabel (hoofdstuk 22).
- Test klein: bouw een paar blokken, test, bouw verder.
- Verander één ding tegelijk, zoals bij een eerlijke proef (hoofdstuk 2). Verander je drie dingen en werkt het, dan weet je niet welke verandering hielp.
Ingenieurs noemden een storing in een machine al in de negentiende eeuw een bug (een beestje). Beroemd werd een logboek van de Mark II-computer aan de universiteit van Harvard: op 9 september 1947 vonden de technici een mot tussen de contacten van een relais. Ze plakten ze in het logboek, met de opmerking dat dit het eerste echte geval van een bug was. De computerpionier Grace Hopper vertelde het verhaal graag verder. Het logboek ligt vandaag in een museum in Washington.
Hoe snel reageer jij?
Hoeveel tijd zit er tussen het moment dat je iets ziet veranderen en het moment dat je op een toets drukt?
- computer met Scratch 3
- een sprite met twee uiterlijken: 'rood' en 'groen' (bv. een cirkel)
- 1Bouw het script uit de figuur. Het wacht een willekeurige tijd tussen 2 en 5 s voor het groen wordt.
- 2Druk op de groene vlag, wacht tot de sprite groen wordt en druk dan zo snel mogelijk op de spatiebalk.
- 3Noteer de tijd die de sprite zegt. Herhaal tot je tien metingen hebt.
- 4Bereken het gemiddelde. Kijk of er een meting is die sterk afwijkt, en zoek een verklaring.
- 5Probeer ook: wat gebeurt er als je op de spatiebalk drukt vóór de sprite groen wordt?
Tien metingen van één leerling (in seconden): 0,31; 0,28; 0,35; 0,27; 0,30; 0,42; 0,29; 0,26; 0,33; 0,30. Gemiddelde: . De meting van 0,42 s wijkt af: de leerling keek even weg. Zonder die meting is het gemiddelde 0,30 s. Scratch toont veel decimalen (bijvoorbeeld 0.3125); die zijn niet allemaal zinvol. Wie te vroeg drukt, krijgt een tijd van bijna 0: het script test pas na de groene kleur.
Een reactietijd van 0,2 à 0,3 s is gewoon: je ogen, je hersenen en je spieren hebben tijd nodig. De willekeurige wachttijd maakt de proef eerlijk: met een vaste wachttijd zou je leren voorspellen in plaats van reageren. Het programma meet niet oneindig precies: Scratch kijkt ongeveer 30 keer per seconde of de toets al ingedrukt is, dus een meting kan tot een paar honderdsten van een seconde te laat zijn. Daarom rond je af op 0,01 s en neem je het gemiddelde van tien metingen (hoofdstuk 2).
Habitat: de meetkas als simulatie
Voor je een echte pomp aansluit, test je het algoritme 'water geven' (hoofdstuk 22) in een simulatie. Het model: het bodemvocht daalt elk uur 5 procentpunt; een pompbeurt van 30 s (240 mL) maakt het 16 procentpunt hoger. Simuleer 48 uur met de drempel 30 %. Hoeveel beurten zijn er, en hoeveel water blijft er over in het reservoir van 30 L?
- start: vocht 50 %, reservoir 30 L
- per uur: vocht − 5
- onder 30 %: vocht + 16, water − 0,24 L
- 48 herhalingen (één per uur)
- het blokprogramma
- aantal beurten en water over na 48 h
- vergelijking met 1,8 L per dag
- 1Abstractie. Drie variabelen: vocht, water en beurten. Eén ronde van de lus is één uur; de wachttijd van 0.2 s laat je het verloop zien zonder twee dagen te wachten.
- 2Algoritme. In de lus: eerst het vocht laten dalen (de planten drinken), dan de keuze 'als vocht < 30 dan geef water'. De teller 'beurten' telt de pompbeurten.
- 3Naspelen. 50, 45, 40, 35, 30 (30 is niet kleiner dan 30), 25 → beurt → 41, 36, 31, 26 → beurt → 42, ... Na de eerste beurt geeft de kas ongeveer om de drie uur water.
- 4Uitkomst. Na 48 uur zijn er 14 beurten geweest: water, er blijft 26,64 L over.
- 5Vergelijken. Op lange termijn daalt het vocht 120 procentpunt per dag; dat vraagt beurten, of per dag: precies het verbruik uit het stationsdossier. In de eerste 48 uur zijn het er iets minder, omdat de grond nat begon.
Overzicht: de belangrijkste blokken
De blokken uit dit hoofdstuk met hun Nederlandse naam in Scratch 3, en de Engelse naam die je in handleidingen tegenkomt.
| categorie | blok (Nederlands) | Engels | wat het doet |
|---|---|---|---|
| Gebeurtenissen | wanneer op de groene vlag wordt geklikt | when green flag clicked | start het script |
| Gebeurtenissen | wanneer [spatiebalk] is ingedrukt | when [space] key pressed | start bij een toets |
| Gebeurtenissen | zend signaal [...] / wanneer ik signaal [...] ontvang | broadcast / when I receive | scripts laten samenwerken |
| Besturen | wacht (1) sec. | wait (1) seconds | pauze |
| Besturen | herhaal (10) | repeat (10) | vast aantal keer |
| Besturen | herhaal tot <...> | repeat until | tot de voorwaarde waar is |
| Besturen | herhaal | forever | eindeloos |
| Besturen | als <...> dan / anders | if then / else | keuze |
| Besturen | wacht tot <...> | wait until | wachten op een voorwaarde |
| Besturen | stop [alle] | stop [all] | alles stoppen |
| Variabelen | maak [..] (0) / verander [..] met (1) | set to / change by | beginwaarde / tellen |
| Functies | (..) < (..), (..) = (..), (..) > (..) | <, =, > | vergelijken |
| Functies | <..> en <..>, of, niet | and, or, not | voorwaarden combineren |
| Functies | willekeurig getal tussen (1) en (10) | pick random | toeval |
| Waarnemen | vraag (..) en wacht / (antwoord) | ask and wait / answer | invoer van de gebruiker |
| Waarnemen | zet klok op 0 / (klok) | reset timer / timer | tijd meten |
| Uiterlijken | zeg (..) (2) sec. | say for secs | uitvoer in een tekstballon |
| stroomdiagram | blok |
|---|---|
| Start | hoedblok (gebeurtenis) |
| handeling | stapelblok |
| invoer / uitvoer | vraag en wacht / zeg |
| ruit zonder lus terug | als ... dan (... anders) |
| ruit met een lus terug | herhaal tot <voorwaarde> |
| lus die nooit stopt | herhaal (eindeloos) |
| Stop | einde van het script of 'stop alle' |
Waar blokken naartoe leiden
Blokken zijn de eerste programmeertaal van de leerlijn programmeren en computationeel denken. De vier bouwstenen (sequentie, herhaling, keuze, variabelen) plus gebeurtenissen vind je in elke taal terug. Met de simulatie raak je ook de leerlijn wiskundig modelleren: een model doorrekenen stap voor stap, zoals later met de methode van Euler.
Het stroomdiagram en het algoritme 'water geven' die je hier in blokken omzet.
Debuggen en de reactietijdproef: één ding tegelijk veranderen, herhalen, gemiddelde nemen.
Dezelfde blokken sturen een echte led en lezen een echte drukknop op een Arduino of micro:bit.
De simulatie wordt werkelijkheid: een sensor meet het vocht en een relais zet de pomp aan.
Van blokken naar tekst: if, while en for in Python.
Gebeurtenissen en toestanden netjes ordenen: dag, nacht, alarm.
Een simulatie stap voor stap doorrekenen: de methode van Euler is dezelfde lus met een wiskundig model.
In het kort
- Een blokprogramma bestaat uit scripts; een hoedblok start het script bij een gebeurtenis.
- De vorm zegt waar een blok past: stapelblok, C-blok (met mond), rond waardeblok, zeshoekig ja/nee-blok, eindblok.
- Sequentie: blokken worden van boven naar onder uitgevoerd; de volgorde bepaalt het resultaat.
- Herhaling: herhaal (n) voor een vast aantal keer, herhaal tot voor 'tot een voorwaarde waar is', herhaal (zonder getal) voor eindeloos.
- Keuze: als ... dan ... anders voert een van twee monden uit, afhankelijk van een voorwaarde. Test altijd op de grens.
- Een variabele is een doos met een naam; een teller krijgt een beginwaarde vóór de lus en verandert in de lus.
- Debuggen: lees hardop, toon variabelen, vertraag, speel na, test klein, verander één ding tegelijk.
- In de simulatie van de meetkas blijft het vocht tussen 30 en 45 %, met gemiddeld 7,5 beurten (1,8 L) per dag.
Wat je nu kent
- script
- Een reeks blokken die aan elkaar vastzitten en samen uitgevoerd worden, meestal onder een hoedblok.
- sequentie
- Blokken die na elkaar worden uitgevoerd, in de volgorde waarin ze gestapeld zijn.
- herhaling (lus)
- Een blok dat de blokken in zijn mond meerdere keren uitvoert: een vast aantal keer, tot een voorwaarde waar is, of eindeloos.
- keuze
- Een blok dat afhankelijk van een voorwaarde de ene of de andere groep blokken uitvoert: als ... dan ... anders.
- voorwaarde
- Een uitdrukking die waar of niet waar is, zoals 'vocht < 30'; in Scratch een zeshoekig blok.
- variabele
- Een geheugenplaats met een naam, waarin het programma een waarde bewaart die kan veranderen.
- teller
- Een variabele die telkens met een vaste stap verandert, om iets te tellen.
- gebeurtenis (event)
- Iets wat gebeurt (klik op de groene vlag, een toets, een signaal) en een script laat starten.
- debuggen
- Fouten in een programma opsporen en verbeteren.
- simulatie
- Een programma dat een echt systeem nabootst met een vereenvoudigd model, om het te kunnen testen.