Samenvattingen · InformaticaNL · HAVO

Domein D: Programmeren

Programmeren is het hart van de informatica: je vertaalt een plan (een algoritme) in code die de computer stap voor stap uitvoert. In dit domein leer je van de grond af werken met variabelen en datatypes, met de drie controlestructuren sequentie, selectie en iteratie, met functies en objecten, en met de belangrijkste programmeerparadigma's. Het domein sluit af met testen en debuggen: systematisch controleren of je programma klopt en fouten gericht opsporen.

5 Onderdelen~27 min leestijd4 VaardighedenNiveau Basis 2 · Standaard 2 · Verdieping 1

T·0444 / 12

Examenprofiel

De kandidaat kan een probleem analyseren en vertalen naar een algoritme en een werkend programma.De kandidaat kan variabelen, datatypes, expressies en de controlestructuren (sequentie, selectie, iteratie) correct toepassen.De kandidaat kan een programma opdelen in functies en objecten en verschillende programmeerparadigma's herkennen.De kandidaat kan een programma systematisch testen, fouten opsporen en het resultaat documenteren.

Operatoren:schrijfleg uitbepaalberedeneerontwerptestvergelijkpas toe

basisniveau

Zorg dat je variabelen, de drie controlestructuren en een eenvoudige functie foutloos kunt lezen en naspelen (tracen).

verhoogd niveau

Oefen met geneste structuren, objectoriëntatie en het opstellen van volledige testsets met randgevallen en foutieve invoer.

Diepte

Tekst

Inhoud · 5 onderdelen

Domein D: Programmeren

Variabelen, datatypes en expressies#

Basisexamenblad-nl

Veelgebruikte datatypes

Afb. 1Vijf basisdatatypes met een voorbeeldwaarde en typisch gebruik. Het type bepaalt welke bewerkingen op een waarde zijn toegestaan.

Programmeren betekent dat je een computer stap voor stap opdrachten geeft in een taal die hij begrijpt, bijvoorbeeld Python. De bouwsteen waarmee alles begint, is de variabele: een plek in het geheugen met een naam waarin je een waarde bewaart. Met een toewijzing zet je een waarde in die plek, bijvoorbeeld leeftijd = 16. Let op: de = is hier géén gelijkteken uit de wiskunde, maar een opdracht 'stop de waarde rechts in de variabele links'. Je leest zo'n regel dus eigenlijk van rechts naar links. Een variabele kun je later opnieuw een waarde geven, zoals score = score + 10, en juist die veranderlijkheid maakt een programma krachtig: dezelfde code werkt telkens met andere waarden.

Elke waarde heeft een datatype dat bepaalt wat je ermee mag doen. De belangrijkste typen zijn het gehele getal (int) zoals 16 of -3; het kommagetal (float) zoals 3,14 met een gebroken deel; de tekst of string zoals „Amsterdam”, die je altijd tussen aanhalingstekens schrijft; en de booleaanse waarde (boolean), die alleen waar of onwaar kan zijn. Een lijst (array) bewaart bovendien meerdere waarden in één variabele, bijvoorbeeld cijfers = [7, 8, 6]; met een index spreek je een los element aan, waarbij cijfers[0] het eerste element (de 7) is. Het type doet ertoe omdat de computer met een int rékent, maar twee strings alleen achter elkaar plakt: de tekst „3” is dus iets heel anders dan het getal 3.

Met operatoren combineer je waarden tot nieuwe waarden. De rekenkundige operatoren zijn optellen (+), aftrekken (-), vermenigvuldigen (× , in code de ster), delen (/) en de restdeling of modulo (mod), die de rest na deling geeft: 17 mod 5 is 2. De vergelijkingsoperatoren (==, !=, <, >, <=, >=) leveren altijd een boolean op: 7 > 5 is waar. Let goed op het dubbele isgelijkteken == waarmee je vergelijkt, tegenover de enkele = waarmee je toewijst — dat verschil kost veel beginners punten. De logische operatoren en, of en niet combineren booleans: (leeftijd >= 12 en leeftijd < 18) is alleen waar als beide deelvoorwaarden waar zijn. Deze operatoren vormen de taal waarin je voorwaarden en berekeningen formuleert.

Een expressie is een combinatie van waarden, variabelen en operatoren die de computer uitrekent tot één nieuwe waarde; dat uitrekenen heet evalueren. Bij het evalueren geldt een vaste volgorde van bewerkingen, net als in de wiskunde: eerst wat tussen haakjes staat, dan vermenigvuldigen en delen, dan optellen en aftrekken, daarna de vergelijkingen, en als laatste de logische operatoren (eerst niet, dan en, dan of). De computer vervangt elke variabele eerst door haar actuele waarde en werkt daarna van binnen naar buiten. Zo evalueert 2 + 3 × 4 tot 14 en niet tot 20, omdat vermenigvuldigen vóór optellen gaat. Wie de volgorde kent, kan elke expressie stap voor stap naspelen en voorspellen wat eruit komt.

Het resultaat van een expressie heeft zelf ook weer een type, en dat is niet altijd hetzelfde als de invoer. Delen levert in veel talen een float op: 10 / 2 is 5.0 en niet 5. Een vergelijking of een logische expressie levert altijd een boolean op. Problemen ontstaan wanneer je typen mengt die niet samengaan: de tekst „3” plus het getal 5 geeft een typefout, want tekst en getal kun je niet zomaar bij elkaar optellen. Zulke fouten los je op met typeconversie: met int("3") maak je van de tekst het getal 3, en met str(3) maak je van een getal weer tekst. Wie steeds in de gaten houdt welk type een variabele bevat, voorkomt de meeste beginnersfouten — het is de basis voor de keuzes, herhalingen en functies die hierna komen.

Uitgewerkt voorbeeld

Een gemengde expressie evalueren

Bepaal stap voor stap de waarde en het datatype van: 2 + 3 × 4 > 10 en niet (10 / 2 == 4).

Haakjes eerst
Binnen de haakjes staat 10 / 2 == 4. Delen gaat vóór vergelijken: 10 / 2 = 5.0 (een float). Daarna 5.0 == 4, en dat is onwaar.
Vermenigvuldigen
Buiten de haakjes eerst het product: 3 × 4 = 12. De expressie wordt nu 2 + 12 > 10 en niet (onwaar).
Optellen
2 + 12 = 14. Er staat nu 14 > 10 en niet (onwaar).
Vergelijken
14 > 10 is waar. De expressie wordt: waar en niet (onwaar).
Logische operatoren
Eerst niet: niet onwaar = waar. Dan en: waar en waar = waar.
Resultaat en type
De uitkomst is waar. Omdat de buitenste bewerking een logische operator is, is het datatype een boolean.

Resultaat: De expressie evalueert tot waar; het datatype van het resultaat is boolean.

Veelgemaakte fouten

De toewijzing = verwarren met het vergelijkingsteken == in een voorwaarde.
Denken dat 10 / 2 een int oplevert; in veel talen is het resultaat van delen een float (5.0).
De volgorde van bewerkingen negeren, waardoor 2 + 3 × 4 ten onrechte 20 wordt in plaats van 14.

Actieve herhaling

Gegeven a = 5 en b = 2. Bepaal de waarde én het datatype van de expressie a / b > 2 en niet (a mod b == 0). Schrijf elke tussenstap op.

Actief ophalen

Haal de kernpunten op — onthul ze daarna.

Bronnen: Examenprogramma informatica (HAVO) (CvTE / Examenblad)

Controlestructuren: sequentie, selectie en iteratie#

Basisexamenblad-nl

Herhaling met een for-lus

Afb. 2Een for-lus als stroomdiagram: de terugpijl van 'i = i + 1' naar de voorwaarde is de herhaling; bij 'onwaar' verlaat de uitvoering de lus.

Een programma dat alleen regels van boven naar beneden uitvoert, kan maar weinig. Echt krachtig wordt code door drie basisstructuren, en met alleen deze drie kun je élk algoritme bouwen. De eerste is de sequentie: opdrachten die simpelweg na elkaar worden uitgevoerd, in de volgorde waarin ze staan. De tweede is de selectie of keuze: afhankelijk van een voorwaarde wordt een stuk code wél of níét uitgevoerd. De derde is de iteratie of herhaling: een stuk code wordt meerdere keren herhaald. In de praktijk stapel en nest je deze structuren: een keuze binnen een herhaling, of een herhaling binnen een keuze. Wie deze drie beheerst, kan de logica van vrijwel elk programma lezen en zelf opschrijven.

Bij een selectie hoort een voorwaarde: een booleaanse expressie die waar of onwaar is. De basisvorm is de enkelvoudige keuze: als leeftijd >= 18 dan mag_stemmen = waar. Wil je ook een alternatief, dan gebruik je anders (else): is de voorwaarde onwaar, dan wordt het anders-blok uitgevoerd. Bij meer dan twee gevallen ketting je voorwaarden met anders-als (elif): de computer loopt de voorwaarden van boven naar beneden af en voert het eerste blok uit waarvan de voorwaarde waar is; de rest slaat hij over. Keuzes kun je ook nesten, een keuze binnen een keuze, bijvoorbeeld eerst controleren of iemand is ingelogd en daarbinnen of hij beheerder is. Belangrijk is dat de voorwaarden elkaar logisch uitsluiten of in de juiste volgorde staan, anders wordt het verkeerde blok gekozen.

Bij een iteratie herhaal je een blok code, de lus of loop. De while-lus (zolang-lus) herhaalt zolang een voorwaarde waar blijft, bijvoorbeeld: zolang saldo < doel, spaar door. Vóór elke ronde controleert de computer de voorwaarde; is die waar, dan draait het lusblok nog een keer, is die onwaar, dan stopt de lus. Cruciaal is dat er in de lus iets verandert dat de voorwaarde uiteindelijk onwaar maakt — meestal een teller of een som die je bij elke ronde ophoogt. Een teller is een variabele die je gebruikt om te tellen, bijvoorbeeld i die je met i = i + 1 telkens één verhoogt. Vergeet je die verandering, dan blijft de voorwaarde eeuwig waar en loopt het programma vast.

Wanneer je van tevoren weet hóé vaak je iets wilt herhalen, is de for-lus (voor-lus) handiger dan de while-lus. Een for-lus telt automatisch: voor i van 1 tot en met 5 doorloopt i achtereenvolgens de waarden 1, 2, 3, 4 en 5, en voert bij elke waarde het lusblok uit. Zo bereken je bijvoorbeeld een som: zet totaal op 0 en tel in de lus telkens i op bij totaal. De for-lus gebruik je ook om een lijst af te lopen: voor elk cijfer in cijfers verwerk je één element per ronde. Het verschil met de while-lus zit in de aansturing: de while-lus stopt op een voorwaarde die je zelf bewaakt, terwijl de for-lus een vast aantal keer telt of precies één keer per element loopt.

De gevaarlijkste fout bij herhaling is de oneindige lus: een lus die nooit stopt omdat de voorwaarde altijd waar blijft. Dat gebeurt als de teller niet wordt opgehoogd, als je de verkeerde kant op telt, of als de voorwaarde nooit bereikt kan worden. Controleer daarom altijd drie dingen: begint de teller goed (de initialisatie), verandert hij elke ronde de goede kant op, en kan de voorwaarde ooit onwaar worden. Een handig hulpmiddel om de werking te doorgronden is het stroomdiagram (flowchart), waarin een ruit een keuze voorstelt en een pijl terug naar boven de herhaling. Het stroomdiagram bij deze paragraaf laat zien hoe een for-lus van de startvoorwaarde naar het lusblok loopt, de teller ophoogt en via de terugpijl terugkeert naar de voorwaarde totdat die onwaar wordt.

Uitgewerkt voorbeeld

De uitvoer van een lus met keuze bepalen

Bepaal wat dit programma uitprint: som = 0 aantal = 0 voor i van 1 tot en met 6: als i > 3 dan: som = som + i aantal = aantal + 1 toon som, aantal

Startwaarden
Vóór de lus geldt som = 0 en aantal = 0. De lus laat i lopen van 1 tot en met 6.
i = 1, 2, 3
Voor i = 1, 2 en 3 is de voorwaarde i > 3 onwaar. Het als-blok wordt overgeslagen; som blijft 0 en aantal blijft 0.
i = 4
Nu is 4 > 3 waar: som = 0 + 4 = 4 en aantal = 0 + 1 = 1.
i = 5
5 > 3 is waar: som = 4 + 5 = 9 en aantal = 1 + 1 = 2.
i = 6
6 > 3 is waar: som = 9 + 6 = 15 en aantal = 2 + 1 = 3. Daarna is de lus klaar.
Uitvoer
Na de lus print het programma 15 en 3: de som en het aantal van de getallen groter dan 3 (namelijk 4 + 5 + 6).

Resultaat: Het programma print: 15 en 3.

Veelgemaakte fouten

De teller niet ophogen in een while-lus, waardoor een oneindige lus ontstaat.
Bij een for-lus de grenzen verkeerd tellen — één te veel of één te weinig (het 'off-by-one'-probleem).
elif-voorwaarden in de verkeerde volgorde zetten, zodat een specifieker geval nooit wordt bereikt.

Actieve herhaling

Schrijf in pseudocode een programma dat de getallen 1 tot en met 20 doorloopt en alleen de veelvouden van 3 optelt. Bepaal daarna met de hand welk totaal het programma uitprint.

Actief ophalen

Haal de kernpunten op — onthul ze daarna.

Bronnen: Examenprogramma informatica (HAVO) (CvTE / Examenblad)

Functies, procedures en parameters#

Standaardexamenblad-nl

Een functie aanroepen en terugkeren

Afb. 3De besturing springt van het hoofdprogramma naar de functie (met de argumenten) en keert met de returnwaarde weer terug naar de aanroep.

Naarmate een programma groeit, wil je niet steeds dezelfde regels opnieuw schrijven. Daarvoor bestaat de functie: een blok code met een naam dat je één keer definieert en daarna zo vaak aanroept als je wilt. Definiëren doe je bijvoorbeeld met functie oppervlakte(lengte, breedte): geef lengte × breedte terug. Aanroepen doe je met de naam en tussen haakjes de gegevens: oppervlakte(4, 3). Je kunt een functie als een 'black box' zien: je stopt er waarden in, er komt een resultaat uit, en om die te gebruiken hoef je niet te weten hoe het vanbinnen precies werkt. Een procedure is een variant die vooral iets dóét — bijvoorbeeld iets op het scherm zetten — zonder per se een waarde terug te geven.

De namen tussen de haakjes bij het definiëren heten parameters; het zijn lokale variabelen die de meegegeven waarden ontvangen. De concrete waarden die je bij het aanroepen meegeeft, heten argumenten. Bij oppervlakte(4, 3) zijn 4 en 3 de argumenten die aan de parameters lengte en breedte worden gekoppeld: lengte krijgt 4, breedte krijgt 3. De volgorde is daarbij belangrijk — het eerste argument gaat naar de eerste parameter. Een functie kan nul, één of meer parameters hebben. Door met parameters te werken maak je een functie algemeen: dezelfde functie oppervlakte rekent net zo goed met (4, 3) als met (12, 7), zonder dat je de code hoeft aan te passen.

De meeste functies leveren een resultaat op met het sleutelwoord 'geef terug' (in Python return). Zodra de computer die regel bereikt, stopt de functie onmiddellijk en stuurt de opgegeven waarde terug naar de plek van de aanroep; die aanroep gedraagt zich vanaf dan als die teruggegeven waarde. Zo kun je het resultaat opslaan, zoals opp = oppervlakte(4, 3) waarna opp de waarde 12 heeft, of het direct gebruiken met toon oppervlakte(4, 3). Let op het verschil tussen teruggeven en tonen: 'geef terug' levert een waarde af aan de rest van het programma, terwijl 'toon' alleen iets op het scherm zet. Een functie zonder 'geef terug' — een procedure — doet zijn werk via een neveneffect en levert geen bruikbare waarde op.

Variabelen die je binnen een functie maakt — inclusief de parameters — zijn lokale variabelen: ze bestaan alleen tijdens het uitvoeren van die functie en zijn daarbuiten onzichtbaar. Dit heet het bereik of de scope van een variabele. Een globale variabele daarentegen staat buiten alle functies en is in principe overal leesbaar. Het grote voordeel van lokale variabelen is dat functies elkaar niet in de weg zitten: twee functies mogen allebei een variabele resultaat gebruiken zonder dat de één de ander overschrijft, want het zijn verschillende, van elkaar afgeschermde plekken. Roep je een functie aan, dan krijgt hij zijn eigen verse lokale omgeving; is de functie klaar, dan verdwijnt die omgeving weer. Juist daardoor kun je een functie los van de rest begrijpen en testen.

Functies gebruik je om drie redenen. Ten eerste hergebruik: schrijf de logica één keer en roep haar overal aan, in plaats van dezelfde regels te kopiëren. Dat vat je samen in de vuistregel DRY — Don't Repeat Yourself, herhaal jezelf niet — want gekopieerde code moet je bij elke wijziging op tien plekken tegelijk aanpassen. Ten tweede abstractie: een goede functienaam als bereken_btw verbergt de details, zodat je programma leesbaar wordt als een reeks betekenisvolle stappen. Ten derde decompositie: je hakt een groot probleem in kleine, behapbare deelproblemen die je stuk voor stuk als functie oplost en daarna samenvoegt. Deze aanpak — verdeel en heers — is de kern van gestructureerd programmeren en maakt code makkelijker te lezen, te testen en te onderhouden.

Uitgewerkt voorbeeld

Een functie lezen en de returnwaarde bepalen

Gegeven de functie: functie bmi(gewicht, lengte): resultaat = gewicht / (lengte × lengte) geef resultaat terug Wat geeft de aanroep bmi(64, 1.6) terug, en welke variabelen zijn lokaal?

Argumenten koppelen
Bij de aanroep bmi(64, 1.6) krijgt de parameter gewicht de waarde 64 en de parameter lengte de waarde 1.6.
Noemer berekenen
Eerst het deel tussen haakjes: lengte × lengte = 1.6 × 1.6 = 2.56.
Deling uitvoeren
Dan resultaat = 64 / 2.56 = 25.0 (delen levert een float op).
Teruggeven
De regel 'geef resultaat terug' stopt de functie en levert 25.0 af aan de aanroep.
Scope benoemen
De variabelen gewicht, lengte en resultaat zijn lokaal: ze bestaan alleen binnen bmi en zijn na de aanroep weer verdwenen.

Resultaat: bmi(64, 1.6) geeft 25.0 terug; gewicht, lengte en resultaat zijn lokale variabelen.

Veelgemaakte fouten

Parameters en argumenten door elkaar halen, of de argumenten in de verkeerde volgorde meegeven.
'geef terug' (return) verwarren met 'toon' (print): tonen levert geen waarde af aan de rest van het programma.
Denken dat een lokale variabele buiten de functie nog bestaat of leesbaar is.

Actieve herhaling

Gegeven de functie: functie korting(prijs, procent): geef prijs - prijs × procent / 100 terug. Bepaal de returnwaarde van korting(80, 25) en leg uit welke variabelen lokaal zijn.

Actief ophalen

Haal de kernpunten op — onthul ze daarna.

Bronnen: Examenprogramma informatica (HAVO) (CvTE / Examenblad)

Objectoriëntatie en programmeerparadigma's#

Verdiepingexamenblad-nl

Klassenhiërarchie met overerving

Afb. 4Overerving als boom: elke subklasse erft de eigenschappen van de klasse erboven — een Docent is óók een Medewerker en een Persoon.

Tot nu toe dachten we in losse variabelen en functies. Objectgeoriënteerd programmeren (OOP) bundelt bij elkaar horende gegevens en gedrag in objecten. De basis is de klasse: een bouwtekening of mal die beschrijft hoe een bepaald soort ding eruitziet en wat het kan. Een object is een concreet exemplaar dat je volgens die mal maakt, ook wel een instantie genoemd. Vergelijk het met een koekjesvorm (de klasse) en de koekjes die je ermee steekt (de objecten): één vorm, veel koekjes die allemaal dezelfde structuur hebben maar elk hun eigen inhoud. Zo beschrijf je met de klasse Leerling wat élke leerling heeft en kan, terwijl leerling1 een specifieke leerling is met eigen gegevens.

Een klasse bestaat uit twee soorten leden. Attributen (ook wel eigenschappen of velden) zijn de variabelen die de gegevens van een object bewaren: een Leerling heeft bijvoorbeeld de attributen naam en cijfers. Methoden zijn de functies die bij de klasse horen en die iets met die gegevens doen: een methode gemiddelde() berekent het gemiddelde van de cijfers van díé leerling. Elk object heeft zijn eigen waarden voor de attributen, maar deelt de methoden met alle objecten van dezelfde klasse. Het samenbrengen van data en de bijbehorende bewerkingen in één geheel heet encapsulatie (inkapseling). Een belangrijk voordeel is afscherming: je regelt de toegang tot de gegevens via de methoden, zodat de buitenwereld een object alleen op een gecontroleerde manier gebruikt en de interne details verborgen blijven.

Klassen kunnen gegevens en gedrag van elkaar erven; dat heet overerving (inheritance). Je maakt dan een algemene basisklasse en daaronder meer specifieke subklassen die alles van de basisklasse overnemen en er eigen kenmerken aan toevoegen. Denk aan een basisklasse Persoon met een naam; daarvan erven Leerling en Medewerker, en van Medewerker erven op hun beurt weer Docent en Conciërge. Zo ontstaat een hiërarchie — zie het klassenschema bij deze paragraaf — waarin gemeenschappelijke eigenschappen bovenin één keer worden vastgelegd en niet bij elke subklasse opnieuw. Overerving voorkomt zo dubbele code en maakt de samenhang tussen soorten dingen expliciet: een Docent ís een Medewerker, die op zijn beurt een Persoon ís.

Programmeertalen ondersteunen verschillende manieren van denken, de programmeerparadigma's. In het imperatieve of procedurele paradigma beschrijf je stap voor stap wélke opdrachten in welke volgorde moeten gebeuren, gegroepeerd in procedures — de klassieke, meest directe manier van programmeren. Het objectgeoriënteerde paradigma organiseert het programma rond objecten die data en gedrag combineren, wat vooral bij grote programma's overzicht geeft. In het functionele paradigma bouw je een programma op uit functies die een invoer omzetten in een uitvoer zonder neveneffecten, wat het gedrag voorspelbaar maakt. Het gebeurtenisgestuurde (event-driven) paradigma laat het programma ten slotte reageren op gebeurtenissen: een klik op een knop of het binnenkomen van gegevens roept dan een bijbehorende functie (een event handler) aan — de gebruikelijke aanpak bij grafische interfaces en apps.

In de praktijk zijn deze paradigma's geen strikte keuzes maar gereedschappen die je combineert; veel moderne talen zoals Python ondersteunen ze allemaal tegelijk. De keuze hangt af van het probleem: een klein rekenscript schrijf je meestal gewoon imperatief; een uitgebreid systeem met veel samenhangende gegevens — denk aan een schooladministratie met leerlingen, docenten en cijfers — wordt overzichtelijker met objecten; en een app met knoppen en schermen is van nature gebeurtenisgestuurd. Dat gebeurtenisgestuurde model verklaart ook waarom een programma met een grafische interface niet netjes van boven naar beneden afloopt maar 'wacht' op de gebruiker. Wie de paradigma's herkent, begrijpt beter waaróm code op een bepaalde manier is opgebouwd — en dat helpt weer bij het lezen, uitbreiden en testen ervan.

Vier programmeerparadigma's

Afb. 5De vier paradigma's met hun kernidee en een situatie waarin ze passen. Moderne talen combineren ze vaak.

Uitgewerkt voorbeeld

Een object modelleren en beschrijven

Modelleer een klasse Leerling met de attributen naam en cijfers en een methode gemiddelde(). Beschrijf daarna één concrete instantie.

De klasse opstellen
klasse Leerling: attributen: naam, cijfers methode gemiddelde(): geef som(cijfers) / aantal(cijfers) terug
Een instantie maken
Maak een object met leerling1 = Leerling("Sanne", [7, 8, 6]). Dit object heeft nu naam „Sanne” en cijfers [7, 8, 6].
De methode toepassen
Roep leerling1.gemiddelde() aan: de som van de cijfers is 7 + 8 + 6 = 21, gedeeld door 3 cijfers geeft 7.0.
Vergelijk met een tweede object
Een tweede object leerling2 = Leerling("Ravi", [4, 6]) gebruikt dezelfde methode maar heeft eigen attribuutwaarden; gemiddelde() geeft daar (4 + 6) / 2 = 5.0.
Beschrijving
leerling1 is een instantie van de klasse Leerling. Beide objecten delen de methode gemiddelde(), maar elk object bewaart zijn eigen data — dat is precies de kern van objectoriëntatie.

Resultaat: leerling1.gemiddelde() geeft 7.0 en leerling2.gemiddelde() geeft 5.0: dezelfde klasse en methode, maar eigen attribuutwaarden per object.

Veelgemaakte fouten

Klasse en object door elkaar halen: de klasse is de mal, het object is het concrete exemplaar.
Attributen (de gegevens) verwarren met methoden (het gedrag) van een object.
Denken dat objectgeoriënteerd 'beter' is dan de andere paradigma's; elk paradigma past bij een ander type probleem.

Actieve herhaling

Ontwerp een klasse Boek met minstens twee attributen en één methode. Beschrijf daarna één concrete instantie van je klasse, en geef aan welk paradigma je hierbij gebruikt.

Actief ophalen

Haal de kernpunten op — onthul ze daarna.

Bronnen: Examenprogramma informatica (HAVO) (CvTE / Examenblad)

Testen en debuggen#

Standaardexamenblad-nl

Testgevallen voor geslaagd(cijfer)

Afb. 6Zinvolle testgevallen: normale waarden, de randgevallen rond de grens 5,5, en foutieve invoer. Het gemarkeerde randgeval 5,5 hoort waar te geven omdat >= inclusief is.

Een programma dat zonder foutmelding draait, is nog niet automatisch een goed programma: het kan vlekkeloos draaien en tóch het verkeerde antwoord geven. Testen is het gericht controleren of je programma doet wat het moet doen, door het met zorgvuldig gekozen invoer te draaien en de uitkomst te vergelijken met wat je verwacht. Je bewijst met testen nooit dat een programma helemaal foutloos is — je kunt niet alle mogelijke invoer proberen — maar met goed gekozen gevallen vind je de meeste fouten wél. Daarom hoort testen er niet pas aan het eind bij, maar is het een vast onderdeel van het maken: je bedenkt eerst het gewenste gedrag, en pas als de testen slagen beschouw je een stuk code als af.

Een testgeval bestaat uit een concrete invoer plus het verwachte resultaat; bij het uitvoeren vergelijk je dat verwachte resultaat met het werkelijke resultaat. Goede testgevallen kies je uit drie categorieën. Normale invoer is een 'gewoon' geval midden in het toegestane bereik, bijvoorbeeld het cijfer 7,0 voor een functie die 'geslaagd' bepaalt. Randgevallen zitten precies op of vlak naast een grens, waar de meeste fouten zitten: bij de grens 5,5 test je 5,4, 5,5 en 5,6, want juist daar gaat een verkeerd gekozen < of <= mis. Foutieve of onverwachte invoer, ten slotte, is invoer die eigenlijk niet mag — een negatief cijfer, of tekst waar een getal wordt verwacht — waarvan je test of het programma er netjes op reageert in plaats van vast te lopen. Deze drie categorieën samen maken een testset betekenisvol.

Fouten (bugs) komen in drie soorten, die je op verschillende manieren merkt. Een syntaxfout is een taalfout tegen de grammatica van de programmeertaal — een vergeten dubbele punt of haakje — waardoor het programma niet eens start; de computer wijst de plek meestal aan. Een runtimefout (uitvoeringsfout) treedt pas op tíjdens het draaien, als het programma iets onmogelijks probeert, zoals delen door nul of het opvragen van een lijstelement dat niet bestaat; het programma stopt dan met een foutmelding. Het lastigst is de logische fout: het programma draait netjes en geeft een antwoord, maar het verkeerde, doordat de bedachte oplossing niet klopt (bijvoorbeeld < gebruiken waar <= moest). Syntax- en runtimefouten schreeuwen om aandacht; een logische fout moet je zélf ontdekken door de uitkomst te controleren — precies waarvoor je test.

Het opsporen en herstellen van fouten heet debuggen. Werk daarbij systematisch, in plaats van willekeurig regels te veranderen. Reproduceer eerst de fout: zoek een invoer waarbij het misgaat en zorg dat je die betrouwbaar kunt oproepen. Isoleer daarna het probleem: baken af in welk stuk code de fout ontstaat, bijvoorbeeld door de code in delen te draaien. Maak vervolgens de toestand zichtbaar — met printregels die tussenwaarden tonen, of met breakpoints waarmee je het programma in een debugger stap voor stap laat lopen en de variabelen bekijkt. Stel dan een hypothese op over de oorzaak ('de teller begint fout') en tóets die gericht door één ding te veranderen en opnieuw te testen. Blijkt de hypothese onjuist, dan verwerp je haar en probeer je een volgende — net zolang tot de fout weg is.

Debuggen is dus een cyclus: reproduceren, isoleren, een hypothese opstellen, die toetsen, en bij een bevestigde oorzaak de fout herstellen — waarna je opnieuw test om zeker te weten dat de fout écht weg is en er geen nieuwe is bijgekomen. Het schema bij deze paragraaf laat die kringloop zien, met de terugpijl van een verworpen hypothese naar het opstellen van een nieuwe. Twee gewoontes maken je hierin sterk. Verander tijdens het zoeken steeds maar één ding tegelijk, zodat je weet welke aanpassing effect had. En bewaar je testgevallen: draai na elke reparatie de hele testset opnieuw, zodat een oplossing op de ene plek niet ongemerkt iets anders kapotmaakt. Zo werk je van 'het doet raar' naar een programma waarvan je met bewijs kunt zeggen dat het klopt.

De debugcyclus

Afb. 7Debuggen als cyclus: een verworpen hypothese leidt terug naar een nieuwe; pas na herstel én hertest is de fout klaar.

Uitgewerkt voorbeeld

Een testset met randgevallen opstellen

De functie geslaagd(cijfer) geeft waar als cijfer >= 5,5 en anders onwaar (cijfers lopen van 1 tot en met 10). Stel een zinvolle testset op.

Normale gevallen kiezen
Neem eerst twee gewone cijfers, ruim aan weerszijden van de grens: 4,0 (ruim onvoldoende) hoort onwaar te geven, 8,0 (ruim voldoende) hoort waar te geven.
Randgevallen rond de grens
De grens ligt bij 5,5. Test daarom net eronder, precies erop en net erboven: 5,4 geeft onwaar, 5,5 geeft waar (want >= is inclusief) en 5,6 geeft waar. Juist hier ontmasker je een verkeerd gekozen > in plaats van >=.
Foutieve invoer
Test ook invoer die niet mag: -2 en 11 vallen buiten het bereik 1 tot en met 10. Verwacht gedrag is dat het programma de invoer weigert of een nette melding geeft, in plaats van zomaar een uitkomst te verzinnen.
Verwacht naast werkelijk
Zet elk geval in een tabel met de kolommen invoer, verwacht en werkelijk. Draai de functie en vul de werkelijke uitkomst in; elk verschil tussen verwacht en werkelijk wijst op een fout.

Resultaat: Een testset van bijvoorbeeld 4,0 → onwaar, 8,0 → waar, 5,4 → onwaar, 5,5 → waar, 5,6 → waar en -2 → foutmelding dekt normale, rand- en foutieve invoer af.

Veelgemaakte fouten

Alleen 'gewone' invoer testen en de randgevallen op de grens overslaan, waar juist de meeste fouten zitten.
Denken dat een programma correct is omdat het zonder foutmelding draait; een logische fout geeft geen melding.
Bij het debuggen meerdere dingen tegelijk veranderen, waardoor je niet weet welke aanpassing de fout oploste.

Actieve herhaling

Gegeven de functie geslaagd(cijfer) die waar teruggeeft als cijfer >= 5,5 en anders onwaar. Stel een tabel met minstens vijf zinvolle testgevallen op (normaal, rand én foutief) met daarbij telkens het verwachte resultaat.

Actief ophalen

Haal de kernpunten op — onthul ze daarna.

Bronnen: Examenprogramma informatica (HAVO) (CvTE / Examenblad)

Referenties en bronnen

Bronnen

CvTE / Examenblad

Examenprogramma informatica (HAVO)

Domein D: Programmeren

5 Onderdelen~27 min leestijd4 VaardighedenNiveau Basis 2 · Standaard 2 · Verdieping 1

Domein D: Programmeren

Kernpunten

Een gemengde expressie evalueren

Kernpunten

De uitvoer van een lus met keuze bepalen

Kernpunten

Een functie lezen en de returnwaarde bepalen

Kernpunten

Een object modelleren en beschrijven

Kernpunten

Een testset met randgevallen opstellen

Bronnen

Domein D: Programmeren

Kernpunten

Een gemengde expressie evalueren

Kernpunten

De uitvoer van een lus met keuze bepalen

Kernpunten

Een functie lezen en de returnwaarde bepalen

Kernpunten

Een object modelleren en beschrijven

Kernpunten

Een testset met randgevallen opstellen

Bronnen