Tussen behoud en dinosauriërs: de balanceeract voor stabiliteit

Het belangrijkste programma in jouw bedrijf of organisatie werkt al jaren goed. De applicatie sluit uitstekend aan op jouw bedrijfsprocessen en is ontzettend betrouwbaar. Kortom: de software zorgt voor stabiliteit en continuïteit in jouw organisatie. Als Happy Software People maakt het ons blij dat, ongeachte wie jouw software maakt, jij blij met jouw software bent. Maar zijn we niet naïef om te denken dat alles goed zit?

De wereld rondom bestaande software verandert constant. Misschien is de hardware inmiddels één of meerdere keren vernieuwd. Of draait jouw software niet meer op lokale PC's, maar wordt die binnen een (private) cloud gehost. En voor een efficiënt bedrijfsproces en het gemak van medewerkers, leveranciers en klanten zijn allerlei internetkoppelingen gemaakt waardoor de applicatie altijd online is.

De bovenstaande veranderingen hebben veel waarde voor zowel de organisatie als voor klanten en medewerkers. Helaas zijn er ook veel voorbeelden van bedrijven die niet de vruchten plukken. Die zich prikken aan de stekels van software die ‘in de dinotijd’ is blijven steken. Wij werken daarom aan stabiliteit. Stabiliteit in software is software die een sterke basis legt: de stabiele fundering.. Een basis om jouw processen nu te ondersteunen, maar juist ook in de toekomst.. Want als er één ding onzeker is, is het de toekomst. Om ruimte aan die toekomst te geven, bouwen wij software die aangepast kan worden. Zodat jij nieuwe kansen kan ontsluiten en de bijkomende risico’s verkleint.

Isla Nublar: Werkelijkheid ontmoet fictie

Hoe goed jouw software ook werkt, helaas moeten we je (en onszelf) een illusie armer maken. De werkelijkheid is meestal geen Bounty eiland met witte stranden en pina colada. De werkelijkheid is een regenachtige avond op het Caraïbisch eiland ‘Isla Nublar’. Een avond die jouw mooie vakantie ruïneert: het gaat niet alleen spoken, er is een tropische storm op komst! En op dit eiland staat een prehistorisch attractiepark dat, op een paar kleine testen na, klaar is voor de opening: Jurassic Park.

Nu denk je vast: “maar Jurassic Park is niet echt!” En wij antwoorden met: “dat klopt”. Toch laat Jurassic Park op allerlei manieren zien wat de waarde van stabiele software is. Zo was de software in het prehistorisch pretpark 1) niet te onderhouden door gebrek aan kwaliteitscontrole, 2) lag alle kennis bij één programmeur en werd deze niet gedeeld, en 3) was de software eenvoudig te ‘hacken’ door het ontbreken van scans, reviews en korte termijn denken. Voor het verhaal handig, want een slimme tiener kon zich een weg door de slechte software banen, het pretpark opnieuw opstarten en zo de bezoekers redden.

Jurassic Park mag dan fictie zijn, de werkelijkheid ligt dichter tegen de fictie aan dan je denkt. Directeur John Hammond dacht dat software zijn pretpark kon draaien en de gevaarlijke dino’s in bedwang kon houden. In zekere zin dachten organisaties als ROC Mondriaan en Universiteit Maastricht dat ook. Of Albert Heijn waar kaasschappen leeg bleven doordat een leverancier geen kaas kon leveren. Wat vooral zorgwekkend is, deze drie voorbeelden zijn maar een heel klein overzicht van ransomware incidenten in een wereld gevuld met andere (cyber) dreigingen.

Schakels om dino’s buiten de deur te houden

Of het nu een dinopark, een dierentuin of een pretpark is, zou jij een attractie in stappen als je weet dat die slecht onderhouden is? Waarschijnlijk niet, de meeste mensen vinden de risico’s te groot. Een ongeluk zit in een klein hoekje. Of er nu dino’s in een fictief themapark ontsnappen, of een karretje los komt in een achtbaan, beide voorbeelden laten zien wat het belang is van een veilige basis waarop je kan bouwen: stabiliteit in jouw processen.

In de software hebben we het vaak over betrouwbaarheid en stabiliteit. Twee woorden die veel op elkaar lijken en elkaar aanvullen. Maar waar betrouwbaarheid ervoor zorgt dat iets werkt, zorgt stabiliteit er juist voor dat het blijft werken. Dat jouw software toekomstzeker is. Helaas is het vaak niet bekend dat je software, net als een pretpark, moet onderhouden zodat jouw stabiele basis stabiel blijft. Software die jaren betrouwbaar draait, is meer dan software die nu goed werkt. Stabiele software is in staat veranderingen op te vangen, nieuwe kansen te ontsluiten en de gevaren van losgebroken dino's buiten de deur te houden. Om die toekomstzekerheid te bereiken, is stabiele software als een ketting opgebouwd. Een ketting waarbij het einde van de ene schakel het begin van de volgende schakel is.

1) Onderhoudbaar

In Jurassic Park lag alle kennis bij één programmeur: Dennis Nedry. Dennis had er, laten we eerlijk zijn, een zooitje van gemaakt. Toegegeven, Dennis was in eentje aan zijn lot overgelaten. Maar als zijn chaotische werkplek een spiegel van zijn werk is, dan volgde Dennis geen duidelijke en breed gedragen standaarden. Om nog maar te zwijgen over het delen van kennis en het vastleggen van belangrijke beslissingen. Tenslotte, om zeker te zijn dat alle functionaliteiten werken zoals bedacht, had hij zijn code moeten testen met automatische analyses en reviews door collega’s. Vereisten die niet werden uitgevoerd en ervoor zorgen dat Jurassic Park niet door hedendaagse audits en software reviews zou komen. Maar wanneer de software van Jurassic Park onderhoudbaar was, dan hadden ontwikkelaars makkelijk een patch kunnen maken en fouten in het systeem kunnen repareren.

2) Updatebaar

Het nut van een onderhoudbaar programma komt naar voren wanneer het ook een updatebaar programma is. Wanneer een programma updatebaar is, dan kunnen patches en aanpassingen makkelijk gereleased en in gebruikt worden genomen. In Jurassic Park betekent dit dat de patch die de veiligheidssystemen in losse stukken opdeelt binnen een paar minuten ‘live’ kan. Er was misschien nog steeds een probleem, maar waarschijnlijk was alleen de T-rex ontsnapt terwijl de Raptors nog in hun kooi zaten. Samengevat zorgt onderhoudbaar ervoor dat programmeurs makkelijk verbeteringen kunnen maken. Updatebaar zorgt ervoor dat je die verbeteringen makkelijk in gebruik kan nemen met zo min mogelijk hinder voor gebruikers.

3) Aanpasbaar en uitbreidbaar

Tenslotte hebben we aanpasbaarheid en uitbreidbaarheid. Twee termen die één ding gemeen hebben: ze maken de toekomst mogelijk. Ze gaan niet om wat er nu nodig is (dat zou jouw programma al moeten doen), maar over wat je er in de toekomst mee wil. In ons dinopark zou je kunnen denken aan veiligheidsmaatregelen waardoor buitenstaanders de systemen niet in kunnen. Of nieuwe functionaliteiten die het voor bezoekers aantrekkelijker maken. Denk aan het toevoegen van een geautomatiseerde bootvaart, een functie die in het verlengde ligt van de beroemde (of beruchte) Jeep rondrit. Anderzijds kunnen functies zoals de internetverkoop van kaarten en merchandise totaal nieuwe paden openen. Hetzelfde geldt voor 'onze' wereld. Je hebt nu nog geen wensen, maar door aanpasbare software is het wel mogelijk om in de toekomst vragen op te vangen.

Toekomstvast: Kanaries tussen de dino's

Software gaat vaak lang mee. Veel langer dan verwacht tijdens de bouw. Op zich is dit een teken dat de software uitstekend werk verricht. Maar hoe ouder de software is, hoe groter de kans is dat je een vermomde dino hebt. Om een dino uitbraak, of meer realistisch een cyberaanval, niet langer werkende functies of crashes, te voorkomen is een kanarie nodig. En ja, dat is zo’n kanarie die vroeger in de mijn werd meegenomen om voor gevaarlijke gassen te waarschuwen. Onze kanarie bestaat uit zeven vragen die gezamenlijk de keten van stabiliteit afdekken:

1. Volgt de programmacode breed gedragen industriestandaarden?
2. Is er een 4-ogen-systeem waarmee andere programmeurs de kwaliteit beoordelen?
3. Wordt de programmacode automatisch op kwaliteit gescand?
4. Worden bekende veiligheidslekken automatisch gerapporteerd?
5. Zijn er testen die de werking van functionaliteiten garanderen?
6. Kunnen updates snel en eenvoudig (automatisch) uitgevoerd worden?
7. Is er een plan en budget om de software langere tijd te beheren?

Software mag oud als een dino worden

Dat software oud wordt mag volgens ons geen probleem zijn. Maar voor die stabiliteitmoet de programmacode de juiste fundering hebben . Zodat een nieuw teamlid heel snel begrijpt wat het programma doet en veteranen meteen aan de slag kunnen. Daarom moeten collega’s reviewen op logica en elkaar stimuleren om steeds betere code te maken. Daarna kan speciale tooling gebruikt worden om bekende (veiligheids)lekken op te sporen. En met geautomatiseerde code analyses wordt het gebruik van industriestandaarden gestimuleerd. Allemaal zodat er een basis waarop je verder kan bouwen.

Als de basis goed is, komt ons geloven in “testen, testen en testen” op de voorgrond. Niet alleen om zeker te zijn dat nieuwe functies goed werken. Maar vooral om zeker te zijn dat oudere functies blijven werken. Testen zijn de kanaries van software programmeurs. Door een programma in logische stukjes op te knippen, kan ieder onderdeel zo goed mogelijk getest worden. En een bijkomend voordeel is dat ieder stukje code een duidelijke focus heeft. Ofwel dat die goed begrijpbaar is en dat er, bijna als lego, nieuwe stukken of modules toegevoegd kunnen worden.

Al deze maatregelen sluiten aan op ons idee dat software oud mag worden. Ze zorgen er namelijk voor dat de keten van stabiliteit uitgebreid wordt. Want de drie punten van stabiliteit zorgen er uiteindelijk voor dat jouw software toekomstvast is en daarmee dat die voor lange tijd is. Misschien wel zo oud dat jouw software dino-oud wordt, maar door de kanaries geen last krijgt van de gevaarlijke dino kwalen.