Informatica · Klas 5 VWO · Objectgeoriënteerd Ontwerpen · Periode 2

OOP-ontwerpprincipes: SOLID

Leerlingen denken na over wie hun programma zal gebruiken en hoe ze het programma gebruiksvriendelijk en aantrekkelijk kunnen maken voor die doelgroep.

• SLO Kerndoelen en Eindtermen
• SLO: Onderbouw - Ontwerpen
• SLO: Onderbouw - Gebruiksvriendelijkheid

Over dit onderwerp

De SOLID-principes vormen de kern van robuust objectgeoriënteerd ontwerp. Leerlingen in klas 5 VWO maken kennis met de vijf principes: Single Responsibility Principle (SRP, een klasse heeft één taak), Open-Closed Principle (OCP, open voor uitbreiding, gesloten voor wijziging), Liskov Substitution Principle (LSP, subclassen vervangen superklassen zonder problemen), Interface Segregation Principle (ISP, veel kleine interfaces boven één grote) en Dependency Inversion Principle (DIP, afhankelijk van abstracties, niet concreties). Ze verklaren elk principe met voorbeelden in Python of Java, analyseren codebases op schendingen zoals SRP- of OCP-overtredingen en ontwerpen klassen die aan minstens drie principes voldoen.

Dit onderwerp sluit aan bij SLO-kerndoelen voor ontwerpen en gebruiksvriendelijkheid in de onderbouw. Door na te denken over de doelgroep van hun programma, maken leerlingen software flexibel en aanpasbaar, wat leidt tot gebruiksvriendelijke applicaties. Het bevordert systems thinking: goede principes voorkomen spaghetti-code en vergemakkelijken onderhoud en uitbreiding.

Actieve leerbenaderingen passen perfect bij SOLID, omdat principes abstract zijn maar tastbaar worden door praktijk. Leerlingen refactoren code in groepjes, voeren code-reviews uit of ontwerpen iteratief, wat diep inzicht geeft, fouten blootlegt en samenwerking traint voor echte programmeerpraktijk.

Kernvragen

1. Verklaar de vijf SOLID-principes en geef voor elk een concreet voorbeeld in Python of Java.
2. Analyseer een codebase en identificeer schendingen van het Single Responsibility Principle of het Open/Closed Principle.
3. Ontwerp een klasse die voldoet aan minstens drie SOLID-principes en onderbouw je ontwerpkeuzes.

Leerdoelen

• Verklaar de vijf SOLID-principes (Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, Dependency Inversion) en hun belang voor softwareonderhoud.
• Analyseer bestaande code op schendingen van het Single Responsibility Principle en het Open-Closed Principle, en identificeer mogelijke verbeteringen.
• Ontwerp een klasse die voldoet aan minimaal drie SOLID-principes, met een onderbouwing van de gemaakte ontwerpkeuzes.
• Vergelijk de flexibiliteit en onderhoudbaarheid van code die SOLID-principes volgt versus code die dit niet doet.

Voordat je begint

Basisprincipes van Objectgeoriënteerd Programmeren

Waarom: Leerlingen moeten bekend zijn met concepten als klassen, objecten, overerving en polymorfisme om de SOLID-principes te kunnen toepassen en begrijpen.

Functies en Methoden

Waarom: Het begrijpen van hoe functies en methoden werken binnen klassen is essentieel voor het analyseren van de verantwoordelijkheden van een klasse (SRP) en het ontwerpen van uitbreidbare code (OCP).

Kernbegrippen

Single Responsibility Principle (SRP)	Een klasse mag slechts één reden hebben om te veranderen; ze voert één specifieke taak uit.
Open-Closed Principle (OCP)	Software-entiteiten (klassen, modules, functies) moeten open zijn voor uitbreiding, maar gesloten voor wijziging.
Liskov Substitution Principle (LSP)	Subklassen moeten vervangbaar zijn voor hun basistypen zonder dat dit leidt tot onverwacht gedrag of fouten.
Interface Segregation Principle (ISP)	Clients mogen niet gedwongen worden afhankelijk te zijn van interfaces die ze niet gebruiken; maak kleine, specifieke interfaces.
Dependency Inversion Principle (DIP)	Modulen op hoog niveau mogen niet afhankelijk zijn van modulen op laag niveau. Beide moeten afhankelijk zijn van abstracties.

Pas op voor deze misvattingen

Veelvoorkomende misvatting

SOLID-principes zijn alleen voor grote professionele projecten en te complex voor scholieren.

Wat je in plaats daarvan kunt onderwijzen

SOLID bouwt goede gewoontes op vanaf het begin, ook in kleine scripts. Actieve oefeningen zoals pair programming laten zien hoe principes code leesbaarder maken, zonder overweldiging. Groepen ontdekken dit zelf door directe toepassing.

Veelvoorkomende misvatting

Single Responsibility Principle betekent dat een klasse maar één methode mag hebben.

Wat je in plaats daarvan kunt onderwijzen

SRP richt zich op één verantwoordelijkheid, niet één methode; een klasse kan meerdere gerelateerde methoden hebben. Code-reviews in kleine groepen helpen leerlingen dit onderscheid te zien en te corrigeren door voorbeelden te vergelijken.

Veelvoorkomende misvatting

Open-Closed Principle verbiedt alle wijzigingen aan code.

Wat je in plaats daarvan kunt onderwijzen

OCP staat wijzigingen toe via uitbreiding, niet modificatie van bestaande code. Iteratief ontwerpen in paren onthult dit: leerlingen breiden uit zonder kerncode aan te raken, wat het principe concreet maakt.

Ideeën voor actief leren

Pair Programming: SOLID-klasse Ontwerpen

Deel leerlingen in in paren. Geef een basisopdracht, zoals een bibliotheeksysteem. Elke leerling ontwerpt afwisselend een klasse die aan drie SOLID-principes voldoet, terwijl de partner feedback geeft. Sluit af met een korte presentatie van ontwerpkeuzes.

30 min·Duo's

Small Groups: Codebase Analyse

Verdeel de klas in kleine groepen. Geef een voorbeeldcodebase met SRP- en OCP-schendingen. Groepen identificeren problemen, documenteren ze en stellen refactor-voorstellen op. Bespreek collectief de beste oplossingen.

45 min·Kleine groepjes

Whole Class: SOLID Voorbeelden Bouwen

Start met een brainstorm over een game-applicatie. Bouw als klas stapsgewijs klassen op die SOLID volgen, met input van iedereen via een shared whiteboard. Test live in Python of Java en pas aan op basis van klasfeedback.

50 min·Hele klas

Individual: Refactor Oefening

Geef elke leerling een eenvoudige, niet-SOLID code. Laat ze deze refactoren volgens minstens twee principes en onderbouwen in een kort verslag. Deel vrijwillig resultaten in plenaire sessie.

25 min·Individueel

Verbinding met de Echte Wereld

• Bij game-ontwikkeling gebruiken studio's zoals Guerrilla Games SOLID-principes om complexe game-engines flexibel te houden. Dit maakt het mogelijk om nieuwe gameplay-mechanismen toe te voegen zonder bestaande systemen te breken, wat essentieel is voor de lange levensduur van een titel.
• Financiële softwarebedrijven, zoals Adyen, passen SOLID-principes toe in hun betalingssystemen. Dit zorgt ervoor dat nieuwe betaalmethoden of beveiligingsprotocollen geïntegreerd kunnen worden zonder de kernfunctionaliteit van transactieverwerking te beïnvloeden, wat cruciaal is voor betrouwbaarheid.

Toetsideeën

Peerbeoordeling

Laat leerlingen in tweetallen een kleine, niet-SOLID-codefragment analyseren. Elk tweetal identificeert minimaal twee SOLID-schendingen en stelt concrete verbeteringen voor. Ze presenteren hun bevindingen aan de klas, waarbij ze de principes benoemen die geschonden zijn en hoe de code aangepast kan worden.

Uitgangskaart

Geef elke leerling een kaartje met een scenario (bijvoorbeeld: een klasse die zowel data opslaat als de data valideert). Vraag hen om één SOLID-principe te noemen dat hier mogelijk geschonden wordt en leg in één zin uit waarom. Vraag hen vervolgens hoe ze de klasse zouden opsplitsen om aan dat principe te voldoen.

Discussievraag

Start een klassengesprek met de vraag: 'Stel, je werkt aan een project waar de deadline heel krap is. Zou je dan nog steeds de SOLID-principes volgen, of zou je ze negeren om sneller te kunnen leveren? Waarom?' Stimuleer discussie over de lange-termijn gevolgen van het negeren van deze principes.

Veelgestelde vragen

Wat zijn de vijf SOLID-principes precies?

De SOLID-principes zijn: SRP (één taak per klasse), OCP (open voor uitbreiding, gesloten voor wijziging), LSP (subklassen vervangbaar), ISP (kleine interfaces) en DIP (afhankelijk van abstracties). Ze zorgen voor flexibele, onderhoudbare code. In de les verklaren leerlingen ze met Python- of Java-voorbeelden en analyseren schendingen in codebases.

Hoe leer je SOLID-principes met actieve methoden aan?

Gebruik pair programming voor ontwerpen, groepscode-reviews voor analyse en iteratieve refactoring. Dit maakt abstracties tastbaar: leerlingen ervaren direct hoe SRP code vereenvoudigt of OCP uitbreiding mogelijk maakt. Samenwerking versterkt begrip en simuleert professionele workflow, met 70% betere retentie door praktijk.

Voorbeelden van SOLID in Python voor VWO?

Voor SRP: een aparte Validator-klasse voor inputchecks. OCP: een Strategy-interface voor sortering, met concrete implementaties. LSP: Rectangle en Square die Shape-methoden correct erven. ISP: aparte interfaces voor printen en scannen. DIP: afhankelijkheid van een Logger-interface. Leerlingen bouwen en testen deze zelf.

Hoe analyseer je een codebase op SOLID-schendingen?

Zoek SRP-schendingen door klassen met meerdere taken te spotten, OCP door hard-coded extensies. Gebruik tools als pylint of handmatig: markeer overtredingen en stel fixes voor. In lessen doen groepen dit collaboratief, wat kritisch denken traint en leidt tot betere ontwerpen.