Onderhoudbare code¶

Als je software ontwikkelt is het belangrijk om goed onderhoudbare code te schrijven. In het vorige semester heb je hier al wat ervaring mee opgedaan. Denk bijvoorbeeld aan het voorkomen van dubbele code door herbruikbare code te schrijven met behulp van functies, modules en object georiënteerde technieken. Maar ook door het toepassen van coding conventions, zodat je code makkelijker leesbaar is voor anderen én voor jezelf.

Onderhoudbare code is gemakkelijk te begrijpen, aan te passen en uit te breiden. Op deze manier is het eenvoudiger om nieuwe functionaliteit toe te voegen, bestaande functionaliteit aan te passen en om bugs (fouten in de code) snel op te sporen en te verhelpen. Het zorgt dus voor meer efficiëntie in het software ontwikkelproces.

Een belangrijk voordeel van onderhoudbare code is dat het de samenwerking in het team makkelijker maakt. Wanneer de code duidelijk en gestructureerd is kunnen teamleden elkaar gemakkelijker begrijpen en ondersteunen, wat leidt tot een soepelere workflow en snellere ontwikkeling. Door vanaf het begin te focussen op onderhoudbaarheid zorg je ervoor dat zowel de codekwaliteit als een soepele samenwerking binnen het team geborgd is.

Waarom is het belangrijk om onderhoudbare software te maken?¶

Kwaliteit: Goed onderhouden software heeft vaak een hogere kwaliteit, omdat het gemakkelijker is om fouten te ontdekken en te verhelpen.
Teamwerk: Duidelijke en goed gestructureerde code maakt het eenvoudiger voor meerdere ontwikkelaars om samen te werken aan een project.
Flexibiliteit: Onderhoudbare software kan gemakkelijker worden aangepast aan veranderende eisen of nieuwe technologieën.
Tijdsefficiëntie: Het kost minder tijd om fouten op te lossen en nieuwe functies toe te voegen, wat de productiviteit verhoogt.
Toekomstbestendigheid: Software die goed is ontworpen en onderhouden, kan langer meegaan en is beter voorbereid op toekomstige ontwikkelingen.
Kostenbesparing: Onderhoudbare software kan op de lange termijn kosten besparen, omdat het eenvoudiger en sneller is om aanpassingen door te voeren.

De eerste stappen naar onderhoudbare code¶

Onderstaande lijst is een overzicht van eigenschappen waar onderhoudbare code aan moet voldoen. Deze lijst is niet compleet, maar is een goede eerste stap opweg naar onderhoudbare code.

Duidelijke structuur: De code is logisch georganiseerd, met een duidelijke hiërarchie en indeling.
Leesbaarheid: De code is gemakkelijk te lezen en te begrijpen, met duidelijke namen voor variabelen, functies en klassen.
Consistentie: Op basis van conventies wordt een consistente stijl gevolgd in de hele codebase, zoals naamgevingsconventies, indents, etc. Zo is de code gemakkelijk te lezen en te begrijpen.
Documentatie: Er is voldoende documentatie aanwezig, zoals commentaar in de code en externe documentatie, die de functionaliteit en het gebruik van de code uitlegt.
Single Responsibility Principle (SRP): Elke module, class of functie heeft één enkele verantwoordelijkheid, wat de complexiteit vermindert.
Modulariteit: De code is opgedeeld in kleine, herbruikbare modules en functies die specifieke taken uitvoeren. Zo wordt duplicatie voorkomen, is het eenvoudiger om wijzigingen aan te brengen en te testen.
Foutafhandeling: Er is een robuuste en begrijpelijke foutafhandeling aanwezig, zodat de code op een eenduidige manier omgaat met onverwachte situaties en ontwikkelaars snel kunnen begrijpen wat er mis is gegaan.
Configuratie: Instellingen en configuraties zijn gescheiden van de code, zodat wijzigingen eenvoudig kunnen worden aangebracht zonder de code zelf te wijzigen.
Flexibiliteit: De code is flexibel en kan gemakkelijk worden aangepast of uitgebreid zonder dat dit grote gevolgen heeft voor andere delen van de code.
Versiebeheer: Er wordt gebruikgemaakt van een versiebeheersystemen (zoals Git) om wijzigingen bij te houden en samen te werken met andere ontwikkelaars.

Aan welke eigenschappen kun je nog meer denken?¶

Er zijn nog veel meer eigenschappen waar onderhoudbare code aan moet voldoen, denk bijvoorbeeld aan:

Testbaarheid: De code is ontworpen met het oog op testbaarheid, met unit tests en integratietests die helpen bij het verifiëren van de functionaliteit.
Prestaties: De code is geoptimaliseerd voor prestaties, zonder dat dit ten koste gaat van de leesbaarheid of onderhoudbaarheid.
Gebruik van patronen: Het toepassen van ontwerp- en architectuurpatronen die bewezen oplossingen bieden voor veelvoorkomende problemen.
Toegankelijkheid: De code is toegankelijk voor andere ontwikkelaars, met een duidelijke onboarding- en leercurve.

Hoe kun je er voor zorgen dat je code onderhoudbaar is en blijft?¶

Leg duidelijk vast waar de code aan moet voldoen als het gaat om onderhoudbaarheid. Leg dit vast in een checklist.
Zorg voor regelmatige refactoring van de code om deze schoon en up-to-date te houden, zonder de functionaliteit te beïnvloeden.
Implementeer een proces voor code reviews om de kwaliteit van de code te waarborgen en kennisdeling te bevorderen.

Meer informatie¶

Veel van wat hierboven staat komt terug in principes die in de wereld van software development veel gebruikt worden. Denk aan:

DRY: Don’t Repeat Yourself
KISS: Keep It Simple Stupid
YAGNI: You Aren’t Gonna Need It
SOLID

Er zijn nog veel meer van dit soort principes. Op de volgende websites kun je er meer over vinden: - Key principles in Software and acronyms - Principles of Software Development: SOLID, DRY, KISS, and more

Onderstaande websites gaan vooral over clean coding en software kwaliteit: