Update: I translated this article into English.

Wat is er toch zo ingewikkeld, complex, onmenselijk aan software dat het haast niemand lukt het Gewoon Goed te krijgen. Bewijzen voor het feit dat software zuigt zijn er legio: virussen, spyware, bugs, crashes, updates, upgrades, versies, digibeten en onmogelijk te bedienen apparaten. Op de één of andere manier krijgen wij programmeurs het maar niet voor elkaar.

To Err Is Human”

De vraag is gaan rondwaren in mijn hoofd. En zoals dat vaker gaat (in mijn hoofd) ben ik gaan zoeken naar oorzaken. Wat is er inherent moeilijk of ingewikkeld aan software, of het maken ervan? Ik ben er nog niet helemaal uit, maar wel redelijk op weg. Bovendien ben ik gestuit op het boek, “The Design of Everyday Things” van Donald A. Norman, waar ik ben aangeland bij hoofdstuk 5: “To Err is Human”. En dat zou wel eens de kern kunnen zijn van het hele verhaal.

Computers (of in en bredere zin, technologie) vergissen zich niet. En mede daardoor kunnen ze er erg slecht tegen als iemand zich vergist in de interactie met een apparaat. Maar mensen, die vergissen zich wel. En vaak ook. In het schrijven van dit stukje heb ik meerdere malen de backspace en delete knop gebruikt, ik heb zitten klooien om die link hierboven goed te krijgen en minstens één zin heb ik in zijn geheel herschreven. En dat is nog maar in 15 regels.

Langzaam ben ik van mening geworden, dat mensen stomweg niet de hersenen hebben om Goede Software te schrijven, zoals we huizen kunnen bouwen, muziek kunnen maken of poëzie kunnen schrijven. De grondbeginselen van software zijn zodanig mathematisch en ver verwijderd van het normaal gebruik van de menselijke hersenen, dat het schier onmogelijk is foutloze software te schrijven. Ja, er zijn ‘oplossingen’ met mooie namen als ‘managed code’, maar die lossen de problemen slechts op de onderste laag op. Ze zorgen ervoor dat je niet meer de voor de hand liggende fouten (verkeerd memory management, stack corruption, etc) maakt, maar het conceptuele ingewikkelde van software is er niet mee opgelost. Wat is dat conceptuele ingewikkelde dan wel?

“Hello World!”

Iedereen die programmeert, ken het bovenstaand zinnetje. Velen zullen ook het volgende citaat kennen (wellicht niet, want Google gaf weinig sjoege erover):

“Every program more complex than ‘Hello World!’ has bugs”

Die fouten zijn terug te voeren naar een aantal basisproblemen in mens-computer interactie:

  1. computers accepteren geen vaagheden, fouten of gokken. Het is het ene of het andere, ertussenin kan niet, tenzij als zodanig geprogrammeerd of geëngineerd (wat ons recursief terug voert naar basisprobleem 1),
  2. menselijke hersenen werken erg slecht in een omgeving waarin alles exact vastgelegd moet worden,
  3. de wereld is complex en samen met 1 en 2 levert dat onoverkomelijke problemen op.

En dan zijn er nog zijproblemen die het er niet eenvoudiger op maken:

  1. computersoftware wordt geschreven door schrijvers van computersoftware, niet door haar gebruikers,
  2. om de één of andere reden, moeten er steeds meer opties bijkomen (waarschijnlijk om de gebruikers te blijven laten betalen voor de fouten die programmeurs maken),
  3. het vak van programmeur is betrekkelijk jong, een jaar of dertig, veertig hooguit; er moet nog een hoop ontwikkeling plaatsvinden voor we er zijn, als we er al komen.

Van die laatste drie zijn mogelijke oplossingen te bedenken: beter testen, betere specificaties maken, etc. Dit zijn geen onoverkomelijke of structurele problemen. Die eerste drie, daar ligt het probleem. Daar wil ik dan ook verder op in gaan.

Computers accepteren geen vaagheden

De eerste kant van het probleem is dat computers geen vaagheden accepteren, tenzij daarvoor geprogrammeerd. Als je dit probleem wilt oplossen, zul je dus een systeem moeten programmeren dat niet alleen vaagheden kan accepteren, maar ook kan leren en zichzelf ontwikkelen. Ook op manieren die je aanvankelijk niet bedacht kan hebben. Vooral dat kan hebben is belangrijk. Je moet zien te anticiperen op wat je niet kan anticiperen. Dit is nu nog steeds niet opgelost in de huidige A.I. Er zijn wel zelflerende systemen en systemen die vaagheden accepteren, maar systemen die zaken leren die niet ge-meta-leerd zijn, bestaan – voorzover ik weet – niet.

Als programmeur weet ik hoe belangrijk (of ongelooflijk irritant) het is om exact te beschrijven wat je wil. Zelfs triviale syntaxisfouten worden niet opgelost. Wel ondervangen, maar al met al zijn we er nog niet zo zeker van, dat de compiler zelf de code aanpast en hercompileert (of, beter nog, de code gewoon compileert met kleine syntaxisfouten).

Nou zijn syntaxisfouten triviaal en als zodanig eenvoudig te verhelpen. Maar er zijn veel andere fouten die je kunt maken, die te maken hebben met het probleem dat computers geen vaagheden accepteren. Memory allocatie fouten (redelijk ondervangen met managed code en een hoop andere talen), vreemde constructies die inherent zijn aan de computer architectuur of taal constructies of luie programmeurs.

Menselijke hersenen werken erg slecht in een omgeving waarin alles exact vastgelegd moet worden

Vooraf moet gezegd worden, dat ik geen psycholoog ben, geen neuroloog, zelfs geen bioloog. Ik ben een software engineer die een paar boeken heeft gelezen over bovenstaande. Ik kan er dus ook hopeloos naast zitten. Maar, wat ik heb gemerkt, is dat mensen, menselijke hersenen, uitermate goed functioneren in omstandigheden, waarin niet alles exact is vastgelegd. Triviale zaken worden onbewust ingevuld en uitgevoerd. Aannames worden (ook vaak incorrect) gemaakt en fouten aangepast. Er is sprake van trial-and-error, een leerproces en – dat is waar het hier om gaat – vaagheden. Menselijk functioneren lijkt niet zwart of wit, maar meer een graad van grijswaarden. Zo zitten wij in elkaar en zo zit ook de wereld om ons heen in elkaar.

Het probleem ontstaat dus, wanneer mensen een problemen moeten vertalen naar een computerprogramma. Bij de domeinanalyse moet alles zeer nauwkeurig vastgelegd worden. Het is niet mogelijk de computer aannames te laten doen of zaken aan te geven als ‘zo rond de 37,5’. Je zult keihard de grenzen moeten aangeven waarbinnen het valt. Het heeft wat dat betreft wel overeenkomsten met wetten. Gelukkig hebben we daarin nog rechters die de zaak kunnen ‘vermenselijken’. In computerland zijn die rechters er niet. Grenzen zijn spijkerhard en alleen doordat mensen de trial-and-error cycli doen, kan een computer zich aanpassen aan ‘the real world’.

Dat geldt voor programma’s die al gemaakt zijn, maar ook het schrijven van die programma’s introduceert het zelfde probleem. Voordat een programma zijn beperkte functionaliteit heeft, zijn er al meerdere menselijke trial-and-error slagen overheen gegaan. Tijdens het programmeren vergeet je triviale zaken, maak je dezelfde fouten opnieuw en opnieuw. En het programma dat ‘klaar’ is, is niet klaar; het is slechts klaar genoeg. Na jaren kunnen we nog fouten naar boven komen, die een gevolg zijn van de mens-computer discrepantie.

De wereld is complex

Zoals eerder gezegd: mensen maken fouten. In 15 regels heb ik al meerdere fouten gemaakt. Kun je nagaan wat er mis gaat in 60,000 regels code die een fabrieksautomatisering is, of de 40 miljoen (!) in Windows XP. Veel regels,veel code, da’s één kant van de zaak. De andere kant is de complexiteit. Computers zijn complex (met veel onderdelen, veel modi operandae, veel mogelijkheden) en dus de aansturende software is ook complex. Nu is de wereld om ons heen ook complex, met veel objecten, veel interacties en veel onbewuste handelingen. Dit zou op zich dus een goede mapping moeten opleveren, ware het niet dat de ‘real world’-complexiteiten niet exact hoeven te worden bediend. Van origine ben ik elektrotechnisch ingenieur, en in dat vak heb ik geleerd dat er veel variabelen helemaal niet exact te hoeven worden bepaald. Alles heeft een soort van resolutie. Bereken je een weerstand van 3,27 kΩ, dan kun je gerust eentje van 3,6 kΩ inzetten; een afwijking van 10%. Een dichter-bij-je-bed voorbeeld is dat je niet op de millimeter nauwkeurig een kopje hoeft vast te grijpen om het op te pakken. Software accepteert dit soort afwijkingen niet, zit je 1 byte verkeerd in het geheugen en je programma maakt fouten, of in het beste geval, het crasht.

Complexiteiten in software en in broncode horen bij de grootste alledaagse problemen van de software engineer. Goed geheugenbeheer (ook in managed talen als Java en C#!), multithreading, (massive) parallellism, real-time aspecten zijn allemaal problemen die niet eenvoudig voor een mens te bevatten zijn, laat staan ze foutloos te implementeren in een produkt. Waar we dus naar op zoek moeten, of moeten zien te ontwikkelen, is een programmeertaal, -omgeving, -apparaat, dat deze problemen voor ons ondervangt of beter nog oplost of nóg beter voorkomt dat we ze überhaupt maken. Er zijn onderzoeken aan de gang, er zijn wat produkten op de markt, maar we zijn er nog lang niet. Als we er al komen, aangezien het mijns inziens een conceptueel probleem is. De oplossing zou kunnen liggen in biologische computers, zoals ze bestaan in eXistenZ. Wie weet? We zullen wel zien.


3 reacties

Mark · 30/01/08 op 22:27

Om te beginnen ; een erg goed relaas… dagelijks herkenbaar als programmeur zijnde.

Een paar hersenspinsels mijnerzijds ter aanvulling danwel overweging:

Waarom we geen “gewoon goede” software kunnen schrijven heeft wellicht tevens te maken met het verwachtingspatroon van “de gebruiker”. Niet ten onrechte willen wij als consument iets gebruiken en verwachten we dat het “gewoon werkt”. Deels raak je dit probleem al aan bij de stelling dat de software geschreven wordt door programmeurs en niet door gebruikers … echter zijn wij zelf niet ook gebruikers? Ik denk het wel, en het verwachtingspatroon dat iets “gewoon moet werken” is, in ieder geval in mijn geval, zeer herkenbaar. Ondanks deze eigenschap krijgen we het kennelijk niet voor elkaar aan de algemene verwachting te voldoen. Ik wil hierbij de kanttekening plaatsen dat dit niet alleen voor software geldt, maar voor verscheidene andere producten.
Nu komt het natuurlijk … we praten hier over een “verwachting”. Dit is een dusdanig grijs gebied, zo erg persoonlijk, inherent aan ons mensen, dat het theoretisch vrijwel onmogelijk wordt hieraan te voldoen?
Daarom denk ik dat dit probleem niet enkel software betreft maar eigenlijk vrijwel alle producten van menselijke makelij welke door andere mensen gebruikt worden.

Ten slotte wordt het maken van software nog extra gecompliceerd op een gebied waar andere producten geen of in mindere mate last van hebben. Namelijk: parallellisme.
Losse processen en threads kunnen wij prima designen, implementeren en begrijpen. Echter het menselijk brein raakt al snel overhit zodra er verschillende processen tegelijkertijd maar toch samen hun werk moeten uitvoeren. Zoals ik het zelf vaak verwoord ; ik ben als software programmeur eigenlijk maar voor één ding bang: “the ghost in the system” ; onverwacht gedrag.
In het voorbeeld van jouw 60.000 regelige fabrieksautomatisering (niet toevalligerwijs grotendeels van mijn hand ;-)) zijn alle losse processen simpel, begrijpelijk en voeren ze redelijk atomaire taken uit. Echter het geheel bestaat uit 10 processen welke ieder op zichzelf weer bestaan uit 3 of meer threads. En daar komt de clue … onze hersens begrijpen prima wat elke thread doet danwel moet doen, echter als we kijken naar het totaalsysteem raken onze hersens in de knoop. Het is daardoor niet ondenkbaar dat een dusdanig complex systeem ineens onverklaarbaar gedrag zou gaan vertonen welke niet op voorhand bedacht is. Is het A.I? Nee. Het is ons onvermogen om dit soort systemen volledig te doorzien in ons programmeursbrein. En hoe zouden wij iets kunnen maken wat “gewoon goed” is als we het niet volledig doorzien?

Overigens is dit laatste een van de redenen waarom velen bang zijn voor A.I. en misschien is die angst niet eens onterecht. Als (als!) we echte A.I. ooit voor elkaar krijgen is er geen enkel mens wat dat systeem zou kunnen begrijpen, doorzien of voorspellen. Het zou echt een eigen leven gaan leiden en dat is angstig….

M

Why does software suck - English | Ik doe er niet aan mee · 29/09/08 op 20:13

[…] lot of searches that lead to my blog lead to the article “Why does software suck?”. That article is written in Dutch, so not very understandable for most English speaking people that […]

Wal-Mart's $200 Linux PC uitverkocht - Pagina 18 | hilpers · 18/01/09 op 16:09

[…] (Ik zal eens kijken of ik tijd heb om te lezen 🙂 >> > Wat zijn SEO vriendelijke URLs? http://www.friesoft.nl/?p=21 wordt dan: http://www.friesoft.nl/2008/01/21/w…software-suck/ (bijvoorbeeld). Zoekmachines […]

Geef een reactie

Het e-mailadres wordt niet gepubliceerd. Vereiste velden zijn gemarkeerd met *

Deze website gebruikt Akismet om spam te verminderen. Bekijk hoe je reactie-gegevens worden verwerkt.