Subdomein D1 en D2: Ontwikkelen, inspecteren en aanpassen
Programmeren (in beperkte zin) is het uitdrukken van een algoritme in een voor een computer uitvoerbare taal, om zo een werkende, op de computer uitvoerbare, versie van dat algoritme te verkrijgen.
Programmeertalen
De taal waarin een programma wordt geschreven wordt programmeertaal genoemd. Binnen de vele bestaande programmeertalen zijn groepen te onderscheiden. In dit domein richten we ons op de zogenaamde imperatieve talen, waarin stapsgewijze instructies (die in een voorgeschreven volgorde worden uitgevoerd) het belangrijkste ingrediënt vormen. Imperatieve talen sluiten goed aan bij de karakterisering van algoritmen in Domein B: zo heeft elke imperatieve taal specifieke taalconstructies die overeenkomen met de basisbouwstenen opeenvolging, keuze en herhaling. Voorbeelden van imperatieve talen zijn Python, Java en Scratch.
Met de term 'paradigma' worden grondbeginselen aangeduid voor programma-ontwikkeling en voor programmeertalen die deze manier van ontwikkelen ondersteunen. Voorbeelden van paradigma's en bijbehorende talen zijn: object-georiënteerd (Java, C++), functioneel (Haskell) en logisch (Prolog). Programmeertalen worden ook wel globaal ingedeeld in twee klassen: procedureel (talen waarin vooral het 'hoe' van een berekening in detail wordt weergegeven) en declaratief (talen waarin veeleer de bedoelde uitkomst, het 'wat', wordt geformuleerd).
Programmeertaalconstructies
In een programma in een imperatieve programmeertaal kunnen, onder andere, de volgende elementen voorkomen:
- aanduidingen voor data-objecten (variabelen en constanten) en toewijzing om waarden aan variabelen toe te kennen
- zogenaamde controlestructuren: taalconstructies voor:
- opeenvolging
- keuze
- herhaling
De meeste programmeertalen bevatten abstractiemechanismen die de programmeur in staat stellen om stukken programma apart te beschrijven en met een simpele aanduiding te activeren ('aan te roepen') in een groter programma. Taalconstructies die abstractie ondersteunen zijn bijvoorbeeld:
- procedures (methoden, subroutines, …) voor stukken programma die iets doen;
- functies, al dan niet met parameters, voor stukken programma die een waarde opleveren.
Toepassing van abstractie maakt het programma overzichtelijker (door stukken programma te vervangen door een betekenisvolle naam) en vaak ook korter (door een stuk code dat meermalen wordt gebruikt te vervangen door meerdere aanroepen van eenzelfde procedure of functie).
Programma's schrijven
Het debuggen van een programmacomponent is het opsporen en verhelpen van fouten (bugs) in de programmacomponent. Dit wordt bijvoorbeeld gedaan door de programmacomponent regel voor regel uit te voeren in plaats van in het geheel en regelmatig controlewaardes te printen. Debugging wordt in de regel ondersteund door een programmeeromgeving.
Eigenschappen van programma's
Een programmacomponent is correct als deze bij iedere invoer de juiste uitvoer oplevert. De correctheid van een programmacomponent kan bijvoorbeeld onderzocht worden door het programma te testen. Correctheid kan ook onderzocht of beredeneerd worden aan de hand van het achterliggende algoritme.
Als een programma 'het niet doet' kan dat verschillende oorzaken hebben: bij het samenstellen van het programma kan een fout zijn gemaakt ('plan composition problem'), maar het achterliggende algoritme zou ook incorrect kunnen zijn. Systematisch zoeken naar de oorzaak van een fout zal dan ook beide aspecten moeten beslaan.
Naast correctheid kan ook efficiëntie van een programmacomponent worden bekeken. De uitvoertijd van een programma kan gemeten worden aan de hand van verschillende invoer, maar ook via het achterliggende algoritme worden beredeneerd. Absolute rekentijd is meestal niet zo interessant; het is zinvoller om te bekijken welk effect het vergroten van de invoer heeft op de uitvoertijd van het programma.
De leesbaarheid van een programmacomponent kan vergroot worden via een aantal mechanismen, zoals passend gebruik van abstractiemechanismen (procedures, functies), kiezen van betekenisvolle namen voor dataobjecten, procedures en functies, toevoegen van commentaar, en suggestieve lay-out. Het idee is dat vergroten van de leesbaarheid ook de inzichtelijkheid, overdraagbaarheid en onderhoudbaarheid van een programma ten goede komt. Zo zal een programma gemakkelijker op lange termijn zijn aan te passen, ook door anderen dan de oorspronkelijke maker.