Escaping the Quicksand: A Call to Arms

Stel je een wereld voor waarin de onzichtbare machinerie van het moderne leven — onze banken, ziekenhuizen, elektriciteitsnetten en communicatienetwerken — is gebouwd op een fundament dat langzaam wegzakt. Dit is de realiteit waar de computerindustrie vandaag de dag voor staat. Decennialang was de standaardmanier om software te bouwen het schrijven van een ruwe beschrijving van wat een programma moet doen, dan het schrijven van de code, en het vervolgens testen door het uit te voeren met diverse inputs om te zien of het kapot gaat. Deze methode, bekend als test-en-debug-ontwikkeling, heeft technologie laten bloeien, maar laat systemen vol zitten met verborgen gebreken. Omdat de oorspronkelijke beschrijvingen vaak vaag zijn en in gewone taal zijn geschreven, kunnen ze niet door machines worden gecontroleerd, en omdat testen slechts een fractie van de miljarden mogelijke manieren kan dekken waarop een programma zich kan gedragen, glippen veel fouten erdoorheen. Nu kunstmatige intelligentie meer code begint te schrijven, dreigt deze cyclus dit te versnellen, waardoor er enorme nieuwe systemen ontstaan die nog complexer en fragieler zijn dan voorheen, gebouwd op een "quicksand" van decennia-oude ontwerpkeuzes die werden gemaakt toen cyberaanvallen zeldzaam waren en rekenkracht schaars was.

Twee onderzoekers, Peter Sewell van de Universiteit van Cambridge en Jean Pichon-Pharabod van de Universiteit van Aarhus, betogen dat de industrie al vijfenzeventig jaar in een gevaarlijke lus zit. Zij observeren dat, hoewel we ongelooflijk vaardig zijn geworden in het schrijven van code, we de precieze definities van wat die code precies moet bereiken, hebben verwaarloosd. De huidige aanpak vertrouwt op proza-specificaties — paragrafen tekst die het gedrag van een systeem beschrijven. Hoewel deze gemakkelijk leesbaar zijn voor mensen, zijn ze inherent ambigu en incompleet. Een menselijke lezer kan een zin op de ene manier interpreteren, terwijl een machine of een andere mens het anders interpreteert. Omdat deze beschrijvingen niet direct door een computer getest kunnen worden, worden ontwikkelaars gedwongen te gissen naar het juiste gedrag, waarbij ze vaak terugvallen op eenvoudige controles zoals "crasht het programma?" in plaats van te verifiëren of het programma daadwerkelijk het juiste doet. Deze kloof tussen de geschreven intentie en de feitelijke code creëert een enorme hoeveelheid technische schuld, een verborgen kostenpost die zich manifesteert als beveiligingskwetsbaarheden en systeemfouten die door aanvallers kunnen worden geëxploiteerd.

De auteurs stellen dat de oplossing niet is om testen op te geven, maar om de manier waarop we specificaties gebruiken te veranderen. In plaats van vage paragrafen voorstellen zij het creëren van specificaties die uitvoerbaar zijn, wat betekent dat ze in een vorm worden geschreven die een computer kan uitvoeren. Stel je een specificatie voor die fungeert als een levende scheidsrechter tijdens het ontwikkelproces. Terwijl code wordt geschreven of gegenereerd, draait deze uitvoerbare specificatie er direct naast, waarbij direct wordt gecontroleerd of het gedrag van de code overeenkomt met de beoogde regels. Als de code iets probeert te doen wat de specificatie verbiedt, signaleert het systeem dit onmiddellijk. Dit creëert een veel nauwere feedbackloop, waardoor ontwikkelaars fouten kunnen ontdekken terwijl ze gebeuren, in plaats dan weken later. Deze aanpak kan op verschillende manieren worden toegepast: men kan beginnen met de code en een specificatie schrijven die erbij past, beginnen met een specificatie en code genereren die eraan voldoet, of beide samen opbouwen. Het kernpunt is dat de specificatie niet alleen een document is om te lezen, maar een hulpmiddel om te gebruiken.

De onderzoekers erkennen echter dat dit geen eenvoudige schakelaar is om om te zetten. Om dit op grote schaal werkend te krijgen, moet de computergemeenschap een nieuwe laag infrastructuur opbouwen. Momenteel zijn er geen universeel geaccepteerde, machineleesbare definities voor het gedrag van veel fundamentele technologieën, zoals de programmeertaal C, de taal Rust, of de instructies die op computerchips draaien. Hoewel sommige onderzoekers erin zijn geslaagd deze definities voor specifieke delen van het systeem te creëren, is er geen verenigd kader dat ze allemaal met elkaar verbindt. De auteurs wijzen erop dat het bouwen van deze infrastructuur een uitdaging is van schaal en samenwerking. Het vereist een massale, gecoördineerde inspanning van universiteiten, overheden en technologiebedrijven om deze precieze definities te creëren, te valideren en te onderhouden voor de gehele stack van computertechnologie, van de hardware tot de clouddiensten.

Het artikel behandelt ook de rol van kunstmatige intelligentie. De auteurs waarschuwen dat het simpelweg gebruiken van AI om meer code te schrijven zonder deze betere feedbackloops, het probleem alleen maar zal verergeren. AI kan code sneller genereren dan mensen, maar als die code gebouwd is op wankele fundamenten en alleen getest wordt met de oude, ineffectieve methoden, zal het simpelweg grotere systemen creëren met meer verborgen fouten. Omgekeerd, als AI wordt gebruikt om te helpen bij het genereren en controleren van deze uitvoerbare specificaties, kan het een krachtig hulpmiddel worden voor het verbeteren van de softwarekwaliteit. De auteurs voorzien een toekomst waarin AI helpt bij het creëren van rigoureuze specificaties, en waar die specificaties worden gebruikt om te verifiëren dat zowel door mensen geschreven als door AI gegenereerde code correct is. Dit zou een geleidelijke toename van vertrouwen mogelijk maken, beginnend bij eenvoudige tests en bewegend naar complexere wiskundige bewijzen van juistheid, zonder dat elke ontwikkelaar een wiskundige hoeft te worden.

Ondanks het duidelijke pad vooruit, betogen de auteurs dat de industrie wordt tegengehouden door een mismatch in prikkels. Technologiebedrijven zijn gemotiveerd om producten snel uit te brengen om marktaandeel te veroveren, terwijl de risico's van falen grotendeels bij de samenleving en de eindgebruikers liggen. Het bouwen van de robuuste infrastructuur die nodig is om deze fouten te voorkomen, is duur en tijdrovend, en geen enkel bedrijf wil de volledige kosten dragen voor het oplossen van problemen die iedereen aangaan. De onderzoekers pleiten voor een collectieve inspanning, vergelijkbaar met de grootschalige projecten in de natuurkunde of biologie, om de creatie van deze semantische infrastructuur te financieren en te coördineren. Zij suggereren dat, hoewel de kosten aanzienlijk zijn, het een fractie is van de huidige uitgaven aan kunstmatige intelligentie en essentieel is voor de beveiliging van de toekomst van computing. Zonder deze verschuiving blijft de industrie gevangen in een cyclus van het bouwen van steeds complexere systemen op fundamenten die te zwak zijn om hen te ondersteunen, wat de samenleving kwetsbaar maakt voor constant risico.

De auteurs concluderen dat de instrumenten en methoden om dit probleem op te lossen al bestaan. Onderzoekers hebben succesvol aangetoond hoe men het gedrag van complexe systemen kan definiëren en verifiëren met een hoge mate van zekerheid. Wat ontbreekt is de wil om deze methoden in de dagelijkse praktijk te brengen en de gedeelde infrastructuur te bouwen die ze voor iedereen toegankelijk maakt. Het artikel dient als een oproep tot actie voor de onderzoeksgemeenschap, industriele leiders en financieringsinstanties om samen te werken aan deze taak. Door weg te bewegen van vage beschrijvingen en toe te bewegen naar precieze, uitvoerbare specificaties, kan de computerwereld ontsnappen aan de quicksand van technische schuld en een toekomst bouwen die niet alleen innovatiever is, maar ook fundamenteel veiliger en betrouwbaarder.