Leven op een softwarevulkaan

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 programmas maar niet voor software als
soort. Klint pleit voor softwareontwikkeling als evolutionair
proces, met als toekomstperspectief de softwarekwekerij.

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
programmas 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 programmas 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 hirarchische, 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 kopiren 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 programmas
worden steeds de beste programmas gekozen voor voortplanting
om zo na een aantal generaties te komen tot gekweekte
programmas 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 programmas 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 initile structuren waarmee het evolutieproces start
bestaan uit een willekeurig aantal, willekeurig gekozen,
programmas. 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 (programmas) overblijven die het probleem
het beste oplossen.

Sexuele reproductie vindt plaats door eerst een paar
fitte ouders (twee programmas, 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 programmas bestaat uit willekeurige
programmas 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
programmas 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 programmas 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 programmas 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
nuclenezuren die tot lange strengen aaneengeregen zijn.

Identificeerbare eigenschappen van individuele planten
of dieren liggen vast in genen, op zich reeksen nuclenezuren.
Om te komen tot een op evolutionaire principes gebaseerde
softwarekwekerij moeten velerlei vragen worden beantwoord.

Wat zijn de nuclenezuren 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 programmas
bevat).

Hoe kunnen deze softwarenuclenezuren gecombineerd worden?
In de natuur worden nuclenezuren 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 cordinatietalen
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 programmas voor
en kunnen dienen als uitgangspunt voor een softwarekwekerij?
Genen bepalen een 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
cordinatiemechanismen 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.

Weekblad 1999, week 50

Meer weten over de wondere wereld van ICT 
in Jip en Janneke taal? Ga dan naar de
knipselkrant van Chris Verhoef

Deze tekst is copyright SDU.  Niets van deze uitgave
mag zonder schriftelijke toestemming van de uitgever
worden overgenomen of worden gepubliceerd.