Leven op een softwarevulkaan

16 december 1999
De kwaliteit van software is verbijsterend, zegt prof. dr. Paul Klint. Toch kunnen
we overleven op een softwarevulkaan vol fouten. Softwarefouten zijn fataal voor individuele programma’s maar niet
voor software als soort. Klint pleit voor softwareontwikkeling als evolutionair proces,
met als toekomstperspectief de softwarekwekerij.


Paul Klint
Voorspellingen rond de vorige eeuwovergang hebben belangrijke uitvindingen zoals de kernbom, de transistor of het Internet niet kunnen voorzien en er is geen reden om aan te nemen dat voorspellingen over de komende eeuw betrouwbaarder zullen zijn. Toch wil ik me aan enige bespiegelingen wagen over de vraag hoe wij in de toekomst software zullen ontwikkelen en onderhouden.
Het woord software suggereert dat programmatuur ’soft’ en dus veranderbaar is, maar het tegendeel is het geval. Legacy-systemen blijken van hoogwaardig beton. Ook bij de overgang van maatwerk naar pakketsoftware (bijvoorbeeld ERP) is de gewenste flexibiliteit niet bereikt: de organisatie is nu overgeleverd aan de werkstromen en procedures van het ERP-pakket die nauwelijks gewijzigd kunnen worden.
Ook de hoeveelheid en kwaliteit van software zijn verbijsterend (zie: A. van Deursen, P. Klint en C. Verhoef, Research issues in
the renovation of legacy systems, in Proceedings of Fundamental Approaches to Software Engineering (Fase), Springer LNCS 1577, pp. 1--21, 1999):
• De hoeveelheid software wereldwijd bedraagt ongeveer 7 x 109 functiepunten
(7 giga-FP). Dit correspondeert ruwweg met 650 giga-regels Cobol-code of 900 giga-regels C.
• Deze software bevat naar schatting 35 x 109 fouten.
Hoe kunnen we leven met deze inflexibele softwarevulkaan vol fouten? Een analogie met de biologie kan ons hierbij enig inzicht verschaffen.
Als we de effecten van opvoeding buiten beschouwing laten dan bepaalt de structuur van ons DNA ieder menselijk individu volledig. Toch bevat het DNA van de meeste mensen fouten. Deze fouten kunnen levenslang onopgemerkt blijven maar ze kunnen ook dodelijke gevolgen hebben. DNA-fouten bedreigen wel het individu maar niet de soort. Naar analogie kunnen we constateren dat softwarefouten fataal kunnen zijn voor individuele programma’s maar niet voor software als soort.
Het gezichtspunt dat ik nu verder wil ontwikkelen is dat softwareontwikkeling gezien moet worden als een evolutionair proces waarin programma’s ontstaan, geleidelijk worden verbeterd en tenslotte worden afgeschaft. De analogie met de biologie kan ons hierbij inspireren.
Evolutionaire principes zijn vanuit twee invalshoeken op software toe te passen: als beschrijvingsmechanisme voor de levenscyclus van bestaande software en als methode om nieuwe software te maken. Beide invalshoeken komen nu eerst kort aan de orde. Daarna volgen enkele speculaties over de (on)mogelijkheden van een softwarekwekerij.

Drie wetten
Om te beginnen de evolutie van bestaande software. Belady en Lehman hebben al geruime tijd geleden onderkend dat softwareontwikkeling een evolutionair proces is (zie: L.A. Belady en M.M. Lehman, A model for large program development, IBM Systems Journal, Vol. 15, No. 1, 1976, p 225-252). Zij hebben hun waarnemingen vastgelegd in drie wetten:
• De wet van voortdurende verandering:
een systeem dat wordt gebruikt onder-
gaat voortdurende veranderingen totdat
besloten wordt dat het goedkoper is het systeem te bevriezen en te vervangen.
• De wet van de toenemende entropie: de entropie van een systeem (de mate van ongestructureerdheid) neemt toe naarmate de tijd verstrijkt, tenzij expliciete maatregelen worden getroffen om de entropie te reduceren.
• De wet van de statistisch vlakke groei: waarnemingen van systeemgroei mogen lokaal gezien willekeurig lijken in tijd en ruimte, maar statistisch gezien betreft het cyclische, zelfregulerende, processen met goed gedefinieerde langetermijntrends.
Over de evolutionaire aspecten van softwareontwikkeling is nog meer te zeggen (zie: P. Klint en C. Verhoef, Evolutionary Software Engineering with Components, in Proceedings Systems Implementation 2000, Chapman & Hall, pp. 1--18, 1998).
Ten eerste bevinden verschillende delen van een systeem zich meestal in verschillende fasen van ontwikkeling, daarom is de naadloze integratie van methodes voor nieuwbouw, onderhoud en renovatie van groot belang. Het kunnen samenstellen van systemen uitgaande van bestaande componenten is ook essentieel om hergebruik te ondersteunen.
Ten tweede is de ontwikkeling van software te ingewikkeld geworden om nog op een hiërarchische, top down, wijze te kunnen controleren. Meer evolutionaire principes lijken daarvoor meer geschikt te zijn.
Ten slotte is het al lang bekend dat ’peer review’ een van de beste methodes is om software te verbeteren. De recente populariteit van het open source-model benadrukt dit nog eens. Het oude adagium ’Use the force, read the source’ wordt hiermee weer zeer actueel: peer review speelt immers de rol van selectie- en verbeteringsmechanisme tijdens de evolutie van software.
Open source speelt nog een tweede rol in het evolutieproces. De beste programmeurs kopiëren en hergebruiken code waar dit maar mogelijk is. Hierdoor ontstaan klonen van algemeen beschikbare broncode.

Fitte ouders
Ten tweede de evolutie van nieuwe software. Uit het werk van onder anderen John Koza is bekend dat evolutionaire, darwinistische, principes ook letterlijk gebruikt kunnen worden om software te kweken (zie: J. Koza, Genetic Programming: On the Programming of Computers by Means of Natural Selection, The MIT Press, 1992). Uitgaande van een beginpopulatie van willekeurige programma’s worden steeds de ’beste’ programma’s gekozen voor voortplanting om zo na een aantal generaties te komen tot gekweekte programma’s die een gegeven taak zo goed mogelijk uitvoeren. Hierbij spelen enkele begrippen een rol die allereerst toelichting verdienen.
De ’zoekruimte’ waarin de evolutie plaatsvindt omvat alle individuele programma’s die ooit kunnen ontstaan. In ieder probleemgebied wordt van tevoren bepaald welke primitieven in een programma voor mogen komen zoals bijvoorbeeld rekenkundige bewerkingen, bewegingen van een robotarm of zetten in spel.
De ’initiële structuren’ waarmee het evolutieproces start bestaan uit een willekeurig aantal, willekeurig gekozen, programma’s. Een ’fitnessfunctie’ bepaalt hoe goed een individueel programma erin slaagt om een gegeven probleem op te lossen. Volgens het principe van de ’survival of the fittest’ zullen uiteindelijk die individuen of hun nakomelingen (programma’s) overblijven die het probleem het beste oplossen.
’Sexuele reproductie’ vindt plaats door eerst een paar ’fitte’ ouders (twee programma’s, beide met een hoge fitness-score) te selecteren en deze een nakomeling te laten produceren door de compositie van delen van beide ouders. Het resulterende kind (weer een programma) wordt toegevoegd aan de volgende generatie en neemt daarin weer deel aan fitnessbepaling en reproductie.
Het kweken van een programma is nu bijvoorbeeld toe te passen om uitgaande van een klein aantal waarden van een functie f, de functie zelf te vinden. Gegeven zijn bijvoorbeeld de waarden f(1),..., f(10) en de vraag is om een programma te kweken dat
f zo goed mogelijk berekent. De eerste generatie programma’s bestaat uit willekeurige programma’s opgebouwd uit willekeurige, rekenkundige, operaties. De fitness van een programma wordt bepaald door de mate waarin het voor de input-waarden 1 ,..., 10 de waarden f(1),..., f(10) goed berekent. Na enkele tientallen tot honderden generaties zal blijken dat er programma’s ontstaan die de waarden van f aardig, maar misschien niet perfect, benaderen.
Het blijkt dat deze methode van genetisch programmeren vooral goed toe te passen is om problemen op te lossen waarvoor geen eenvoudige analytische oplossing bestaat, zoals het modelleren van de beurskoersen of gebruikersgedrag, het oplossen van plannings- en zoekproblemen en patroonherkenning. De opgeleverde programma’s hebben echter een puur functioneel gedrag, dat wil zeggen ze leveren voor gegeven invoerwaarden een antwoord, maar ze zijn niet in staat om neveneffecten te veroorzaken zoals het opslaan van waarden in een bestand of het fysiek besturen van een apparaat. Dit maakt het voorlopig nog niet mogelijk om ’echte’ programma’s te kweken die bijvoorbeeld de administratie van een bedrijf uitvoeren of een fabriek besturen.

Kwekerij
Een softwarekwekerij zoals zojuist beschreven is nog niet in zicht, maar ik verwacht wel dat deze principes in de komende jaren verder ontwikkeld en toegepast zullen worden. We kunnen de analogie op een aantal punten nog verder uitwerken.
Bij het kweken van dieren en planten gaat men uit van gegeven genetisch materiaal dat wordt verbeterd en vermenigvuldigd. Bestaand genetisch materiaal bevat een grote diversiteit die het resultaat is van
een zeer lange evolutie. Dit is de reden dat de farmaceutische industrie de tropische regenwouden afstroopt – zolang het nog kan – op zoek naar planten met medicinale eigenschappen. Het genetisch materiaal is opgebouwd uit slechts vier nucleïnezuren die tot lange strengen aaneengeregen zijn.
Identificeerbare eigenschappen van individuele planten of dieren liggen vast in genen, op zich reeksen nucleïnezuren. Om te komen tot een op evolutionaire principes gebaseerde softwarekwekerij moeten velerlei vragen worden beantwoord.
Wat zijn de nucleïnezuren van de software? Het spectrum van mogelijkheden omvat (geordend naar toenemende complexiteit): (1) een laagniveau instructie die direct door een computer uitgevoerd kan worden (bijvoorbeeld het plaatsen van een waarde in een register); (2) een statement uit een programmeertaal (bijvoorbeeld een toekenningsstatement, een conditioneel statement of een herhalingsconstructie); (3) een procedure uit een programmeertaal (die zelf weer een aantal statements bevat); (4) een module uit een programmeertaal (die zelf weer een aantal procedures bevat); (5) een compleet programma (dat zelf weer een aantal modules bevat); (6) een compleet systeem (dat zelf weer een aantal programma’s bevat).
Hoe kunnen deze softwarenucleïnezuren gecombineerd worden? In de natuur worden nucleïnezuren gecombineerd door ze in een lineaire structuur (streng) aan elkaar te plakken. In software bestaan er, naast het achter elkaar plakken van elementen, nog diverse andere compositiemechanismen: procedure-aanroepen, importeren van modulen en coördinatietalen voor de dynamische, op workflow-principes gebaseerde, koppeling van componenten. Welke bestaande, of nieuw te ontwikkelen, compositiemechanismen zijn het meest geschikt voor software-evolutie?
Welke ’softwaregenen’ komen in bestaande programma’s voor en kunnen dienen als uitgangspunt voor een softwarekwekerij? Genen bepalen één specifiek deelaspect van een organisme (kleur van de ogen, lichaamsbouw et cetera). Combinaties van genen bepalen complete functionele delen van een organisme (bijvoorbeeld de ogen). De momenteel gebruikte softwarecomponenten bevatten de complete functionaliteit van een onderdeel van een systeem (bijvoorbeeld het verwerken van de datum, conversie van valuta, opzoeken van een naam in een tabel). Op deze manier beschouwd zijn de huidige softwarecomponenten vaak groter dan softwaregenen en zijn ze daardoor vermoedelijk te groot om als basis te dienen voor een softwarekwekerij.
Een belangrijk aspect van de huidige softwarecomponenten is ’abstractie’: aan de buitenkant van een component is alleen zijn extern gedrag waar te nemen terwijl zijn interne structuur verborgen blijft. Bij evolutionaire processen kunnen echter ook mutaties optreden in genen, waardoor er een wijziging ontstaat in hun interne structuur. Dit druist helemaal in tegen de principes van functionele decompositie en het verbergen van de implementatie van componenten.
Ten slotte speelt taal een cruciale rol bij
het vastleggen van softwaregenen. Maar welke taal? Het lijkt duidelijk dat hier een programmeertaal-neutrale benadering gewenst is die in elk geval abstraheert van de verschillende programmeertalen waarin gekweekte software uiteindelijk vastgelegd zal moeten worden voor gebruik.
Er resteren nog veel andere vragen, bijvoorbeeld over de eigendomsrechten van gekweekte software, de mogelijkheden tot het patenteren van softwaregenen en de aard en omvang van de waardeketens in dit nieuwe model.

Levend organisme
We kunnen de evolutionaire aspecten van bestaande software en de evolutionaire methodes voor het kweken van nieuwe software integreren tot een nieuwe visie op software als levend organisme. Nieuwbouw komt dan overeen met het kweken van nieuwe software, terwijl onderhoud en renovatie overeenkomen met chirurgische ingrepen in bestaande software, die daarna opgekweekt moet worden tot een weer bevredigend werkend exemplaar. Principes van zelfregulatie en -herstel zullen daarbij van groot belang zijn.
Zoals al aangegeven bieden softwarecomponenten en coördinatiemechanismen voor het koppelen van deze componenten al een allereerste aanzet tot het evolutionaire ontwikkelingsproces. De volledige realisatie van een softwarekwekerij ligt nog vele jaren voor ons. De vele vragen van technische, juridische en economische aard die deze visie oproept, kunnen echter stimuleren tot het verkrijgen van een beter inzicht in de bouw en beheersing van complexe softwaresystemen. De softwarevulkaan waarop wij leven zal in het nieuwe millennium immers op de een of andere manier bedwongen moeten worden.

Prof. dr. P. Klint is als themaleider verbonden aan het Centrum voor Wiskunde en Informatica (CWI). Bovendien is hij hoogleraar Informatica aan de Universiteit van Amsterdam.
 
Lees het hele artikel
Je kunt dit artikel lezen nadat je bent ingelogd. Ben je nieuw bij AG Connect, registreer je dan gratis!

Inloggen

Registreren

  • Direct toegang tot AGConnect.nl
  • Dagelijks een AGConnect nieuwsbrief
  • 30 dagen onbeperkte toegang tot AGConnect.nl

Ben je abonnee, maar heb je nog geen account? Laat de klantenservice je terugbellen!