vrijdag 10 juli 2026

Testautomatisering met NL, Nederland én Netherlands tegelijk


Een ketentest die ik recent tegenkwam: je maakt testdata aan via de API, past die vervolgens aan in applicatie A en controleert het resultaat in applicatie B. Of andersom: aanpassen in B, controleren in A. Simpel, zou je zeggen. Tot je merkt dat "Nederland" in de API "NL" heet, in A "Nederland" is en in B ineens "Netherlands".

Testautomatisering van ketentesten en integratietesten heeft zo haar eigen problemen. Een van die problemen is de testdataweergave, zeker als je ketentesten en integratietesten een combinatie zijn van API aanroepen en GUI gebruik. En dan is er nog die combobox, die het net weer anders doet: "NL - Netherlands". Jouw integratietest gebruikt al deze varianten, niet alleen als weergave, maar ook om testdata in te voeren.

Hoe hou je hier orde in? In deze blog deel ik mijn oplossing.

Stap 1 – Maak een goede opzoekstructuur

De concrete oplossing kan per programmeertaal verschillen, maar waar dit op neer komt is dat je op basis van een keyvalue andere varianten op kan zoeken. Van belang is dat je dit deel alleen richt op de data. Laat varianten die je kan baseren op andere weergavevarianten weg, zoals b.v. in het bovenstaande voorbeeld de waarde NL – Netherlands. Voor de bovenstaande situatie zou deze oplossing leiden tot de mogelijkheid om op basis van de waarde NL te zoeken naar een record of item. Vervolgens kan je uit dat record of item de Nederlandse of de Engelse naam selecteren.


Stap 2 – Maak conversiefuncties

Wanneer je een bepaalde weergavewaarde kan samenstellen uit andere waardes kan je het onderhoud beperken door hier een conversiefunctie voor te maken. Omdat binnen een applicatie vaak voor verschillende soorten gegevens eenzelfde constructie gebruikt wordt, kunnen deze zelfs generiek, los van de data ontwikkeld worden. Neem de waarde “NL – Netherlands”. Wanneer een combobox de combinatie “Code - Naam” heeft, hebben vaak meerdere comboboxes dit. Een functie die tussen twee woorden een streep toevoegt kan dan ook erg generiek gebruikt worden.

Stap 3 – Maak gestandaardiseerde functies om de data op te vragen

Als je data de ene keer met een conversiefunctie omgezet moet worden en de andere keer niet kan je code al vrij snel moeilijk te begrijpen worden. Dit kan je verhelpen door een kleine extra laag toe te voegen, waarbij je steeds dezelfde functies gebruikt. Uitgaande van het voorbeeld aan het begin kan je b.v. de functies GetAPIValue(), GetDutchValue(), GetEnglishValue(), GetEnglishComboboxValue() maken voor een CountryList object. Wanneer je vervolgens een CityList krijgt, kan je deze precies dezelfde functies geven. Binnen deze functies regel je vervolgens het opzoeken van de juiste waarde of waardes en evt. de conversiefuncties die hiervoor nodig zijn. Mocht dit wijzigen, dan hoef je het maar op 1 locatie aan te passen.

Voor- en nadelen

Het belangrijkste nadeel is dat deze constructie de code ingewikkelder maakt. Daarnaast breng je zaken, die je als business rules kan zien, in je testautomatisering. Dit wordt over het algemeen niet aangeraden.

Maar voor mij wegen de voordelen zwaarder.

  • Je controleert binnen je testautomatisering slechts op 1 weergavevorm, waardoor je consistentie veel beter test
  • De data wordt slechts op 1 locatie bewaard, waardoor toevoegen, wijzigen en verwijderen van data slechts op 1 locatie hoeft te gebeuren
  • Wanneer een weergavevorm wijzigt, hoef je de code slechts op 1 locatie aan te passen
  • De testcode zelf wordt juist minder ingewikkeld, doordat dezelfde functienamen steeds terugkomen i.p.v. een grote variatie aan conversie of validatiefuncties.

Deze aanpak is niet de enige oplossing, en ook niet voor elke situatie de beste keuze. Maar in projecten met veel weergavevarianten heeft hij mij veel onderhoud bespaard.

vrijdag 26 juni 2026

Wanneer gaan bij mij de alarmbellen af?


Ik zit nu al heel lang in het vak, ben bij veel bedrijven geweest en heb nog veel meer applicaties gezien. In de loop van de tijd heb ik een soort van tweede zintuig ontwikkeld, waardoor ik kan aanvoelen waar een mogelijk kwaliteitsrisico zit. Niet omdat ik helderziend ben, maar omdat ik dezelfde situaties steeds terugzie. En als ik ze zie, gaan mijn alarmbellen af.

Missende groep in testdekking

Als het om mijn alarmbellen gaat, gaat het niet om “missen de randgevallen”. Het gaat eerder om “is er met genoeg brillen naar gekeken”. Zo wil ik bij het testen graag de volgende groepen herkennen

Testerskennis

Dit zijn testcases die vaak verschillende situaties testen of juist de uitzonderingen. Denk hierbij aan de controle op verplichte gegevens, lijsten controleren met 0, 1 en meerdere waardes en randgevallen. De zaken waar een tester op getraind is

Organisatiespecifiek

Hierbij gaat het om testgevallen, waarbij groepen testen afgestemd zijn op de ervaring in het bedrijf. Dit kunnen testgevallen zijn, die gebaseerd zijn op productiefouten. Maar ook testgevallen, die gebaseerd zijn op kennis van vorige projecten. In tegenstelling tot de vorige groep, is deze lijst minder voorspelbaar

Organisatiebelang

Dit is de groep waarin het niet specifiek gaat om wat er eerder fout ging of wat er volgens de regels moet. Hier gaat het erom: “Wat is er van belang voor de organisatie”. Bijvoorbeeld speciale aandacht voor beveiliging of compliance. Of juist voor correctheid

Waar dit eigenlijk op neer komt, is of er geen kokervisie is ontstaan, doordat een te beperkte groep mensen naar de applicatie heeft gekeken. Dit kan nog wel eens voorkomen als bijvoorbeeld een helpdesk slecht contact heeft met development. Of men een compliance afdeling liever ontwijkt.

Aantal als-dan loops

De kwaliteit van je applicatie is nooit zo goed, dat er nooit mensen over klagen. Ik heb ervaren dat het aantal klachten of klagers niet zo’n goede indicatie is van de kwaliteit. Wanneer je een goede applicatie hebt, klaagt men eerder over details. Als je een slechte applicatie hebt, brengt men de details niet eens ter sprake. Daarom tel ik het aantal “Als-dan loops” in de gemiddelde problemen. Wanneer de klacht bijvoorbeeld is “Als ik Hongarije als land selecteer, dan kan ik niet verder”, is dit een teken van een slechtere kwaliteit. Maar bij “Wanneer ik Hongarije selecteer in stap 1 en daarna bijgebouw selecteer in stap 2 om vervolgens terug te gaan naar stap 1, zijn de gegevens in stap 1 niet meer correct”, ben je een flinke kwaliteitssprong verder

Inconsistentie

Als er inconsistentie is, kom je daar vaak pas in de loop van het project achter. Op je Confluence pagina staan 5 items, in je story 7. Of in de ene story wordt gesproken van een organisatie en in een andere story van bedrijf. Hoe vaker dit voorkomt, hoe groter de kans dat er onderdelen gemist zijn of anders gebouwd zijn dan gewenst.

(Bijna) alle communicatie in Jira (of soortgelijk tool)

Wat moet je nu bouwen

Deze informatie staat in de story en is vaak wel aanwezig

·       Wat moet de applicatie zijn of worden

Dit is de informatie die ervoor zorgt dat story's gezamenlijk leiden tot een correcte applicatie

In de praktijk wordt er op de tweede groep snel en veel bezuinigd. Ik kom ze tegen, de projecten waar het antwoord vaak is “Dat staat in het ticket”. Dat klinkt goed, het is vastgelegd, maar in de praktijk merk ik dat dit vaak problemen geeft.

Wanneer informatie alleen in tickets is vastgelegd, is er zowel een grotere kans op het missen van onderdelen als op het bouwen van onderdelen die niet op elkaar aansluiten. Dit komt, doordat hoe vaker informatie opgesplitst en herhaald wordt, hoe eerder fouten ontstaan. Een lijst van 12 wordt opgesplitst in 24 story’s, 2 per item op de lijst. Denk je er dan bij punt 13 aan om ook story variant 2 hiervoor aan te maken? En als je aanpassingen doet voor team 1, worden die dan ook gedaan voor team 2?

Als men de tweede groep documentatie als basis gebruikt, worden er veel minder snel onderdelen vergeten en sluit wat gebouwd wordt eerder op elkaar aan. Al is het alleen maar door ernaar te verwijzen.

Jouw alarmbellen

Misschien heb jij een eigen lijst, met andere punten of andere prioriteiten. Dat is ook precies de bedoeling. Een alarmbellensysteem werkt alleen als het op jouw ervaring is gebaseerd, niet op die van iemand anders.

Wat ik in de loop van de jaren heb geleerd: de alarmbellen gaan niet af omdat ik een checklist afloop. Ze gaan af omdat ik patronen herken. En die patronen herken ik alleen omdat ik ze eerder heb gezien. Dat kan zijn in een ander project, bij een ander bedrijf, in een andere applicatie. Elke keer dat er iets misging waar ik op had kunnen letten, is er een bel bijgekomen.

Dus als jij nog geen lijst hebt: begin er één. Niet als protocol, maar als geheugen.

woensdag 10 juni 2026

Twee jubilea, één rode draad - Groeien en toch jezelf blijven


Twee jubilea deze maand. Twintig jaar geleden ben ik begonnen als tester. 12,5 jaar geleden ben ik begonnen met deze blog. Er is in die tijd veel veranderd. Zowel in het testvak, als voor mijzelf.

Ik ben teruggegaan naar mijn eerste blog. Het was grappig hier de volgende tekst tegen te komen:

Ik ben geen testcoördinator. Ik ben geen testconsultant. Ik heb nooit op conferenties gestaan. Ik heb geen officiële complete Agile of Scrum opleiding gehad. Ik heb weinig collega's gehad om kennis mee uit te wisselen. Wat ik vooral heb, is ervaring. Ervaring in verschillende bedrijven, waarbij ik met vallen en opstaan heb geleerd wat werkt en wat niet. En het geluk om af en toe personen tegen te komen waarmee ik mijn ervaringen kan uit te wisselen. Personen waarvan ik kan leren. Soms testers, soms testcoördinatoren, soms scrummasters, soms ontwikkelaars, soms andere mensen. Of dit genoeg is om een blog te schrijven over Agile testen, laat ik ter beoordeling aan de lezer over. Maar ik zou zeggen, geef het een kans. Niet gelezen, altijd gemist.

Mijn werksituatie is sinds die tijd wel veranderd: vaker grotere teams, meer richting consultant en zeker officiële opleidingen gevolgd. Het werk is steeds meer verschoven van handmatig testen naar testautomatisering. Maar tegelijkertijd hecht ik nog steeds de meeste waarde aan het feit dat ik in heel veel verschillende bedrijven heb gewerkt. En zijn mensen om mij heen nog steeds belangrijk, als het gaat om groeien en leren. Nog steeds vind ik vooral het vallen en opstaan tijdens mijn werk een belangrijk deel van mijn ervaring. En ondanks meer certificaten en ervaring is mijn insteek bij elke blog nu ook “Of mijn kennis voldoende is om een blog te schrijven, laat ik ter beoordeling aan de lezer over. Maar ik zou zeggen: geef het een kans. Niet gelezen, altijd gemist.”

Omdat AI voor mij een standaard is geworden, heb ik Claude maar eens even gevraagd om mijn ontwikkeling te omschrijven op basis van mijn blogs:
de rode draad — kwaliteit verdedigen, weerstand ombuigen, eigenstandig redeneren — is tien jaar lang onveranderd gebleven. Wat wél veranderd is, is de technologische context (Selenium → Playwright → AI), de professionele situatie (vaste baan → detachering) en de diepgang van de reflectie. De blogger is ouder en wijzer geworden, maar schrijft nog steeds over hetzelfde: hoe je als tester "Ja" zegt waar de organisatie "Nee" zegt.

Een mooie samenvatting, al zou ik het zelf anders verwoorden. Hoewel mijn werk en mijn werkomgeving zijn veranderd, heb ik in de kern nog steeds dezelfde overtuigingen: ga voor kwaliteit, volg niet blind de mening van iemand anders (ook niet de meerderheid) en probeer onder alle omstandigheden beter te bereiken. Ik hoop dat ik inderdaad wijzer ben geworden, maar zelf zou ik het bescheiden houden op: ik heb meer kennis en ervaring nu.

Ik heb de testwereld zien veranderen van waterval naar Agile en van volledig handmatig testen naar steeds meer testautomatisering. Maar door alle ontwikkelingen heen, ongeacht methode, tools en technieken zijn mijn testovertuigingen niet veel veranderd. Ik heb waardering gevoeld voor waar ik voor wil staan als tester, maar ook afkeuring. Zowel toen als nu. En ik heb van beiden geleerd.

Maar wat ik vooral voel als ik terugkijk is trots. Trots op wie ik ben geworden, trots op wat ik bereikt heb. Maar ook trots op wie ik ben gebleven. Ik weet dat mensen uit 2016 me in mijn werk niet meer terug zouden kennen. En ik weet dat mensen uit 2016 mijn woorden nog steeds wel zouden herkennen. Dat is een evenwicht waar ik ook voor de komende 20 jaar best voor wil tekenen. Groeien in mijn vak, maar blijven staan voor wat ik belangrijk vind.

dinsdag 19 mei 2026

SOLID is te veel, POM is te weinig


Ik heb al aardig wat testautomatiseringsframeworks opgezet en aangepast. En ik heb altijd al veel aandacht besteed aan begrijpelijkheid en onderhoudbaarheid. Maar sinds ik in de detachering ben gegaan, is dit onderwerp nog meer gaan leven. Je hoort opeens in korte tijd veel meer meningen over wat de ideale code is. Waarbij woorden als SOLID en POM regelmatig langskomen.

Wat SOLID betreft zie ik grotendeels twee kampen: het kamp dat de best practices altijd toepast en het kamp dat SOLID helemaal niet van toepassing vindt op testautomatisering. Ik merk dat ik hier tussenin val.

Ik heb deze best practices zelf geprobeerd toe te passen en ik merkte dat vaak testautomatiseringscode hierdoor in begrijpelijkheid en onderhoudbaarheid afneemt. De code is te eenvoudig om de best practices consistent op toe te passen. Hierdoor krijg je extra code lagen, die weinig toevoegen, maar wel zorgen dat je code nu op 2 of meer plaatsen moet aanpassen, in plaats van een. Bijvoorbeeld door het toevoegen van interfaces, die slechts een maal in de code gebruikt worden. Een ander voorbeeld is het opsplitsen van paginacode in een invoer- en een validatieklasse vanuit de S van SOLID. In de praktijk betekent dit dat een aanpassing aan één veld je dwingt twee bestanden aan te passen in plaats van één.

Maar dat betekent niet dat ik vind dat je het zomaar moet negeren. Het argument “Het is geen productiecode”, dat ik vaak hoor, vind ik niet terecht. Juist testautomatiseringscode heeft behoefte aan een goede onderhoudbaarheid. En daar kunnen principes als SOLID wel degelijk  aan bijdragen.

Over POM ben ik al veel langer ontevreden. Het is een goede structuur, zeker. Maar ik heb nooit gesnapt waarom we als testautomatiseerders regelmatig stoppen bij POM, helpers en datadriven programmeren. Qua data kan ik dit het snelste duidelijk maken: als een bedrijf besluit om in plaats van ‘Groot-Brittanië’ voortaan ‘United Kingdom’ te gebruiken, op hoeveel plaatsen in je code moet je dit dan aanpassen? Wie heeft zijn code zo geschreven dat het antwoord hierop ‘1 keer’ is?

Hoe doe ik het dan wel? Ik zal twee recente voorbeelden geven. Ik heb verschillende datasets gemaakt in mijn code, waarmee je op basis van een landcode (volgens internationale standaard) data horende bij dat land op kan halen. De data is op 1 plek vastgelegd. En bij aanpassen wordt automatisch het invoeren en controleren aangepast, omdat de landcode gelijk blijft. Daarnaast geeft dit de mogelijkheid om bij het testen eenvoudig testsets te maken van naar wens 1 land of juist een testset met data van verschillende landen.

Als extraatje heb ik de landcode zo vastgelegd, dat als ik er een toevoeg elke dataset niet meer te compileren is. Allemaal geven ze aan dat er nu een landcode mist. Dit is een variant op het L van SOLID, die je vraagt om bij een afgeleide van een interface er altijd voor te zorgen dat alle functies van die interface goed blijven werken. Door mij vertaald: door het toevoegen van een land moeten alle datasets goed opvraagbaar blijven. Een ontwikkelaar moet zich niet hoeven afvragen of standaardgebruik leidt tot een ongewenste uitkomst.

Een ander voorbeeld: een veelvoorkomend testautomatiseringsprobleem is comboboxen die niet als combobox werken. Je testtool kan in een combobox niet op de standaard manier een waarde selecteren. Dus haal je trucjes uit met klikken, invoeren of zoiets om toch maar de waarde geselecteerd te krijgen. En zo’n combobox komt vaak vaker terug. Deze code heb ik altijd gecentraliseerd, vaak in een functie. Maar nu heb ik er iets langer over nagedacht. Het eindresultaat waren twee nieuwe combobox classes. Een voor elk type dat ik in mijn code tegenkwam. Beiden hebben een selectOption() en een nth(), precies als Playwright. En beiden zijn gebaseerd op een abstracte klasse, die een eventuele nieuwe comboboxvariant dwingt dezelfde functies ook te implementeren. Deze oplossing zorgt dat ik een eventuele aanvulling zo toe kan voegen. Zo had de eerste versie alleen selectOption. De nth() is later toegevoegd. Als ik later een derde comboboxvariant tegenkom, voeg ik een nieuwe klasse toe zonder de bestaande twee aan te raken. Precies wat de O van SOLID beoogt.

In testautomatisering is onderhoudbaarheid belangrijk, net als begrijpelijkheid. Deze eisen moeten in mijn ogen altijd gaan boven SOLID, POM of welk design principe dan ook. Dat houdt in dat je geen enkel design principe pertinent moet afwijzen, omdat het de onderhoudbaarheid wel kan vergroten. Ook betekent het niet dat je elk design principe blind moet toepassen, omdat dat de onderhoudbaarheid en begrijpelijkheid kan verkleinen. En evenmin dat alleen het toepassen van design principes je code onderhoudbaar en begrijpelijk maakt, zeker niet in testautomatisering.

De vragen die ik mezelf blijf stellen zijn vragen als: wordt deze code of data op meerdere plekken herhaald? En hoe foutgevoelig is een aanpassing? Die vragen leiden soms tot een design principe als oplossing, soms tot een andere oplossing. Maar ik wil deze afweging elke keer opnieuw maken, alles om onderhoudbaarheid en begrijpelijkheid te blijven verhogen.

zondag 26 april 2026

Van hoogst naar mogelijke

 


Ik was en ben perfectionistisch. Ik wil altijd het hoogst mogelijke bereiken. Maar naarmate mijn ervaring toenam, merkte ik iets op: hoe meer je wil bereiken, hoe minder je vaak bereikt. En dit is vooral merkbaar in testautomatisering en testverbetering. Hoe hoger de eisen aan de testautomatisering of de testverbetering, hoe kleiner de kans dat er ook maar iets verbetert.

Wat ik zag gebeuren, is twee verschillende zaken. De eerste is dat verbeteringen, al dan niet door testautomatisering, door de eisen die gesteld werden, nooit in gebruik werden genomen. De perfecte oplossing was in de huidige situatie van het bedrijf of team vaak niet haalbaar, dus gebeurde er uiteindelijk niets.

Het tweede dat ik zag gebeuren had te maken met draagvlak. Ik kan met mijn kennis en ervaring weten wat de perfecte oplossing voor een testautomatiseringsprobleem is. Maar als daaraan getwijfeld wordt, is mijn oplossing niet meer perfect. Verbetering werkt op zijn best als de personen die ze moeten uitvoeren in de oplossing geloven of het minimaal een kans willen geven. Bij twijfel of ongeloof zullen mensen de perfecte oplossing alleen volgen, wanneer je constant blijft controleren. En dat is gewoon niet haalbaar. Uiteindelijk zit je met een perfecte oplossing die niet perfect wordt uitgevoerd, waardoor de perfectie niet gehaald kan worden.

Maar ik schreef dat ik nog steeds perfectionistisch ben. Ja, ik wil nog steeds het hoogst mogelijke bereiken. Ik heb alleen mijn doel verplaatst van “hoogst” naar “mogelijke”. Ik wilde altijd uitgaan van de oplossing die in theorie het beste resultaat zou geven. Het hoogste doel halen, wat maar mogelijk is. Nu wil ik iets anders. Ik wil kijken wat er in de organisatie mogelijk is, en binnen die mogelijkheden het hoogste doel halen.

Het gekke is dat dit perfectionisme vaak gezien wordt als erg pragmatisch. Maar er zit meer achter dan alleen pragmatisme. Ik kijk niet alleen naar wat nu mogelijk is, ik kijk ook of ik de grenzen kan verleggen. Ik kijk of ik meningen van mensen kan veranderen. En ik kijk of ik iets dat binnen de organisatie al bekend is, nu op een andere manier kan inzetten om een ander doel te bereiken.

Ik zorg voor snelle, korte-termijn verbeteringen, om draagvlak te creëren voor grotere, lange-termijn verbeteringen. Dus eerst een paar eenvoudige, maar waardevolle automatische testen om te bouwen aan draagvlak voor de middelen die nodig zijn voor de complexere automatische testen.

Ik wil altijd meer en beter. Maar ik wil tegelijkertijd wel dat het testen en het testproces werkelijk verbetert, en niet wacht tot alles perfect in orde is. Ik wil dat mensen zien dat verbetering kan, waardoor mensen geloven dat meer en beter ook werkelijk iets kan opleveren. Zo komen mogelijkheden open die eerst gesloten waren. Perfectie in stappen, in plaats van in een keer.

dinsdag 7 april 2026

Tijd is een factor, geen doel

 

Ik denk dat iedere tester het wel een keer heeft meegemaakt: het project waaraan je werkt moet opeens snel af. Liefst zo snel mogelijk. Vandaag is goed, gisteren was beter. Het gevolg laat zich raden: alles gaat in een noodtreinvaart. En bijna altijd zie je hetzelfde patroon terug: de tijd die zogenaamd is gewonnen in de ontwikkeling, verdwijnt genadeloos in het bugfixen.

En toch blijven we het doen.

Mijn reactie op tijdsdruk is daarom al jaren dezelfde, en die levert regelmatig fronsende wenkbrauwen op: hoe sneller iets moet, hoe langzamer ik test. Niet uit dwarsheid, maar uit ervaring. Want hoe harder een team gaat rennen, hoe sneller de kwaliteit onderuitgaat. Dat is geen mening, dat is een wetmatigheid.

Tegelijk ben ik ook niet naïef. Tijdsdruk bestaat. Soms is het onvermijdelijk. Soms zelfs terecht. Maar laten we stoppen met doen alsof “het moet snel” een volledige boodschap is. Dat is het niet. Het is hooguit de helft.

De andere helft wordt vaak bewust niet uitgesproken: hoeveel risico zijn we bereid te accepteren?
Zolang die vraag niet beantwoord is, betekent “snel” meestal: minder testen, minder nadenken, minder kwaliteit. En daar zou geen enkele tester tevreden mee moeten zijn.

Wat mij stoort, is dat snelheid zelden wordt gepresenteerd als een keuze. Het wordt gebracht als een natuurverschijnsel. Alsof we geen alternatieven hebben. Alsof morgen goed opleveren minder waardevol is dan vandaag half. Terwijl iedereen weet wat de uitkomst is: vandaag snel levert morgen gedoe op. En overmorgen frustratie.

Juist testers zouden hier harder in mogen zijn. Het is niet onze taak om blind mee te sprinten omdat de rest dat doet. Het is onze taak om zichtbaar te maken wat versnellen kost. Kwaliteit laat zich niet dwingen. Die laat zich alleen ruilen tegen stabiliteit, vertrouwen en uiteindelijk tijd.

Dus voordat we weer “even gas geven”, stel ik liever eerst een paar ongemakkelijke vragen. Versnellen we omdat het echt waarde toevoegt? Of alleen omdat iemand heeft geroepen dat het moet? En belangrijker: als dit misgaat, zijn we dan allemaal bereid de consequenties te dragen?

Want nee, we hoeven geen wedstrijd te winnen.
We proberen een goed product te leveren. En dat kost tijd. Altijd.


zaterdag 28 maart 2026

Ik leer niet voor mijn werkgever. Maar voor wie dan wel?

 
Ik ben op dit moment mijn kennis flink aan het uitbreiden. Zo ben ik bezig met het leren van SAFe, officieel vanuit mijn werk. Daarnaast ben ik mijn programmeerkennis aan het uitbreiden en volg ik privé een cursus Claude Code. Waarom ik dat allemaal doe? Om eerlijk te zijn: het is nauwelijks omdat mijn werkgever dat wil. Maar waarom wil ik dit dan vrijwillig doen?


CV verbetering

Ik zie het als mijn eigen verantwoordelijkheid om ervoor te zorgen dat mijn CV geschikt is voor heden en toekomst. Niet alleen voor mijn huidige werkgever en de daarbij horende opdrachten, maar ook voor toekomstige werkgevers.

Ik heb flink wat eigen tijd en geld gestopt in het verbeteren van mijn CV. Zodat de gevraagde certificaten erop staan.  En ook dat er certificaten opstaan, die mij misschien net dat extra pluspuntje kunnen geven ten opzichte van anderen. Dat geeft mij nu meer zekerheid op opdrachten, maar ook op langere termijn meer kans op baanbehoud en het wisselen van baan.

Ik heb te vaak mensen om mij heen gezien die qua kennis achter waren gebleven, hierdoor vast kwamen te zitten op een werkplek waar ze het niet meer naar hun zin hadden, of zelfs hun baan kwijtraakten en daarna niet meer aansloten op de markt. Ik weet dat ik dit niet altijd kan voorkomen, maar ik wil er zeker wel mijn best voor doen.

Eigen opinie vormen

Maar er is nog een belangrijke reden waarom ik graag mijn kennis uitbreid. De ICT staat niet stil. Er komen constant nieuwe methoden, technieken en tools bij. En regelmatig komen er bij mij vragen op als ik mensen over deze nieuwe zaken hoor praten. Is dit werkelijk hoe deze methode in elkaar steekt? Kan dit werkelijk niet met deze nieuwe tool? Ik ben niet een persoon, die iemand zomaar op zijn of haar woord wil geloven. Maar zonder eigen kennis ga ik ook niet zomaar ergens tegenin.

Daarom vind ik het belangrijk om te blijven leren, als het gaat om nieuwe methodes en nieuwe ontwikkelingen. Maar ook als ik al langer bestaande methodes en tools tegenkom, die ik zelf nog niet eerder heb toegepast, leer ik hier graag meer van. Vaak kom ik er inderdaad achter dat een tool meer kan. Maar ook dat een methode niet op deze wijze uitgevoerd hoort te worden. Het heeft ook een extra voordeel: als je met een certificaat of cursus kan aantonen dat je officiële kennis hebt, is het ook eerder mogelijk hier iets van te zeggen.

Uitdaging zoeken

De laatste reden om te leren is de meest persoonlijke. Ik word graag uitgedaagd en hou ervan om nieuwe dingen te leren en tools uit te proberen. En ik kan niet verwachten dat ik deze uitdaging altijd binnen mijn werk kan vinden. Daarom daag ik mijzelf ook buiten mijn werk graag uit, zoals nu met het leren van Claude Code.

Maar dit is zeker niet altijd 100% werkgerelateerd. AI is op dit moment hét gebied waar de uitdagingen liggen. Daarom heb ik me bijvoorbeeld al verdiept in het maken van AI-muziek, naast natuurlijk AI-afbeeldingen.

En jij als lezer?

Ik merk dat er een groep mensen is, die leren soms als verplichting ziet. En voor een deel is dat zeker het geval. Maar het gaat er mij meer om dat, zelfs als je het als verplichting ziet, je dit nog steeds niet doet voor je werkgever. Een detacheerder heeft misschien belang bij een goed CV, maar jijzelf ook.

En het gaat niet alleen om de certificaten. Maar ook om dat je mee kan praten over de onderwerpen, die rond je werk spelen. Ook als het niet direct over testen gaat. Basiskennis hebben van methodes, al of niet rond testen, zorgt ervoor dat je beter in staat bent je testen hierop te laten aansluiten. Of algemeen kan helpen de kwaliteit van het proces te verbeteren. Zo kan je als tester niet alleen wijzen op fouten in de code, maar ook op fouten in de gevolgde methode. Omdat je weet wat de officiële regels zijn én wat de officiële bedoeling van deze regels is.

En als je, net als ik, ook nog manieren gaat vinden waardoor je het soms ook nog leuk vindt, is er helemaal niets meer wat je tegenhoudt.