De echte mannen zijn weer terug

Een verontrustende trend is zichtbaar in de wereld van software-ontwikkeling. De interesse voor CASE-tools is aan het afnemen terwijl de 3GL's aan een spectaculaire opkomst bezig zijn. De vraag is of gaat dit leiden tot een tweede softwarecrisis?

Tijdens mijn opleiding, zo'n 20 jaar geleden, besteedden docenten veel tijd aan het beschrijven hoe software-ontwikkeling er in de zestiger en zeventiger jaren uitzag. Dit was nog de tijd dat automatiseerders echte mannen (of vrouwen) waren. Indien er een programma geschreven moest worden, ging men aan de ponskaartmachine zitten, krabbelde even op het hoofd, sloot enkele seconden de ogen, liet de vingers langzaam afdalen naar het toetsenbord en ramde dan in één keer het programma eruit. Als het programma klaar was, dus aan het eind van het project, werd aan de gebruiker gevraagd of dit was wat hij of zij wilde (vandaar de term eindgebruiker).

Voor het bouwen van programma's waren alleen inhumane 2GL's (assemblers) en 3GL's, zoals COBOL en Fortran, beschikbaar. Uiteraard zaten dergelijke programma's vol fouten en moesten er talloze slagen overheen om het programma goed te krijgen. Ondertussen werd wel een geheel Braziliaans woud aan papieren ponskaarten verprutst. Deze echte mannen vonden dat toen dè aanpak. Zo hadden ze het altijd gedaan en zo zouden ze het altijd blijven doen. Ze waren er in feite trots op dat ze zonder iets eerst op papier te zetten die programma's in elkaar konden flansen. Vooraf alles analyseren was voor watjes.

Het gevolg van deze aanpak werd duidelijk in de tachtiger jaren: een grote softwarecrisis. Software-ontwikkeling duurde te lang, omdat er veel fouten in zaten, onderhoud was een nachtmerrie en documentatie was, om toch maar wat papier te besparen, geheel niet aanwezig. De term die ook veelvuldig gebruikt werd, was application backlog. 

Op twee manieren werd getracht deze softwarecrisis op te lossen en de achterstand in applicatieontwikkeling weg te werken. Ten eerste zijn we meer tijd gaan besteden aan een gedegen analyse- en ontwerpfase en ten tweede zijn we hogere, meer toegespitste programmeertalen gaan inzetten. Om de analyse- en ontwerpfase te ondersteunen kwamen er CASE-tools op de markt en werden er 4GL's ontwikkeld om de productiviteit van de programmeur op te schroeven. 

Het positieve effect is dat we in de negentiger jaren op een meer gedegen manier software zijn gaan ontwikkelen en daarmee hebben we de softwarecrisis voor een groot deel kunnen wegwerken. De wensen van onze gebruikers konden sneller ingewilligd worden.

Kijken we naar de huidige situatie, dan zien we langzaam een teruggang naar de cultuur van de zeventiger jaren: de echte mannen zijn terug. De CASE-tool markt heeft het zwaar. Bijvoorbeeld, onderzoeksbureau IDC heeft gemeld dat de verkoop van CASE-tools afneemt. En tegenwoordig kun je leveranciers van dit soort producten ook voor een prikkie kopen, denk maar aan hoe goedkoop Sterling Software het bedrijf Cayenne heeft kunnen opkopen. 

De immer toenemende populariteit van 3GL's als Java en Basic geven ook aan dat de interesse van 4GL's aan het afnemen is. Er wordt zelfs beweerd dat er meer dan drie miljoen VisualBasic programmeurs zijn. Dat is zorgelijk, want wat men ook beweert: de productiviteit van de 4GL-programmeur ligt hoger. Dit blijkt ook keer op keer tijdens de door CM Corporate georganiseerde Rad-races. Het zijn de teams die met 4GL's werken die op eenvoudig wijze winnen. Als deze teams klaar zijn met het gehele programma, hebben de teams die voor een 3GL hebben gekozen net één button op het scherm. Maar, en dat moet gezegd, deze is dan wel object-georiënteerd en opgebouwd uit componenten.

Laten we eerlijk zijn, dit is een ongunstige ontwikkeling. Als we zo doorgaan, kunnen we over enkele jaren de termen softwarecrisis en application backlog uit de kast halen, want dan zitten we weer met bergen 3GL-code waar weinig documentatie voor beschikbaar is. 

Een vergelijkbaar verhaal heb ik ooit tijdens een congres gehouden en toen vertelde iemand mij dat dit allemaal niet zo'n vaart zou lopen, want talen als Java en Basic zijn zelfdocumenterend. Ik heb daar maar niet op gereageerd. Ik hoop dat u zich herinnert dat dit ooit over COBOL en Fortran gezegd werd. Nu weten we wel beter.