Het verband tussen fout en faalkans

We gebruiken de termen wel eens door elkaar
maar fouten en falen zijn twee wezenlijk
verschillende dingen.  Als er een fout in een
systeem zit wil dat nog niet zeggen dat die
zich ook manifesteert door faalgedrag.  Een
systeem kan ondanks een foutje toch heel
betrouwbaar zijn.

Neem het voorbeeld van de eensgezinswoning.
Die wordt gemiddeld met een twintigtal fouten
opgeleverd.  Ondanks die gebreken kan er
prima in te wonen zijn.  Hooguit moeten die
fouten nog moeten worden aangepakt.
Als het aantal fouten dat aangetroffen wordt
echter drie keer zo hoog is, dan is dat een
sterke indicator dat het huis niet goed gebouwd
is, en dat er niet goed in te wonen valt.

Ergo, er is een verband tussen het aantal
fouten dat in een systeem huist en het faalgedrag
van datzelfde systeem.  De betrouwbaarheid van
een systeem moet zich bewijzen door de jaren
heen.  Als je met een operationeel systeem
nooit in de krant komt dan is de kans zeer
groot dat er niet al te veel fouten inzitten.
Omgekeerd, als een systeemcomplex keer op keer
hapert tijdens de operatie, is de kans aanzienlijk
dat het systeem bol staat van de fouten.

Hoeveel fouten worden er eigenlijk opgeleverd
bij het gemiddelde IT-systeem?  Daar zijn
industriegemiddelden voor.  Een vuistregel is
dat je moet denken aan zo'n 5 fouten per
functiepunt die gemaakt worden tijdens de
ontwikkeling van een systeem.  Dus bij duizend
functiepunten (een systeem in de orde van de
honderduizend regels code) moet je denken aan
vijfduizend fouten.  Dat zijn fouten in het
pakket van eisen, in het ontwerp, in de code,
in de documentatie, en het verkeerd repareren
van reeds geconstateerde fouten.

Door toetsen en testen vissen we gemiddeld
85% van die vijfduizend fouten uit het systeem
voordat het in productie gaat.  Dus je levert
dan driekwart fout per functiepunt op, wat
neerkomt op 750 fouten verdeeld over de net
genoemde vijf categorieen.

Is dat erg?  Die fouten hoeven zich namelijk
helemaal niet te manifesteren.  Echter, net
zoals het huis met teveel fouten heb je ook
correlaties tussen fout en faalkans in de IT
wereld.  Dat gaat ongeveer als volgt.  Als je
het aantal fouten weet bij oplevering en hoelang
is getest onder gelijkblijvende omstandigheden,
dan kun je de ordegroote van de faalkans
afschatten.

We nemen ons voorbeeldsysteem van 1000
functiepunten, met daarin de 750 opgeleverde
fouten.  Stel dat systeem is 2 jaar zonder al
te veel problemen operationeel.  Voorts nemen
we aan dat een fout die falen heeft veroorzaakt
meteen bij het eerste falen wordt opgelost.
We willen alleen ernstig falen in kaart brengen.
Daarom nemen we van al die 750 fouten een klein
percentage.  De gevaarlijke fouten in een
systeem die het echt tot een halt roepen vormen
gemiddeld twee procent van alle fouten.  Dus
in ons hypotetische voorbeeld zijn dat er 15.

Om nu de ordegrootte van de worst-case faalkans
als gevolg van die grove fouten te
berekenen gebruiken we een formule van Bishop
en Bloomfield.  Die faalkans zit volgens hun
formule tussen de twee en twintig keer per
jaar.  Als dat systeem nu niet twee jaar maar
tien jaar ``getest'' is, oftewel zonder al te veel
problemen tien jaar draait dan neemt de faalkans
af.  Betrouwbaarheid is een proces dat
met de jaren komt bij software.  De formule
voorspelt dan tussen de 0.4 en 4 keer compleet
falen per jaar.

Wat we hier dus zien is dat als je goed zorgt
voor je bestaande systemen, en daar elke keer
de fouten die er altijd inzitten meteen uithaalt
dat je dan na jaren draaien meer en meer beloond
wordt met een steeds betrouwbaarder systeem.
Dat is niet zo gek, en daar heb je eigenlijk geen
formule voor nodig om het te begrijpen.

Toch is het aardig dat je over faalkansen van
software middels dergelijke wiskundig afgeleide
en empirisch gevalideerde correlaties al heel
redelijke uitspraken kunt doen.  De hele crux
van de betrouwbaarheid van software zit hem
dus vooral in een zo goed mogelijke start maken
door zo min mogelijk fouten op te leveren, en
die dan door de jaren heen zo veel mogelijk te
verwijderen.

Over de jaren heen zal de gebruikersinterface
verouderen, dat is een nadeel.  Maar het voordeel
van betrouwbaarheid weegt vaak zwaarder dan
opnieuw beginnen.  Immers,  dan moet je de
betrouwbaarheid ook weer van de grond af
opbouwen.

X

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

Prof. dr Chris Verhoef is hoogleraar informatica
aan de Vrije Universiteit in Amsterdam en
wetenschappelijk adviseur voor overheid en
bedrijfsleven.  Hij schrijft regelmatig een
column in AG II.  Hij is te bereiken via email:
x@cs.vu.nl.  Deze tekst is copyright SDU.  Niets
van deze uitgave mag zonder schriftelijke
toestemming van de uitgever worden overgenomen of
worden gepubliceerd.