Ga naar de inhoud

Podcast: Wat is Software Testing echt!

Podcast: Wat is Software Testing echt!

Wat is Software Testing?

Software testing. Iedereen heeft er wel al van gehoord, maar wat houdt het nu écht in? In de eerste aflevering van onze podcastreeks Back to Basics duiken we samen met experts Jürgen en Günther in de fundamenten van softwaretesting. Waarom is testen meer dan bugs vinden? Wat betekent kwaliteit eigenlijk? En waarom moeten testers zo vroeg mogelijk betrokken worden bij een project?

We zetten het voor je op een rijtje.

Waarom testen we software?

Een logische eerste vraag. Testen doe je natuurlijk om fouten op te sporen, maar dat is lang niet het volledige verhaal. Zoals Jürgen uitlegt: “Je gaat op zoek naar fouten in een applicatie, ja, maar je helpt de klant vooral om tot een betere kwaliteit te komen.”

Testen draait om het verbeteren van software, om de eindgebruiker een goede ervaring te geven. Soms betekent dat letterlijk bugs vinden en doorgeven. Maar vaak gaat het om veel meer dan dat: structuur aanbrengen, risico’s inschatten, processen begeleiden, meedenken over analyses en teststrategieën opstellen. Testers zijn dus niet alleen speurneuzen, maar ook adviseurs, kwaliteitsambassadeurs en bruggenbouwers tussen teams.

Bugs vinden = leuk! Maar niet alles wordt opgelost

Voor veel testers is het opsporen van bugs een soort sport. En geef ze eens ongelijk: het geeft voldoening als je iets vindt dat niet werkt zoals het zou moeten. Toch moet je als tester ook realistisch zijn. Niet elke fout wordt opgelost. Dat klinkt misschien tegenstrijdig, maar het is de realiteit van softwareontwikkeling.

Er wordt namelijk altijd afgewogen: hoe ernstig is de bug? Kan de gebruiker ermee leven? Is het esthetisch of functioneel? Hoeveel kost het om dit op te lossen? Soms is een workaround voldoende en wordt de bug gewoon gedocumenteerd. En dat is oké. Wat telt, is dat je als tester een duidelijk beeld schetst van de huidige kwaliteit en mogelijke risico’s.

Testers geven advies, geen garanties

Een ander belangrijk inzicht: testers beslissen niets, ze adviseren. Ze voeren testcases uit, analyseren de resultaten en delen hun bevindingen. Op basis daarvan beslist het team – of de klant – wat ermee gebeurt. En dat advies wordt sterker als je als tester niet alleen kijkt naar “werkt het of niet?”, maar ook naar context, gebruiksgemak en het grotere plaatje.

Zoals Günther het mooi verwoordt in de podcast: “Een goede test is een test die een fout naar boven brengt, zodat we erover kunnen praten.”

Kwaliteit = werkt het zoals de klant het wil?

Wat is eigenlijk “kwaliteit” in software? Volgens Jürgen is dat niet altijd wat jij als tester goed vindt, maar wat de klant vraagt. Zelfs als je denkt “dit kan beter”, moet je je afvragen: is dit wat de klant heeft gevraagd? Werkt het voor hen?

Testen betekent dus ook: jezelf in de huid van de gebruiker plaatsen. Begrijpen wat zij nodig hebben, hoe zij de software zullen gebruiken, en hoe de oplossing aansluit bij hun verwachtingen.

En tegelijk mag je als tester ook adviseren. Denk aan kleine verbeteringen die de gebruikservaring ten goede komen, zoals een zoekfunctie in een keuzelijst. Dat zijn zaken die de klant misschien niet gevraagd heeft, maar wel helpen om hun werk efficiënter te doen. Ook dát is kwaliteit.

Testen is meer dan klikken: het is een proces

Testing is niet iets dat je er snel “op het einde” even bijneemt. Het is een gestructureerd proces met drie grote onderdelen:

  1. Voorbereiding: hier worden de teststrategie en testscenario’s opgesteld. Wat testen we? Hoe testen we het? Wanneer is het voldoende getest?
  2. Uitvoering: hier voer je de testcases uit en verzamel je de resultaten. Bugs worden gelogd, ernst en impact worden beoordeeld.
  3. Rapportering: hier worden de bevindingen gedeeld met het team en de stakeholders. Je licht toe wat goed zit, waar nog werk aan is, en welke risico’s er zijn.

Deze structuur blijft al decennia hetzelfde, maar de invulling evolueert met de tijd en de context. Bij de ene klant zal de focus liggen op snelheid, bij de andere op volledigheid. En bij de ene organisatie ligt de lat op 80% dekking, bij een andere op 100%. Belangrijk is dat iedereen dezelfde verwachtingen heeft, en dat de testdoelen duidelijk zijn.

Testers ≠ ontwikkelaars (maar we werken samen)

Een vaak voorkomende verwarring: testers debuggen niet. Debugging is een taak van ontwikkelaars. Maar testers kunnen wél enorm helpen. Door duidelijke testcases aan te leveren, goed te documenteren wat ze deden, en samen met de ontwikkelaars de fout te analyseren, help je als tester om de oorzaak van het probleem sneller te vinden.

Het is een samenwerking: testers detecteren, ontwikkelaars analyseren en herstellen. En samen tillen ze de kwaliteit naar een hoger niveau.

Wanneer moet je beginnen met testen?

Het antwoord is simpel: zo vroeg mogelijk.

Idealiter start het testproces al bij de analysefase. Testers denken dan mee over de haalbaarheid, helpen bij het scherpstellen van acceptatiecriteria en zorgen ervoor dat er vanaf het begin kwaliteit in het proces zit. Dit noemen we ook wel shift left testing: testen verplaatsen naar het begin van de software lifecycle.

Toch zien we in de praktijk vaak het tegenovergestelde: testers komen pas op het einde aan bod. Het gevolg? Te weinig tijd, onduidelijke documentatie, én veel bugs op het laatste moment. Dat veroorzaakt stress, tijdsdruk en fouten.

Risicoanalyse: slim omgaan met tijd

Want eerlijk is eerlijk: je kunt niet alles testen. Er is altijd een deadline, er is altijd tijdsdruk. Daarom is een risicoanalyse zo belangrijk. Wat zijn de risico’s als we iets niét testen? Wat zijn de mogelijke gevolgen? Door dat vooraf te bekijken, kun je gerichter testen, en beter onderbouwde keuzes maken als de tijd krap is.

En dat helpt niet alleen bij testen zelf. Het zorgt ook voor meer bewustzijn bij het hele team over wat echt belangrijk is.

Agile? Dan moet testing mee evolueren

Bij Agile projecten wordt software in stukjes (sprints) opgeleverd. Ideaal om al tijdens het ontwikkelproces te testen. Maar dat lukt alleen als testing ook mee in die cadans zit. Testers moeten aanwezig zijn bij de sprintplanning, zodat ze weten wat eraan komt, wat getest moet worden en wat daarvoor nodig is (zoals testdata of specifieke testtools).

En het helpt als er op het einde van de cyclus een sprint is zonder nieuwe features – puur om te testen en te stabiliseren. Dat gebeurt niet altijd, maar het maakt een wereld van verschil.

Conclusie: testen is mensenwerk

Softwaretesting is veel meer dan foutjes zoeken. Het is een vakgebied waar samenwerking, communicatie en inzicht centraal staan. Het draait om kwaliteit, om risico’s beheersen, om processen verbeteren en om samen met klanten betere software maken.

De techniek en tools zijn belangrijk, maar uiteindelijk zijn het de mensen die het verschil maken.

Wil je meer weten over hoe softwaretesting jouw organisatie kan helpen om betere digitale producten af te leveren? Of ben je benieuwd hoe M2Q jou hierbij kan ondersteunen? Neem dan gerust contact met ons op via info@m2q.be – we denken graag met je mee!

Deze aflevering is niet alleen te beluisteren via onze website, maar ook via je favoriete podcastplatforms: Apple Podcasts en Spotify

 

 

https://www.buzzsprout.com/1887853/episodes/16980704

Gerelateerde blogs