Samenvattingen · InformaticaNL · VWO

Domein D: Programmeren

Programmeren is het omzetten van een bedacht algoritme in code die een computer uitvoert. Domein D behandelt het imperatieve paradigma (variabelen, datatypes, control flow, functies) en het objectgeoriënteerde paradigma (klassen, objecten, encapsulatie, overerving), het werken met datastructuren in code, en het volledige ontwikkelproces: van specificatie via implementatie naar systematisch testen en debuggen. De voorbeelden staan in taalonafhankelijke pseudocode; het draait om de begrippen, niet om één specifieke taal.

4 Onderdelen~13 min leestijd4 VaardighedenNiveau Basis 1 · Standaard 3

T·0444 / 18

Examenprofiel

D · Imperatief programmeren: variabelen, datatypes, control flow, functies, parameters en scopeD · Objectgeoriënteerd programmeren: klassen, objecten, encapsulatie, overerving en polymorfismeD · Datastructuren (arrays, lijsten, records/objecten) in code gebruikenD · Het ontwikkelproces: specificeren, implementeren, testen (unittests) en debuggen

Operatoren:schrijfleesspeel naontwerptestverbeter

basisniveau

Imperatief programmeren met de drie controlestructuren en functies is de kern; die beheersing toon je in programmeeropdrachten.

verhoogd niveau

Objectgeoriënteerd ontwerp, het onderbouwd kiezen van datastructuren en systematisch testen horen bij de verdieping en het profielwerkstuk.

Diepte

Tekst

Inhoud · 4 onderdelen

Domein D: Programmeren

Imperatief programmeren en control flow#

Basisexamenblad-informatica-D

In het imperatieve paradigma beschrijf je stap voor stap wát de computer moet doen: gegevens opslaan en veranderen. Een variabele is een benoemde geheugenplek met een waarde die tijdens de uitvoering kan wijzigen. Elke variabele heeft een datatype dat vastlegt wat erin past en welke bewerkingen erop mogen. Afb. 1 vat de veelgebruikte primitieve types samen: geheel getal (int), kommagetal (float), waarheidswaarde (boolean), teken (char) en tekenreeks (string). Het type is geen formaliteit: het bepaalt de opslag én voorkomt fouten — je kunt geen tekst optellen bij een getal zonder expliciete omzetting.

Primitieve datatypes

Afb. 1Afb. 1 — Elk datatype legt vast wat een variabele kan bevatten en welke bewerkingen erop mogen.

Met expressies reken je waarden uit: rekenkundige (

a + b

a \bmod b

), vergelijkende (

a < b

) en logische (en, of, niet). Een toewijzing legt het resultaat in een variabele vast. Let op de betekenis van het gelijkteken in code: `x ← x + 1` is geen wiskundige gelijkheid maar een opdracht — ‘bereken x + 1 en zet dat terug in x’. Deze verandering-in-de-tijd is precies wat het imperatieve paradigma kenmerkt en wat het onderscheidt van het functionele paradigma (keuze J), waar waarden juist onveranderlijk zijn.

De control flow bepaalt de uitvoervolgorde met de drie controlestructuren uit domein B. Selectie (`als voorwaarde dan … anders …`) kiest een tak op grond van een booleaanse voorwaarde. Iteratie herhaalt: een `zolang`-lus draait tot de voorwaarde onwaar wordt, een `voor`-lus een vast aantal keer. Bij lussen let je scherp op de begin- en eindwaarde en de stopvoorwaarde — de klassieke ‘off-by-one’-fout (één te veel of te weinig) ontstaat door een verkeerde grens. Correct itereren betekent: bij welke waarde begin ik, wanneer stop ik, en verandert de teller gegarandeerd richting die stop?

Om herhaling en complexiteit te beheersen bundel je code in functies (of procedures). Een functie krijgt invoer via parameters, voert een taak uit en geeft meestal een resultaat terug. Functies maken code herbruikbaar, leesbaar en apart testbaar — de programmeer-tegenhanger van decompositie. Belangrijk is scope: een variabele die binnen een functie wordt aangemaakt (lokaal) bestaat alleen daar en is buiten de functie onzichtbaar. Dat je functies via parameters en teruggeefwaarden laat communiceren in plaats van via gedeelde variabelen, houdt ze onafhankelijk en voorkomt lastig te vinden fouten.

Uitgewerkt voorbeeld

Een lus naspelen

Speel `som(4)` na: som ← 0; voor i van 1 t/m 4: som ← som + i. Wat is de teruggegeven waarde?

Start
som = 0 voordat de lus begint.
i = 1 en i = 2
som wordt 0 + 1 = 1, daarna 1 + 2 = 3.
i = 3 en i = 4
som wordt 3 + 3 = 6, daarna 6 + 4 = 10. Daarna stopt de lus (i > 4).

Resultaat: `som(4)` geeft 10 terug — de som 1 + 2 + 3 + 4.

Veelgemaakte fouten

De off-by-one-fout: een lus één keer te veel of te weinig laten draaien door een verkeerd gekozen begin- of eindgrens.
`=` in code als een wiskundige gelijkheid lezen in plaats van als een toewijzing; `x ← x + 1` verhoogt de waarde van x, het is geen bewering dat x gelijk is aan x + 1.

Actieve herhaling

Schrijf in pseudocode een functie `som(n)` die met een lus de som 1 + 2 + … + n teruggeeft. Speel de functie na voor n = 4 en noteer de waarde van de teller en de somvariabele na elke ronde.

Actief ophalen

Haal de kernpunten op — onthul ze daarna.

Bronnen: Examenprogramma informatica vwo — domein D (imperatief programmeren) (CvTE / Examenblad)

Objectgeoriënteerd programmeren#

Standaardexamenblad-informatica-D

Overervingshiërarchie van Voertuig

Afb. 2Afb. 1 — Overerving: elke subklasse erft de attributen en methoden van zijn superklasse (‘is-een’-relatie).

Objectgeoriënteerd programmeren (OO) organiseert een programma rond objecten: eenheden die gegevens (attributen) en gedrag (methoden) bundelen. Een klasse is de mal, het bouwplan; een object is een concrete instantie daarvan. De klasse `Leerling` beschrijft dát elke leerling een naam en cijfers heeft en een gemiddelde kan berekenen; ‘Sanne’ en ‘Jan’ zijn objecten met eigen waarden. Deze bundeling sluit naadloos aan op modelleren (domein A): je vertaalt de dingen uit het probleemdomein rechtstreeks naar klassen, wat grote programma’s begrijpelijk houdt.

Encapsulatie (inkapseling) betekent dat een object zijn interne gegevens afschermt en alleen via zijn methoden laat benaderen. De attributen zijn ‘privé’; de methoden vormen de openbare interface. Zo bewaakt een `Rekening`-object zijn saldo: je kunt niet zomaar het getal veranderen, alleen `storten` en `opnemen` aanroepen — en die methode kan controleren of er genoeg saldo is. Encapsulatie beschermt de samenhang van de gegevens en verbergt de implementatie, zodat je die later kunt wijzigen zonder de rest van het programma te breken.

Overerving laat een klasse voortbouwen op een andere: een subklasse erft de attributen en methoden van zijn superklasse en voegt er eigen zaken aan toe. Afb. 1 toont zo’n hiërarchie: `Voertuig` (met merk en snelheid) is de superklasse; `Auto` en `Fiets` erven daarvan, en `Sportauto` erft weer van `Auto`. Overerving voorkomt herhaling — gedeelde eigenschappen staan één keer, bovenaan — en drukt een ‘is-een’-relatie uit: een sportauto ís een auto ís een voertuig.

Polymorfisme (‘veelvormigheid’) is het sluitstuk: verschillende objecten kunnen op dezelfde boodschap elk op hun eigen manier reageren. Roep je `beschrijf()` aan op een lijst met een auto en een fiets, dan voert elk object zijn eigen versie uit. De aanroepende code hoeft het precieze type niet te kennen — ze vertrouwt op de gedeelde interface. Samen maken encapsulatie, overerving en polymorfisme OO-code uitbreidbaar: een nieuw soort voertuig toevoegen kan zonder de bestaande code te wijzigen, wat OO bij uitstek geschikt maakt voor grote, groeiende systemen.

Uitgewerkt voorbeeld

Een klasse met encapsulatie ontwerpen

Ontwerp de klasse `Rekening` zodat het saldo alleen via methoden verandert en nooit negatief wordt.

Attribuut afschermen
Maak saldo een privé-attribuut; buiten de klasse is het niet direct te wijzigen.
Storten
Methode storten(bedrag): controleer bedrag > 0 en verhoog saldo met bedrag.
Opnemen met controle
Methode opnemen(bedrag): alleen als bedrag ≤ saldo, verlaag saldo; anders weiger en geef een melding.

Resultaat: Door het saldo te encapsuleren kan geen enkele buitenstaander het ongecontroleerd wijzigen; de klasse bewaakt zelf dat het saldo geldig blijft.

Veelgemaakte fouten

Klasse en object verwarren: de klasse is het bouwplan (één keer), objecten zijn de concrete exemplaren (meerdere, elk met eigen attribuutwaarden).
Overerving gebruiken voor een ‘heeft-een’-relatie (een auto hééft een motor) terwijl het bedoeld is voor een ‘is-een’-relatie (een sportauto ís een auto).

Actieve herhaling

Ontwerp een klasse `Rekening` met een privé-attribuut saldo en de methoden `storten(bedrag)` en `opnemen(bedrag)`. Zorg dat `opnemen` niet meer laat opnemen dan het saldo, en leg uit welke rol encapsulatie hier speelt.

Actief ophalen

Haal de kernpunten op — onthul ze daarna.

Bronnen: Examenprogramma informatica vwo — domein D (objectgeoriënteerd programmeren) (CvTE / Examenblad)

Werken met datastructuren in code#

Standaardexamenblad-informatica-D

Objectdiagram: een klas met leerlingen

Afb. 3Afb. 1 — Tijdens de uitvoering wijzen objecten via verwijzingen naar elkaar; hier verwijst een klas naar haar leerlingen en omgekeerd.

Losse variabelen volstaan niet voor grote hoeveelheden gegevens; daarvoor gebruik je datastructuren in code. Een array (of lijst) bewaart een reeks waarden onder één naam, elk bereikbaar via een index. Cruciaal detail: indices beginnen in vrijwel elke taal bij 0, dus de eerste plek is `rij[0]` en het laatste element `rij[n-1]` bij lengte

n

. Een record (of object) bundelt juist gegevens van verschillende soorten die bij elkaar horen — naam, klas en cijfer van één leerling. Je combineert beide voortdurend: een array van objecten, bijvoorbeeld een lijst leerlingen.

Afb. 1 laat zien hoe zulke datastructuren er tijdens de uitvoering uitzien: een objectdiagram met een `Klas`-object dat verwijst naar meerdere `Leerling`-objecten, terwijl elke leerling terugverwijst naar zijn klas. Deze verwijzingen (references) zijn de lijm van OO-programma’s: objecten bevatten niet elkaars gegevens, maar wijzen naar elkaar. Begrijpen dat twee variabelen naar hetzelfde object kunnen wijzen (aliasing) — zodat een wijziging via de één ook via de ander zichtbaar is — voorkomt een hele klasse van verwarrende fouten.

Om iets met een array te doen, itereer je erover met een lus die de index van 0 tot

n-1

laat lopen. Dit patroon — ‘doe voor elk element iets’ — is de brug tussen de algoritmen uit domein B en echte code. Zoeken, tellen, optellen, het grootste of kleinste element vinden: het zijn allemaal varianten van één keer door de array lopen en onderweg een resultaatvariabele bijhouden (een accumulator). Wie dit standaardpatroon beheerst, kan de meeste eenvoudige verwerkingstaken zelf programmeren.

De keuze van de datastructuur bepaalt hoe makkelijk je algoritme wordt — precies de les uit domein B, nu in de praktijk. Wil je vaak op index opzoeken, dan is een array ideaal; wisselt de lengte sterk, dan een lijst; hoort er een ‘laatste erin, eerste eruit’-gedrag bij, dan een stapel. Een goede programmeur kiest de structuur bewust vóór het coderen, want de verkeerde structuur maakt eenvoudige taken onnodig ingewikkeld of traag. Datastructuur en algoritme zijn twee kanten van dezelfde ontwerpbeslissing.

Uitgewerkt voorbeeld

Het maximum vinden

Vind het grootste getal in de array [6, 9, 4, 8] met het accumulatorpatroon.

Initialiseer
max ← rij[0] = 6. Begin met het eerste element als voorlopig maximum.
Vergelijk verder
rij[1] = 9 > 6 → max ← 9. rij[2] = 4 < 9 → max blijft 9.
Laatste element
rij[3] = 8 < 9 → max blijft 9. Array op.

Resultaat: Na één keer door de array is max = 9, het grootste getal — in n − 1 vergelijkingen.

Veelgemaakte fouten

De index buiten bereik laten lopen: bij een array van lengte n is de laatste geldige index n − 1; `rij[n]` valt erbuiten.
Denken dat het toewijzen van een object aan een tweede variabele een kopie maakt; beide verwijzen naar hetzelfde object, dus een wijziging is via allebei zichtbaar.

Actieve herhaling

Gegeven een array `cijfers` van lengte n. Schrijf in pseudocode een lus die het hoogste cijfer vindt, en speel je algoritme na op [6, 9, 4, 8].

Actief ophalen

Haal de kernpunten op — onthul ze daarna.

Bronnen: Examenprogramma informatica vwo — domein D (datastructuren in code) (CvTE / Examenblad)

Testen, debuggen en het ontwikkelproces#

Standaardexamenblad-informatica-D

Testtabel voor isGeldigCijfer

Afb. 4Afb. 1 — Een testtabel dekt naast een normaal geval juist de grenzen: de randgevallen leggen de meeste fouten bloot.

Code schrijven is maar één fase van het ontwikkelproces. Daarvoor komt specificeren (wat moet het precies doen, met welke invoer en gewenste uitvoer?) en ontwerpen (welke functies, klassen en datastructuren?), en erna testen, debuggen en documenteren. Deze volgorde is niet vrijblijvend: een fout die je in de specificatiefase ontdekt kost bijna niets, dezelfde fout in een uitgeleverd product veel. Programmeren is daarom voor een groot deel gestructureerd fouten voorkómen en opsporen, niet alleen ‘typen’.

Testen toont de aanwezigheid van fouten, nooit de afwezigheid ervan — je kunt niet elke mogelijke invoer proberen, dus kies je representatieve testgevallen. Cruciaal zijn de randgevallen (grenswaarden): de kleinste en grootste toegestane invoer, de lege invoer, en waarden net binnen en net buiten de grens. Afb. 1 toont een testtabel voor een functie die controleert of een cijfer geldig is (1 t/m 10): naast een normaal geval staan juist de grenzen 0, 1, 10 en 11. Systematisch testen betekent vooraf, op grond van de specificatie, deze gevallen bedenken — niet achteraf willekeurig wat proberen.

Unittests automatiseren dit: kleine stukjes code die een functie met een bekende invoer aanroepen en controleren of de uitvoer het verwachte is. Ze draaien in een oogwenk en kun je bij elke wijziging opnieuw uitvoeren, zodat je meteen ziet of je iets gebroken hebt (regressie). Een functie die alle unittests doorstaat, is aantoonbaar correct voor precies die gevallen — vandaar dat je de randgevallen erin opneemt. Deze aanpak maakt de vage eis ‘het werkt’ concreet en controleerbaar, een echo van het toetsbaar formuleren uit domein A.

Debuggen is het lokaliseren en herstellen van een fout waarvan een test het bestaan liet zien. Je onderscheidt daarbij drie soorten fouten: syntaxfouten (de code voldoet niet aan de taalregels; het programma start niet), runtimefouten (het crasht tijdens de uitvoering, bijvoorbeeld delen door nul) en de verraderlijkste, logische fouten (het programma draait maar geeft het verkeerde antwoord). Logische fouten vind je door de uitvoering te volgen: variabelen printen of met een debugger stap voor stap door de code lopen en op elk punt de werkelijke waarden vergelijken met wat je verwachtte. Je zoekt systematisch de eerste plek waar de werkelijkheid van je verwachting afwijkt.

Uitgewerkt voorbeeld

Een logische fout opsporen

Een functie die het gemiddelde van een array berekent, geeft steeds een te lage uitkomst. De code deelt de som door de arraylengte + 1. Beschrijf hoe je de fout vindt en herstelt.

Reproduceer met klein geval
Test met [10, 20]: verwacht 15, maar de functie geeft 30/3 = 10 — dus een logische fout.
Volg de uitvoering
Print de deler: die is 3 terwijl de array lengte 2 heeft. De deling gebruikt lengte + 1.
Herstel
Deel door de lengte (2), niet lengte + 1. Test opnieuw: 30/2 = 15, correct.

Resultaat: De logische fout zat in de deler; door met een klein geval te reproduceren en de tussenwaarden te volgen is hij gelokaliseerd en hersteld.

Veelgemaakte fouten

Alleen ‘gemakkelijke’ geldige invoer testen en de randgevallen (0, de grens, net erbuiten, leeg) overslaan, terwijl juist daar de meeste fouten zitten.
Uit een geslaagde test concluderen dat de code foutloos is; een test kan hooguit de aanwezigheid van fouten aantonen, nooit de afwezigheid.

Actieve herhaling

Een functie `isGeldigCijfer(c)` moet waar teruggeven voor gehele cijfers 1 t/m 10 en anders onwaar. Stel een testtabel op met minstens vijf gevallen, inclusief de randgevallen, met per geval de verwachte uitvoer.

Actief ophalen

Haal de kernpunten op — onthul ze daarna.

Bronnen: Examenprogramma informatica vwo — domein D (testen en debuggen) (CvTE / Examenblad)

Referenties en bronnen

Bronnen

CvTE / Examenblad

Examenprogramma informatica vwo — domein D (imperatief programmeren)

Domein D: Programmeren

Kernpunten

Een lus naspelen

Kernpunten

Een klasse met encapsulatie ontwerpen

Kernpunten

Het maximum vinden

Kernpunten

Een logische fout opsporen

Bronnen

Domein D: Programmeren

Kernpunten

Een lus naspelen

Kernpunten

Een klasse met encapsulatie ontwerpen

Kernpunten

Het maximum vinden

Kernpunten

Een logische fout opsporen

Bronnen