Problemen oplossen met algoritmen en computationeel denken

Een computer kan een route berekenen, een geluid afspelen of een lijst met namen ordenen. Informatica onderzoekt de processen achter deze taken: hoe informatie wordt weergegeven en verwerkt, welke problemen kunnen worden opgelost en hoe je systemen bouwt die de oplossingen uitvoeren.

Beschrijf een berekening

Een bruikbaar startmodel is invoer → verwerking → uitvoer. Een routeplanner ontvangt een startpunt en een bestemming. De routeplanner doorzoekt informatie over wegen en geeft vervolgens een route, een afstand in kilometers en een reistijd terug. De wegeninformatie bestaat ook uit gegevens die het proces nodig heeft. Het zichtbare resultaat is slechts één onderdeel van de berekening.

Beschrijf een computationeel probleem voordat je een methode kiest. Bijvoorbeeld: “Invoer: een lijst met namen. Uitvoer: dezelfde namen in alfabetische volgorde.” Dit legt vast hoe een correct resultaat eruit moet zien. Het laat ruimte voor verschillende methoden om dat resultaat te bereiken. Als de uitvoer een naam weglaat, is het probleem niet opgelost, ook als de overige namen op volgorde staan.

Meer dan code schrijven

Programmeren is instructies schrijven in een taal die een computer kan uitvoeren. Het is een belangrijke activiteit binnen de informatica. Het bredere vakgebied onderzoekt ook of er een oplossing bestaat, hoeveel werk die kost en hoe mensen die veilig en gemakkelijk kunnen gebruiken.

De grenzen overlappen. Bij het ontwerpen van een beeldbewerkingsprogramma kun je bijvoorbeeld tegelijkertijd te maken hebben met computergraphics, gebruikersinteractie en software-engineering. Informatica ondersteunt ook andere vakgebieden: biologen vergelijken DNA-sequenties, klimaatwetenschappers modelleren de atmosfeer en kunstenaars gebruiken software om afbeeldingen en muziek te maken.

Verwante vakgebieden en praktische grenzen

Computertechniek richt zich op fysieke apparaten zoals processors en printplaten. Informatietechnologie, of IT, richt zich op het kiezen, installeren en beheren van systemen voor een organisatie. Datawetenschap combineert statistiek en computertechnieken om conclusies uit gegevens te trekken. Deze vakgebieden delen methoden met informatica, maar leggen de nadruk op ander werk.

Computers voeren nauwkeurige instructies snel uit, vaak miljarden eenvoudige bewerkingen per seconde. Snelheid herstelt geen onduidelijke instructie. “Voeg wat zout toe” laat de hoeveelheid ongenoemd; een proces dat automatisch moet worden uitgevoerd, heeft een nauwkeurige handeling nodig.

Er zijn ook andere grenzen dan snelheid. Sommige nauwkeurig beschreven problemen hebben geen algoritmische oplossing. Andere problemen hebben oplossingen die te veel stappen vereisen om praktisch uitvoerbaar te zijn. Vragen wat een computer kan bereiken, maakt deel uit van de informatica zelf.

Computationeel denken maakt een probleem duidelijk genoeg om het stap voor stap op te lossen. Een mens kan de oplossing uitvoeren, een computer kan dat doen of ze kunnen het werk verdelen. Bij het denkwerk bepaal je ook wat het probleem inhoudt en hoe je een resultaat controleert.

Vier technieken die samenwerken

Decompositie deelt een probleem op in kleinere delen. Patroonherkenning vindt overeenkomsten of terugkerend werk. Abstractie behoudt de details die nodig zijn voor een doel en laat andere weg. Algoritmeontwerp zet een oplossing om in nauwkeurige, geordende stappen.

Dit zijn hulpmiddelen waarop je kunt terugvallen wanneer dat nodig is. Het zijn geen vier vakjes die je in een vaste volgorde moet afwerken. Een mislukte test kan een ontbrekend deelprobleem aan het licht brengen. Een terugkerend deelprobleem kan wijzen op een herbruikbare procedure. Een model heeft misschien nog een detail nodig voordat het algoritme kan werken.

Jeannette Wing hielp de term “computationeel denken” algemeen bekend te maken in een essay uit 2006. Haar belangrijkste boodschap was dat deze aanpak voor iedereen nuttig is, ook voor mensen die niet als programmeur werken.

Begrijp, plan, voer uit en controleer

De wiskundige George Pólya beschreef in 1945 vier fasen voor het oplossen van problemen. In de informatica leiden die tot concrete handelingen:

1. Begrijp het probleem. Bepaal de invoer, uitvoer, randvoorwaarden en succescriteria.
2. Maak een plan. Kies kleinere taken, bruikbare patronen en een algoritme.
3. Voer het plan uit. Geef het weer en voer het uit met pseudocode, een stroomdiagram of een programma.
4. Kijk terug. Vergelijk het resultaat met de succescriteria en pas de oplossing zo nodig aan.

Een randvoorwaarde is een regel waaraan de oplossing moet voldoen, zoals een maximale beschikbare tijd. Een succescriterium is een manier om het resultaat te beoordelen. “Maak één boodschappenlijst met de benodigde hoeveelheden” is te controleren. “Maak boodschappen doen beter” laat het resultaat onduidelijk.

Werk een maaltijdplan uit

Stel dat je avondmaaltijden voor een week nodig hebt. De invoer omvat de recepten, het aantal personen en het voedsel dat al beschikbaar is. De uitvoer is een plan en een boodschappenlijst. Dieetwensen en beschikbare kooktijd zijn randvoorwaarden.

Deel het werk op in maaltijden kiezen, de lijst maken en koken. Patroonherkenning laat zien dat verschillende recepten rijst en uien gebruiken. Abstractie geeft een ingrediënt weer met zijn naam en hoeveelheid, zoals “rijst, 1 kg”, zonder een merknaam te bewaren als het merk geen invloed heeft op het plan.

Je kunt het boodschappenalgoritme nu ordenen: kies de maaltijden, schrijf de ingrediënten op, voeg terugkerende ingrediënten samen, trek af wat al in de voorraadkast staat en koop wat overblijft. Door hoeveelheden samen te voegen voordat je de voorraadkast controleert, voorkom je dat dezelfde voorraad voor elk recept afzonderlijk wordt afgetrokken.

Controleer het resultaat aan de hand van de maaltijden. Elk benodigd ingrediënt moet in voldoende hoeveelheid beschikbaar zijn. Als een ingrediënt ontbreekt, ga dan na hoe de lijst is opgebouwd en pas de betreffende stap aan.

Een veelvoorkomende fout is beginnen met coderen voordat je hebt bepaald welk resultaat nodig is. Een snel programma kan het verkeerde probleem nauwgezet oplossen. Mensen kiezen nog steeds het model, de randvoorwaarden en de stappen; de computer voert de instructies uit die deze keuzes weergeven.

Een groot probleem kan moeilijk in één keer te overzien zijn. Decompositie vervangt het door kleinere deelproblemen die je afzonderlijk kunt begrijpen, oplossen en controleren. Samen moeten de delen nog steeds een oplossing voor het oorspronkelijke probleem vormen.

Werk van het geheel naar de details

Begin met de hoofdtaak. Deel die op in enkele betekenisvolle verantwoordelijkheden en werk vervolgens elke verantwoordelijkheid verder uit. Dit is top-downdecompositie. In een boomvormig decompositiediagram staat het hele probleem bovenaan met de kleinere taken eronder. De takken laten zien bij welke taak een kleinere taak hoort.

Bij een quizapp zijn de hoofddelen vragen en antwoorden opslaan, vragen stellen, antwoorden controleren en de score bijhouden en tonen. Het deel “een vraag stellen” kun je opsplitsen in de vraagtekst tonen, de antwoordopties tonen en de keuze van de lerende inlezen.

Een tekstueel structuurdiagram zou er zo uit kunnen zien:

Run a quiz
    Store questions and answers
    Ask a question
        Show question text
        Show answer options
        Read the choice
    Check the answer
    Keep and show the score

Deze takken beschrijven verantwoordelijkheden. Alleen hun verticale positie geeft niet de volledige uitvoeringsvolgorde aan. De app herhaalt bijvoorbeeld het stellen en controleren van vragen zolang er vragen over zijn. Een afzonderlijk algoritme beschrijft dat verloop.

Bepaal wanneer je stopt met opsplitsen

Een deel is klein genoeg wanneer je ziet hoe je het direct kunt oplossen, of wanneer een bestaande methode of bestaand hulpmiddel het afhandelt. “Lees de keuze” kan een bruikbare taak zijn zodra je weet hoe de interface invoer verzamelt. Als je die opsplitst in afzonderlijke handbewegingen, voeg je details toe die niet helpen bij het ontwerpen van de app.

Maak eerst de hoofdindeling. Als je begint met het beschrijven van kleine handelingen, besteed je gemakkelijk tijd aan één scherm terwijl je een volledige verantwoordelijkheid vergeet, zoals bepalen wanneer de quiz eindigt.

Bepaal afhankelijkheden

Een afhankelijkheid betekent dat een taak het resultaat van een andere taak nodig heeft. De quiz moet een keuze ontvangen voordat die wordt gecontroleerd en de keuze controleren voordat de score wordt bijgewerkt. Schrijf op wat elk deel ontvangt en oplevert. Zo worden de overdrachten duidelijk.

Delen moeten zo onafhankelijk mogelijk zijn. Als de weergave verandert van vier antwoordknoppen naar een andere invoermethode, moet de scoreberekening nog steeds met het gecontroleerde resultaat kunnen werken. Duidelijke grenzen maken het mogelijk dat mensen tegelijkertijd afzonderlijke delen bouwen en maken latere wijzigingen eenvoudiger.

Onafhankelijkheid betekent niet dat de delen nooit informatie uitwisselen. Ze hebben afgesproken invoer en uitvoer nodig. Een scoreonderdeel dat TRUE of FALSE verwacht, kan niet rechtstreeks de ruwe tekst van een onderdeel voor vraagweergave gebruiken zonder een stap die het antwoord controleert.

Zoek naar hiaten en overlap

Lees het oorspronkelijke probleem opnieuw en vraag je af of het voltooien van elk deel de hele taak zou afronden. Het eerste diagram laat niet zien wanneer de quiz stopt. Voeg die verantwoordelijkheid toe aan de algemene besturing van de quiz. Vraag ook of twee delen allebei de score veranderen, waardoor een correct antwoord mogelijk twee keer wordt geteld.

Controleer elk klein deel afzonderlijk en controleer daarna het gecombineerde proces. Een correcte vraagweergave en een correcte antwoordcontrole kunnen samen toch misgaan als het ene onderdeel een ander keuzeformaat stuurt dan het andere verwacht.

Achter terugkerend werk gaat vaak een herbruikbare methode schuil. Patroonherkenning betekent zoeken naar overeenkomsten, herhalingen of trends binnen een probleem en tussen verschillende problemen. De nuttige vraag is wat gelijk blijft en wat verandert.

Vind herhaling binnen een taak

Om een vierkant te tekenen kan een bewegende pen vier keer 100 stappen vooruitgaan en 90 graden naar rechts draaien. Het paar handelingen wordt herhaald. Een lus geeft dat paar eenmaal weer en bepaalt het aantal herhalingen:

REPEAT 4 TIMES
    Move forward 100 steps
    Turn right 90 degrees

Dit patroon maakt de structuur gemakkelijker zichtbaar. Het maakt ook aanpassen eenvoudiger: als je de afstand vooruit op één plaats verandert, veranderen alle zijden.

Vervang veranderende details door parameters

Generalisatie laat één oplossing voor een groep gevallen werken. Een parameter is een benoemde invoer die een detail weergeeft dat kan veranderen. Voor regelmatige veelhoeken kunnen het aantal zijden en de lengte van een zijde parameters zijn.

Een pen die een regelmatige veelhoek rondgaat, draait in totaal één volledige omwenteling. De draai bij elke hoek is:

Hier is $n$ het aantal zijden. Herhaal het paar van bewegen en draaien $n$ keer, met elke keer dezelfde zijdelengte en draaihoek.

De draai is de verandering van de richting van de pen, niet de binnenhoek van de veelhoek. Bij een driehoek zou een draai van 60 graden niet het bedoelde pad met drie zijden opleveren.

Herken dezelfde methode in verschillende problemen

Bij het vinden van de goedkoopste vlucht, de kortste route en de hoogste toetsscore moet je steeds de beste kandidaat onthouden die je tot dan toe hebt gezien. Begin met een kandidaat. Bekijk elke volgende kandidaat en vervang de onthouden kandidaat wanneer de nieuwe beter is. De richting van de vergelijking verandert tussen laagste en hoogste, maar het algemene patroon blijft bruikbaar.

Patronen kunnen ook gegevens ordenen. Als je uitgaven groepeert in voeding, vervoer en wonen, worden gemeenschappelijke kenmerken zichtbaar. Als de verkoop van paraplu’s herhaaldelijk stijgt wanneer er regen wordt voorspeld, kan een winkel de trend gebruiken om de voorraad te helpen plannen. Een trend is een aanwijzing om te onderzoeken; de reden waarom die geldt, is van belang als je bepaalt of die zal aanhouden.

Controleer het voorgestelde patroon

De getallen 1, 2, 4 bepalen het volgende getal niet eenduidig. Verdubbelen geeft 8. De verschillen steeds met één vergroten geeft 7, omdat de verschillen tot nu toe 1 en 2 zijn. Er zijn meer gevallen of een regel die de reeks verklaart nodig om te bepalen welk patroon bij het probleem past.

Zoek naar betekenisvolle verschillen voordat je een oplossing hergebruikt. Een rekening gelijk verdelen en die verdelen naar wat iedereen heeft besteld, hebben allebei betrekking op een gezamenlijk totaal. Gelijk verdelen lost de eerste taak op, maar voor de tweede is de bestelling van elke persoon nodig. Hergebruik de gemeenschappelijke structuur pas nadat je het detail hebt bepaald dat het vereiste resultaat verandert.

Een model kan eenvoudiger zijn dan de werkelijkheid en toch nuttig zijn. Abstractie behoudt de informatie die nodig is voor een bepaald doel en laat andere details weg. De kwaliteit hangt af van de vraag of het model de vragen van de taak kan beantwoorden.

Kies een model voor de taak

Een metrokaart behoudt stations, hun volgorde op elke lijn en plaatsen waar lijnen aansluiten. Die details helpen een reiziger een reis te plannen. De kaart kan afstanden vertekenen en straatpatronen weglaten omdat het belangrijkste doel is om verbindingen te tonen.

Diezelfde kaart is een slecht hulpmiddel om te bepalen hoe ver je tussen twee stations moet lopen. Het model heeft een detail weggelaten dat het nieuwe doel vereist. Een detail is relevant vanwege het probleem, niet omdat het in het algemeen interessant is.

Bekijk twee modellen van dezelfde auto:

Het racespel moet de beweging bijwerken. De garage moet de auto herkennen en het bezoek bijhouden. Geen van beide modellen hoeft elk fysiek kenmerk van de auto te behouden.

Verberg stappen achter een duidelijke naam

Abstractie laat je ook gebruiken wat een onderdeel doet zonder telkens te hoeven nadenken over hoe het werkt. Om een wasprogramma te kiezen hoef je de motor van de wasmachine niet rechtstreeks aan te sturen.

In een algoritme is een procedure een benoemde groep stappen. Door de naam aan te roepen worden die stappen uitgevoerd. Een naam zoals average(list) maakt een taak duidelijk en verbergt tegelijkertijd de terugkerende berekening. Een procedure die een resultaat terugstuurt naar degene die de procedure aanroept, heeft een retourwaarde. De aanroeper kan die waarde opslaan of in een andere berekening gebruiken.

Een parameter geeft een procedure invoer die kan veranderen. drawPolygon(sides, length) heeft twee parameters. De aanroep drawPolygon(6, 100) levert zes zijden en een lengte van 100 stappen. Dit combineert abstractie, die de tekenstappen verbergt, met generalisatie, die verschillende vormen en afmetingen ondersteunt.

De grens van een procedure moet duidelijk zijn: welke invoer accepteert de procedure en welk resultaat of welke handeling levert die op? Voor een gemiddelde vereist een lege lijst een speciale afhandeling omdat er geen aantal is om door te delen. Stappen verbergen neemt de noodzaak om bruikbare invoer te definiëren niet weg.

Bouw lagen van begrip op

Een chatapp biedt een manier om een bericht te versturen. Daaronder biedt het besturingssysteem diensten die de app kan gebruiken. Daaronder voert hardware bewerkingen uit. Elke laag vertrouwt op het gedrag van de volgende laag zonder elk intern detail aan de gebruiker van die laag te tonen. Een interne wijziging kan beperkt blijven tot die laag wanneer het beloofde gedrag gelijk blijft.

De technieken ondersteunen elkaar. Decompositie bepaalt de delen. Patroonherkenning vindt delen met een gemeenschappelijke structuur. Abstractie geeft die delen namen en duidelijke grenzen zodat ze kunnen worden gecombineerd.

Een veelgemaakte abstractiefout is een gegeven weglaten dat bepaalt of een resultaat werkt. Een routeplanner die eenrichtingsstraten negeert, kan een onmogelijke autoroute voorstellen. Om een model te controleren, schrijf je op welke beslissingen het moet ondersteunen en ga je na of de behouden gegevens voor elke beslissing voldoende zijn.

Een algoritme is een eindige, geordende verzameling nauwkeurige instructies om een probleem op te lossen of een taak te voltooien. Bij geldige invoer levert het na een eindig aantal stappen de vereiste uitvoer. Een recept, montage-instructies en staartdelen gebruiken allemaal dit idee.

Controleer de eigenschappen van de methode

Een bruikbaar algoritme heeft vastgelegde invoer en uitvoer. Elke stap moet nauwkeurig genoeg zijn om één betekenis te hebben en uitvoerbaar genoeg om te kunnen worden uitgevoerd. De stappen moeten eindigen en hun resultaat moet correct zijn voor elke geldige invoer.

“Zoek het grootste getal” noemt een doel, maar legt geen methode vast. “Bekijk elk getal en onthoud het grootste dat je tot dan toe hebt gezien” geeft een methode die je kunt uitwerken tot instructies. De methode roept ook een vraag over de invoer op: wat moet er gebeuren als de lijst leeg is? Door geldige invoer te definiëren voorkom je dat de methode onvolledig blijft.

Alledaagse instructies kunnen hiaten bevatten die mensen vanuit hun ervaring aanvullen. “Doe de jam op het brood” laat het openen van de pot en het smeren van een hoeveelheid op een oppervlak weg. Als je een methode voor automatische uitvoering ontwerpt, vermeld dan de handelingen die het uitvoerende systeem nodig heeft en zet ze in een bruikbare volgorde.

Maak onderscheid tussen de methode en de weergave ervan

Een algoritme is de oplossingsmethode. Een programma drukt een methode uit in een programmeertaal zodat een computer die kan uitvoeren. Hetzelfde algoritme kan voorkomen in pseudocode, in een stroomdiagram en in programma’s die in verschillende talen zijn geschreven.

Drie besturingsstructuren ordenen de uitvoering:

Samen met variabelen zijn deze structuren voldoende om elk algoritme uit te drukken. Dit is het idee achter een klassiek resultaat dat Böhm en Jacopini in 1966 publiceerden. Een algoritme kan ze combineren: doorloop een lijst, test elke waarde en werk een opgeslagen resultaat in volgorde bij.

Vergelijk correcte methoden

Stel dat een alfabetisch geordend telefoonboek 1.000 pagina’s heeft. Als je pagina’s één voor één controleert, kunnen 1.000 paginacontroles nodig zijn. Als je steeds twee pagina’s omslaat en alleen elke tweede pagina controleert, zijn maximaal ongeveer 500 controles nodig, plus één stap terug als je de naam voorbij bent gegaan.

Een andere methode opent het resterende deel in het midden en behoudt de helft die de naam kan bevatten. Met hoogstens 10 halveringen breng je 1.000 mogelijke pagina’s terug tot één:

1000 → 500 → 250 → 125 → 63 → 32
     → 16 → 8 → 4 → 2 → 1

Door de gesorteerde volgorde kun je veilig een helft weggooien. Zonder die volgorde zou de weggegooide helft de naam kunnen bevatten. Deze aanname over de invoer hoort bij de methode.

Bij 2.000 pagina’s kan elke pagina controleren twee keer zoveel controles kosten, terwijl halveren slechts één extra halvering kost: 11. Vergelijken hoe aantallen stappen groeien, verklaart meer dan één uitvoering op één machine timen.

Controleer de correctheid voordat je de snelheid prijst. Een methode die alleen het eerste en het laatste getal in een lijst bekijkt, vindt toevallig 12 in [7, 3, 12]. De methode mist 12 in [7, 12, 3]. Eén succesvol voorbeeld kan niet aantonen dat de methode het volledige invoerbereik aankan.

Pseudocode beschrijft een algoritme met gestructureerde, leesbare instructies. Het is niet gebonden aan één programmeertaal. Je kunt aan de logica werken voordat je rekening houdt met de leestekens en andere schrijfregels van een taal.

Lees de notatie

Sleutelwoorden worden met hoofdletters geschreven: INPUT, OUTPUT, IF, WHILE en FOR. Elke instructie heeft een eigen regel. Inspringing laat zien welke instructies bij een blok horen. Commentaar begint met // en legt de code uit zonder een handeling toe te voegen.

De pijl ← betekent toekenning. Sommige andere pseudocodeconventies gebruiken = of SET … TO voor toekenning. Hier vergelijkt = waarden. Lees count ← 0 als “count krijgt nul”. Een variabele is een benoemde plaats die een waarde opslaat die kan veranderen. Een constante heeft een naam maar behoudt dezelfde waarde, zoals PASS_MARK ← 50.

De rechterkant van een toekenning wordt eerst berekend. Het resultaat vervangt de oude waarde aan de linkerkant. Als count de waarde 4 bevat, leest count ← count + 1 de oude 4, telt er 1 bij op en slaat 5 op. Het is een instructie om opgeslagen gegevens te veranderen, geen vergelijking die stelt dat een getal gelijk is aan zichzelf plus één.

Koppel gegevens aan bewerkingen

De getallen 12 en 3 optellen geeft 15. De tekenreeksen “12” en “3” samenvoegen geeft “123”. Kies beschrijvende namen zoals temperature en total, zodat de rol van een waarde zichtbaar blijft.

Rekenkundige operatoren zijn onder meer +, −, * en /. DIV geeft het gehele quotiënt en MOD geeft de rest. Zo is 17 DIV 5 gelijk aan 3 en 17 MOD 5 gelijk aan 2. De test n MOD 2 = 0 herkent een even geheel getal. Vergelijkingen zoals =, ≠, <, >, ≤ en ≥ leveren booleaanse waarden op.

Lees, bereken en toon

INPUT minutes
hours ← minutes DIV 60
rest ← minutes MOD 60
OUTPUT hours, "h", rest, "min"

Bij 135 minuten gebruiken twee volledige groepen van 60 samen 120 minuten, waardoor 15 overblijft. De uitvoer is “2 h 15 min”. INPUT ontvangt gegevens, de twee toekenningen verwerken ze en OUTPUT stuurt het resultaat.

Bewaar een waarde voordat je die vervangt

Stel dat a de waarde 5 bevat en b de waarde 8. Na de instructies a ← b en vervolgens b ← a bevatten beide variabelen 8. De eerste instructie heeft de enige opgeslagen kopie van 5 overschreven.

Gebruik een tijdelijke variabele:

temp ← a
a ← b
b ← temp

Na de eerste regel bevat temp de waarde 5. De tweede regel plaatst 8 in a. De derde plaatst de bewaarde 5 in b. Een toekenning kopieert een huidige waarde; die maakt geen blijvende verbinding tussen variabelen.

Geef elke variabele een beginwaarde voordat je die uitleest. Een lopend totaal heeft total ← 0 nodig vóór de eerste optelling. Als je de toekenning na de optelling plaatst, heeft de eerste stap geen vastgelegde beginwaarde.

Selectie kiest welke instructies worden uitgevoerd. Een voorwaarde is een expressie met de waarde TRUE of FALSE. De vergelijking score ≥ 50 vraagt of de huidige score minstens 50 is.

Gebruik IF en ELSE

IF score ≥ 50 THEN
    OUTPUT "Pass"
ELSE
    OUTPUT "Fail"
END IF

Precies één tak wordt uitgevoerd. Bij 50 is de voorwaarde TRUE en is de uitvoer “Pass”. Bij 49 is de voorwaarde FALSE en is de uitvoer “Fail”. Een IF zonder ELSE slaat het blok over wanneer de voorwaarde FALSE is.

De vergelijking moet bij de regel passen. “Minstens 50” omvat 50, dus is ≥ nodig. Met > zou die grensscore worden afgewezen. Waarden op de grens testen is een directe manier om deze fout te vinden.

Orden verschillende gevallen

Een ELSE IF-keten controleert voorwaarden in volgorde en voert de eerste bijpassende tak uit:

IF temperature ≥ 30 THEN
    OUTPUT "Hot"
ELSE IF temperature ≥ 20 THEN
    OUTPUT "Warm"
ELSE IF temperature ≥ 10 THEN
    OUTPUT "Mild"
ELSE
    OUTPUT "Cold"
END IF

Bij 24 °C is de eerste test onwaar en de tweede waar. De uitvoer is “Warm”. Bij 10 °C wordt de derde tak uitgevoerd. Bij −3 °C wordt de laatste ELSE uitgevoerd.

Een temperatuur van 35 °C voldoet aan alle drie de opgeschreven vergelijkingen, maar alleen de eerste bijpassende tak wordt uitgevoerd. Als temperature ≥ 10 als eerste kwam, zou die 35 opvangen en “Mild” uitvoeren. Test bij overlappende grenzen met “minstens” eerst de grootste. De lagere takken handelen dan de waarden af die niet aan de hogere grenzen voldeden.

Combineer voorwaarden

Gebruik temperature ≥ 10 AND temperature < 20 om temperaturen vanaf 10 °C tot maar niet met 20 °C op te nemen. Aan beide grenzen moet worden voldaan. Bij 15 zijn beide voorwaarden TRUE. Bij 20 is de tweede FALSE.

Als je voor dit interval OR gebruikt, krijg je temperature ≥ 10 OR temperature < 20. Dat accepteert elk getal: een waarde onder 10 voldoet nog steeds aan het tweede deel, terwijl elke waarde van minstens 10 aan het eerste voldoet. OR is nuttig wanneer elk van beide mogelijkheden voldoende is, niet wanneer aan twee grenzen tegelijk moet worden voldaan.

Plaats een beslissing binnen een andere beslissing

Een geneste IF plaatst een beslissing binnen een tak van een andere beslissing. Je kunt bijvoorbeeld eerst controleren of een wachtwoord lang genoeg is en dan binnen de succesvolle tak controleren of het een cijfer bevat. De binnenste beslissing wordt alleen bereikt wanneer de buitenste voorwaarde dat toestaat.

Laat het binnenste blok inspringen zodat de paden zichtbaar zijn. Als verschillende geneste beslissingen een eenvoudige regel moeilijk leesbaar maken, overweeg dan voorwaarden met AND te combineren of een ELSE IF-keten te gebruiken. Volg een waarde door de werkelijke volgorde voordat je aanneemt dat elke opgeschreven test wordt bereikt.

Iteratie herhaalt een blok instructies. Met een lus kun je terugkerend werk eenmaal beschrijven, maar je moet nog steeds bepalen wanneer de lus begint, wanneer die eindigt en welke waarden bij elke doorgang veranderen.

Kies hoe de herhaling wordt bestuurd

Een FOR-lus past bij een bekend aantal herhalingen. Een voorwaardegestuurde lus past bij een taak waarvan het stoppunt afhangt van waarden of nieuwe invoer. Het lusblok van een WHILE-lus kan nul keer worden uitgevoerd. Het lusblok van een REPEAT … UNTIL-lus met eindvoorwaarde wordt minstens één keer uitgevoerd.

Doorloop een aftelling

n ← 3
WHILE n > 0 DO
    OUTPUT n
    n ← n − 1
END WHILE
OUTPUT "Go!"

Bij de eerste test is n gelijk aan 3. De lus geeft 3 als uitvoer en verandert n in 2. De volgende doorgangen geven 2 en 1 als uitvoer. Na de verandering van 1 naar 0 is de test FALSE. De uitvoering verlaat de lus en geeft “Go!” als uitvoer.

Als je de aanpassing weglaat, blijft n gelijk aan 3, zodat de lus de stoptoestand nooit bereikt. Een lus die moet eindigen, heeft een manier nodig om de voorwaarde te veranderen: een aanpassing binnen de lus of nieuwe invoer kan daarvoor zorgen.

Bouw een totaal op en tel elementen

Een accumulator bouwt een resultaat op over verschillende doorgangen. Een teller houdt bij hoe vaak iets gebeurt. Zo bepaal je het gemiddelde van de dagtemperaturen 18, 21, 19, 22 en 20 °C:

total ← 0
count ← 0
FOR EACH t IN temperatures
    total ← total + t
    count ← count + 1
END FOR
OUTPUT total / count

De opeenvolgende totalen zijn 18, 39, 58, 80 en 100. De teller eindigt op 5, dus is het gemiddelde 20 °C. Initialiseer beide variabelen vóór de lus. Als je total binnen de lus terugzet, wis je de eerdere optellingen. Een lege lijst vereist vóór de deling een afzonderlijke controle, omdat het aantal nul is.

Onthoud de beste waarde tot dan toe

Laat largest bij een niet-lege lijst beginnen met het eerste element. Bekijk vervolgens elke waarde en vervang largest wanneer een grotere waarde verschijnt:

largest ← first item of list
FOR EACH value IN list
    IF value > largest THEN
        largest ← value
    END IF
END FOR
OUTPUT largest

Voor [7, 3, 12, 5] blijft de onthouden beste waarde 7, wordt die 12 en blijft die 12. Beginnen bij nul gaat mis voor een lijst zoals [−4, −9, −2], waarvan de grootste waarde −2 is. Nul was nooit een kandidaat.

Controleer de eerste en laatste doorgang

Een fout van één te veel of te weinig voegt één herhaling toe of laat er één weg. FOR i ← 0 TO 5 wordt zes keer uitgevoerd. In de aftelling zou n ≥ 0 ook nul als uitvoer geven. Schrijf de eerste en laatste waarde van de besturingsvariabele op om het aantal te controleren.

Geneste lussen herhalen een lus binnen een andere lus. Bij 3 rijen en 4 kolommen wordt het binnenste blok voor elke rij vier keer uitgevoerd, in totaal 12 uitvoeringen. De binnenste lus begint opnieuw bij elke buitenste doorgang.

Een stroomdiagram tekent een algoritme als vormen die door pijlen zijn verbonden. De vormen geven soorten stappen aan en de pijlen laten zien welke stap daarna wordt uitgevoerd. Een kort diagram maakt een proces zichtbaar voor iemand die misschien geen code leest.

Kies voor elke taak een vorm

De belangrijkste symbolen volgen ISO 5807. Ze hebben elk een eigen taak:

Een stroomlijn heeft een pijl die de richting aangeeft. De gebruikelijke leesrichting is van boven naar beneden en van links naar rechts, maar de pijl bepaalt de werkelijke volgende stap. Een lijn die teruggaat naar een eerder punt kan herhaling aangeven.

Maak een eenvoudige sequentie

Gebruik deze vijf symbolen in volgorde om de oppervlakte van een rechthoekige kamer te berekenen:

1. Start-stopsymbool: “Start”.
2. Invoer-uitvoersymbool: “Voer lengte en breedte in”.
3. Processymbool: area ← length * width.
4. Invoer-uitvoersymbool: “Toon oppervlakte”.
5. Start-stopsymbool: “Einde”.

Verbind elke stap met de volgende met een pijl. Bij een lengte van 4,5 m en een breedte van 3 m geeft de berekening 13,5 vierkante meter. Het lezen van de invoer berekent de oppervlakte niet; dat hoort in een eigen procesrechthoek. Het tonen van de oppervlakte hoort in het uitvoerparallellogram.

Dit diagram heeft geen keuze of herhaald pad. Het is een zuivere sequentie en de vorm maakt de volgorde duidelijk.

Volg een beslissing met de huidige waarden

Een ruit stelt een vraag of test een waarde. Geef bij een ja-neevraag zoals score ≥ 50? de uitgangen de labels “Ja” en “Nee”. Bepaal de uitkomst van de voorwaarde met de huidige score en volg precies één bijpassende pijl.

Een beslissing kan meer dan twee mogelijke uitgangen hebben wanneer die verschillende afzonderlijke waarden test. Geef elke uitgang de waarde of het geval dat die vertegenwoordigt als label. De labels maken de volgende stap ondubbelzinnig.

Een handeling zoals count ← count + 1 hoort in een procesrechthoek. Een vraag zoals count < 5? hoort in een beslissingsruit. Als je deze taken door elkaar haalt, is niet meer duidelijk of een waarde wordt veranderd of getest.

Controleer de verbindingen

Een duidelijk diagram heeft één Start en minstens één Einde. Elk proces- en invoer-uitvoersymbool heeft één uitgaande stroomlijn. Elke ja-neebeslissing heeft twee uitgangen met een label. Volg elk pad om te controleren of het een bedoelde volgende stap of Einde bereikt.

Laat een tak na de uitvoer niet los eindigen. Als beide takken met dezelfde stap moeten doorgaan, laat je ze vóór die stap samenkomen. Gebruik verbindingssymbolen met labels wanneer lange of kruisende lijnen de pagina moeilijk te volgen maken. Met een symbool voor een voorgedefinieerd proces kan een grote procedure op een afzonderlijk diagram staan, terwijl het hoofddiagram zijn overzichtelijke vorm behoudt.

Pseudocode en stroomdiagrammen kunnen hetzelfde algoritme uitdrukken. Als je tussen beide omzet, moet je de volgorde van handelingen, de voorwaarden en elke route door het proces behouden. Een netjes diagram met een test op een andere plaats beschrijft een ander algoritme.

Toon een keuze en voeg de paden weer samen

Teken voor een slaaggrens van 50 een ruit met het label score ≥ 50?. De Ja-uitgang leidt naar een uitvoerparallellogram met het label “Pass”. De Nee-uitgang leidt naar een parallellogram met het label “Fail”. Laat de paden vóór Einde samenkomen.

In pseudocode worden deze paden de takken IF en ELSE. Het punt waar ze weer samenkomen, komt overeen met de eerste instructie na END IF. Het diagram mag de uitvoer Pass niet verder leiden door de uitvoer Fail; bij één uitvoering hoort slechts één van beide op het pad.

Zet de test op de juiste plaats

Een lus heeft een pad terug naar een eerdere stap en een beslissing die bepaalt of de herhaling doorgaat. Plaats bij een WHILE-lus de beslissing vóór het lusblok. De FALSE-uitgang slaat het lusblok over, zodat nul doorgangen mogelijk zijn.

Plaats bij een REPEAT … UNTIL-lus met eindvoorwaarde de beslissing na het lusblok. De FALSE-uitgang keert terug naar het lusblok en de TRUE-uitgang verlaat de lus. Het lusblok wordt minstens één keer uitgevoerd omdat de uitvoering het bereikt vóór de eerste test.

Werk een aanmelding met drie pogingen uit

attempts ← 0
REPEAT
    INPUT password
    attempts ← attempts + 1
UNTIL password = storedPassword OR attempts = 3
IF password = storedPassword THEN
    OUTPUT "Welcome"
ELSE
    OUTPUT "Account locked"
END IF

Begin het diagram met Start en een procesrechthoek voor attempts ← 0. Teken vervolgens het parallellogram voor wachtwoordinvoer en daarna de rechthoek voor de verhoging. De lusruit vraagt “Wachtwoord correct OF attempts = 3?”. De Nee-uitgang keert terug naar de wachtwoordinvoer. De Ja-uitgang verlaat de lus.

De stopvoorwaarde geeft twee mogelijke redenen om te stoppen en kan dus op zichzelf niet het laatste bericht kiezen. Voeg een tweede ruit toe die vraagt of het wachtwoord correct is. Ja leidt naar “Welcome”; Nee leidt naar “Account locked”. Bij een correcte derde poging stopt de lus en verwelkomt de tak voor een correct wachtwoord de gebruiker nog steeds.

Zet om door paden te volgen

Als je pseudocode omzet in een diagram, maak je van elke toekenning een rechthoek en van elke invoer of uitvoer een parallellogram. Maak van tests voor takken en lussen ruiten. Verbind het lusblok terug met de besturende beslissing op de juiste plaats.

Als je een diagram omzet in pseudocode, onderzoek je waar de paden van elke ruit naartoe leiden. Paden die alternatieven uitvoeren en weer samenkomen, wijzen op selectie. Een pad dat terugkeert naar eerder werk wijst op iteratie. Laat elk blok inspringen overeenkomstig zijn grenzen.

Controleer de bestemming van elke teruggaande pijl. Als die terugkeert ná de besturende beslissing, wordt de volgende test overgeslagen. Als die terugkeert vóór een eenmalige initialisatie, kan bij elke doorgang een teller worden teruggezet en kan de lus mogelijk niet eindigen.

Een algoritme kan er redelijk uitzien en toch het verkeerde doen. Bij doorlopen volg je de instructies precies en leg je vast wat er gebeurt. Bij testen voer je het uit met gekozen invoer en controleer je de resultaten. Bij debuggen zoek en herstel je de oorzaak van een fout.

Maak de toestand zichtbaar

Een tracetabel legt variabelen en uitvoer vast tijdens een handmatige uitvoering. Gebruik de huidige waarden, niet de waarden waarvan je verwacht dat de maker ze bedoelde. Bijvoorbeeld:

total ← 0
FOR i ← 1 TO 4
    total ← total + i
END FOR
OUTPUT total

Deze compacte tabel toont de toestand na elke optelling. Voeg bij een lastige fout rijen toe na afzonderlijke instructies en een kolom voor de resultaten van voorwaarden. Ook een lustest met FALSE hoort in een gedetailleerde uitvoeringstabel: die verklaart waarom de uitvoering de lus verlaat.

Kies tests op basis van de regels

Bepaal het verwachte resultaat voordat je elke test uitvoert. Anders accepteer je de uitvoer van het programma gemakkelijk alleen omdat die verscheen. Sommige tests controleren een eigenschap, zoals het op volgorde houden van uitvoer, in plaats van één exact resultaat.

Voor scores die geldig zijn van 0 tot en met 100, met een slaaggrens van 50:

De categorieën grenswaarde en ongeldig kunnen overlappen: −1 ligt zowel dicht bij een grens als buiten het geldige bereik. De categorie verklaart waarom de test nuttig is. Een regel met score > 50 slaagt voor normale tests met 73 en 49, maar faalt bij precies 50.

Test ook ongebruikelijke invoerstructuren. Een lege lijst, één element, allemaal gelijke waarden en negatieve waarden maken verschillende aannames zichtbaar. Een algoritme voor het gemiddelde moet een lege lijst afhandelen voordat het door het aantal deelt. Een algoritme voor de grootste waarde dat op nul is geïnitialiseerd, kan falen bij een lijst met alleen negatieve waarden.

Bepaal welke fout je herstelt

Een syntaxisfout overtreedt de schrijfregels van een taal, zoals een ontbrekend sluitend haakje. Een uitvoeringsfout ontstaat tijdens de uitvoering, zoals een deling door nul. Een logische fout laat uitvoering toe maar geeft een verkeerd resultaat, zoals het uitsluiten van de slaaggrens met >.

Deze categorieën helpen je een controle te kiezen. Syntaxiscontrole vindt ongeldige taalvormen. Een handmatige uitvoering kan de eerste verkeerde toestand bij een logische fout zichtbaar maken. Testgegevens kunnen een uitvoeringsfout uitlokken die bij typische invoer nooit optreedt.

Debug vanaf de eerste afwijking

Reproduceer de fout met specifieke invoer. Volg of toon tussenwaarden en vind de eerste stap waar de werkelijke toestand afwijkt van de verwachte toestand. Verander de oorzaak en voer daarna de mislukte test en de eerdere tests opnieuw uit. Een reparatie aan de ene tak kan een andere tak kapotmaken.

Slagen voor geselecteerde tests levert bewijs over die invoer. Voor correctheid moet de methode nog steeds elke geldige invoer afhandelen. Combineer testen daarom met redeneren over de instructies en hun aannames.

Bij programmeren met blokken staan grafische blokken voor instructies en waarden. Je sleept ze naar een werkruimte en klikt ze aan elkaar. Dankzij de vormen hoef je veel syntaxis niet te onthouden en kun je je richten op de logica van het programma.

Ken de onderdelen van een project

Scratch is gemaakt bij het MIT Media Lab. Andere blokomgevingen zijn Snap!, ontwikkeld aan de University of California, Berkeley, Microsoft MakeCode en Blockly. Blockly is een bibliotheek voor het bouwen van blokinterfaces; die ontstond bij Google en ging in 2025 over naar de Raspberry Pi Foundation.

In Scratch is het speelveld het gebied waar het project zichtbaar wordt uitgevoerd. Sprites zijn personages of objecten die erop handelen. Een sprite kan scripts, uiterlijken en geluiden hebben. Een script is een stapel blokken; een uiterlijk is een afbeelding die de sprite kan tonen.

Het speelveld is 480 bij 360 Scratch-eenheden. Het middelpunt is het coördinatenpunt (0, 0). Horizontale x-coördinaten lopen van −240 tot 240 en verticale y-coördinaten van −180 tot 180. Bewegingsstappen in Scratch zijn eenheden op het speelveld, geen meters.

Laat je leiden door de blokvorm

Een waardeblok past in een invoerveld van een ander blok. Een opdracht past in een stapel handelingen. Een booleaans blok past in een voorwaardeveld. De vorm helpt onderscheid te maken tussen een waarde leveren en een opdracht uitvoeren.

Zoek blokken per categorie

Scratch 3 heeft negen hoofdcategorieën met elk een eigen kleur: Beweging, Uiterlijken, Geluid, Gebeurtenissen, Besturen, Waarnemen, Functies, Variabelen en Mijn blokken. Beweging verandert de positie; Uiterlijken verzorgt het zichtbare uiterlijk en tekstballonnen; Waarnemen ontvangt informatie; Functies berekent of vergelijkt. De uitbreiding Pen voeg je afzonderlijk toe wanneer een project lijnen moet tekenen terwijl een sprite beweegt.

Voer een korte sequentie uit

Selecteer een sprite en plaats deze blokken onder een startblok “wanneer op groene vlag wordt geklikt”:

1. “ga naar x: 0 y: 0”
2. “zeg Hallo! 2 sec.”
3. “neem 100 stappen”

Klik op de groene vlag. De sprite gaat eerst naar het midden, toont dan twee seconden “Hallo!” en beweegt vervolgens 100 stappen in de huidige richting. Het zegblok met tijdsduur maakt de pauze zichtbaar. De stapel wordt van boven naar beneden uitgevoerd.

Een losse stapel kan worden uitgevoerd als je er rechtstreeks op klikt in de werkruimte, maar start niet door de groene vlag zonder het bijpassende gebeurtenisstartblok. Controleer zowel de volgorde van de stapel als de startgebeurtenis als het project niet lijkt te reageren.

Ook correct passende blokken hebben een correct plan nodig. Een beweging kan plaatsvinden vóór een bedoelde terugzetting van de positie, of een vraag kan worden gesteld nadat het resultaat is getoond. Vormen helpen bij een geldige opbouw; doorlopen laat zien of die opbouw het bedoelde werk doet.

Scratch gebruikt dezelfde ideeën als pseudocode: een waarde opslaan, een voorwaarde testen en stappen herhalen. De blokken maken de structuur zichtbaar, maar hun plaats bepaalt nog steeds wanneer elke handeling plaatsvindt.

Kies een lus die bij de taak past

“Herhaal 10 keer” voert het lusblok tien keer uit. “Herhaal” blijft doorgaan totdat het programma stopt en past bij een spel dat voortdurend invoer controleert. “Herhaal tot ” test vóór elke doorgang en stopt wanneer de voorwaarde waar is. Het lusblok kan daardoor nul keer worden uitgevoerd, anders dan bij REPEAT … UNTIL met eindvoorwaarde in pseudocode.

Met de uitbreiding Pen en de pen op het speelveld tekent “herhaal 4 keer” met daarin “neem 100 stappen” en “draai 90 graden naar rechts” een vierkant. Gebruik voor een regelmatige zeshoek zes herhalingen en een draai van 60 graden. De richtingsveranderingen tellen rond de vorm op tot 360 graden.

Sla een waarde op en kies een tak

Maak score aan in Variabelen. “Maak score 0” kent de beginwaarde toe. “Verander score met 1” telt op bij de huidige waarde. Zet het terugzetten vóór een lus die de score bijhoudt; binnen de lus zou het terugzetten de eerdere score elke keer wissen.

Het afgeronde waardeblok score levert de huidige waarde aan andere blokken. Als je het vakje aanvinkt, verschijnt een venster op het speelveld dat helpt bij het doorlopen.

Een blok “als … dan … anders” voert één van zijn twee blokdelen uit. In het zeshoekige voorwaardeveld past een booleaans blok zoals “(score) > (9)” of “raak ik muisaanwijzer?”. De operatoren “en”, “of” en “niet” combineren voorwaarden met dezelfde betekenis als in pseudocode.

Ontvang invoer, maak tekst en toon die

Het blok “vraag [Wat is je naam?] en wacht” pauzeert voor invoer en slaat die op in “antwoord”. Het blok “voeg [Hallo, ] en (antwoord) samen” maakt tekst. Plaats dat waardeblok binnen “zeg … 2 sec.” om de begroeting te tonen. Als de invoer “Amara” is, is de uitvoer “Hallo, Amara”.

De drie rollen zijn afzonderlijk: vraag ontvangt gegevens, samenvoegen verwerkt tekst en zeg toont die. Een waardeblok kan een nuttige waarde berekenen zonder zelf iets te tonen.

Maak een raadspel

Gebruik deze blokvolgorde, waarbij elk ingesprongen deel binnen het omsluitende blok staat:

"when green flag clicked"
"set secret to (pick random 1 to 10)"
"ask [Guess a number from 1 to 10] and wait"
"repeat until <(answer) = (secret)>"
    "if <(answer) > (secret)> then"
        "say [Too high] for 2 seconds"
    "else"
        "say [Too low] for 2 seconds"
    "ask [Guess a number from 1 to 10] and wait"
"say [Correct!] for 2 seconds"

Een correcte eerste gok slaat de lus over. Bij geheim getal 6 en de gokken 3, 8 en 6 is de terugkoppeling “Too low”, “Too high” en daarna “Correct!”. De nieuwe vraag binnen de lus levert een waarde die de voorwaarde waar kan maken.

Terugkoppeling met een tijdsduur is belangrijk. De vraag van een zichtbare sprite gebruikt zijn tekstballon, zodat de volgende vraag een tekstballon van zeg zonder tijdsduur direct vervangt. Met een zegblok van twee seconden kan de lerende de terugkoppeling eerst lezen.

Lees de lus als WHILE answer ≠ secret om die in pseudocode te controleren. Als je de herhaalde vraag weglaat, blijft het spel vastzitten met het oude verkeerde antwoord; als je het laatste succesbericht binnen de lus plaatst, staat het op het verkeerde pad.

Een Scratch-project heeft vaak verschillende scripts die op verschillende gebeurtenissen wachten. Gebeurtenisgestuurd programmeren start een script wanneer een gebeurtenis plaatsvindt. Met een eigen blok kan een script vervolgens benoemd herbruikbaar werk aanroepen.

Start het juiste script

Startblokken zijn onder meer “wanneer op groene vlag wordt geklikt”, “wanneer op deze sprite wordt geklikt”, “wanneer spatiebalk wordt ingedrukt” en “wanneer ik signaal [bericht] ontvang”. Elk blok beschrijft wat de aangekoppelde stapel start.

Verschillende scripts kunnen op dezelfde gebeurtenis reageren. Twee sprites kunnen allebei starten wanneer op de groene vlag wordt geklikt en vervolgens naast elkaar draaien. De plaats van hun stapels in de werkruimte bepaalt geen uitvoeringsvolgorde tussen de scripts.

Binnen één script blijven handelingen van boven naar beneden geordend. Tussen scripts kan timing belangrijk zijn. Als twee scripts dezelfde sprite in tegengestelde richtingen bewegen, hangt hun gezamenlijke resultaat af van wanneer de handelingen worden uitgevoerd. Geef scripts duidelijke verantwoordelijkheden en coördineer het werk wanneer de ene taak het resultaat van een andere nodig heeft.

Stuur een bericht tussen scripts

“Zend signaal [spel voorbij]” stuurt een bericht naar alle sprites en het speelveld. Bijpassende scripts met “wanneer ik signaal [spel voorbij] ontvang” starten als reactie. De berichtnaam moet overeenkomen; die bepaalt welke gebeurtenis de ontvangers afhandelen.

“Zend signaal en wacht” laat de verzender bovendien pauzeren totdat de ontvangende scripts klaar zijn. Gebruik dit wanneer de volgende handeling afhangt van hun voltooiing. Een besturend script kan bijvoorbeeld een voorbereidingsbericht verzenden en wachten terwijl sprites naar startposities bewegen, en daarna het spel beginnen.

Wachten bepaalt geen volgorde tussen de ontvangers onderling. Als twee ontvangers voor de voorbereiding allebei dezelfde waarde overschrijven, hebben ze nog steeds een plan nodig dat tegenstrijdige verantwoordelijkheden voorkomt. Een ontvanger die eindeloos draait, voorkomt ook dat de wachtende verzender doorgaat.

Geef terugkerend werk een naam en invoer

Maak in Mijn blokken een eigen blok met een invoer genaamd size. De definitie kun je zo beschrijven:

"define square (size)"
    "repeat 4"
        "move (size) steps"
        "turn right 90 degrees"

Met de pen op het speelveld tekent de aanroep “vierkant (100)” zijden van 100 stappen. De aanroep “vierkant (60)” gebruikt dezelfde instructies met kortere zijden. Het eigen blok biedt abstractie door de stappen achter een naam te verbergen en generalisatie doordat de aanroeper de grootte kan opgeven.

De aanroep voert de definitie uit; die kopieert geen tweede, handmatig onderhouden versie naar het script. Als je de definitie verandert, verandert het werk dat latere aanroepen uitvoeren. Daardoor is een terugkerende methode gemakkelijker te onderhouden.

Neem de ideeën mee naar tekst

In een tekstuele taal typ je de instructies en volg je de regels van de taal voor leestekens en spaties. De onderliggende redenering over toestand, voorwaarden en herhaling blijft van toepassing.

Blokken nemen veel syntaxisfouten weg, maar een verkeerde voorwaarde kan nog steeds het verkeerde pad kiezen. Handmatige uitvoeringen en tests blijven nuttig. Grote blokprojecten kunnen ook moeilijk te doorzoeken en te vergelijken worden omdat hun scripts veel schermruimte innemen; tekst is gemakkelijker te doorzoeken en te beheren voor grote softwareprojecten.