Managed hosting door True
Deze opinie is van een externe deskundige. De inhoud vertegenwoordigt dus niet noodzakelijk het gedachtegoed van de redactie.

Aandacht voor programmagenerator

 

Het artikel 'Een andere manier van software ontwikkelen' van Rob Ronda (Computable van 14 maart) heeft Guus van der Meulen aangesproken. Hij denkt dat het tot veel discussie kan leiden. Hij vindt het bijvoorbeeld jammer dat de vraag waarom je een generator zou willen schrijven niet door Ronda beantwoord wordt. Van der Meulen vraagt meer aandacht voor generatoren.

Ik vond het artikel een goed en stimulerend stuk, dat veel discussie waard is. Hij begint in zijn artikel met de situatie waarin je niet een programma wilt schrijven, maar de generator voor dat programma. Rob gaat hierbij niet in op de vraag waarom je een generator zou willen schrijven. Jammer want een generator is immers een middel, geen doel op zich.
Ik zou een generator willen schrijven indien ik geen generator beschikbaar heb en ik tientallen gelijksoortige programma's zou moet schrijven. Dan zou ik na het schrijven van het eerste programma bekijken of ik met het maken van een generator tijdwinst kan boeken bij het maken van de andere programma's. Ik geloof niet dat je een generator voor een bepaalde groep van programma's kunt schrijven zonder eerst een soortgelijk programma beschikbaar te hebben. Wat anders duurt het maken van een generator langer dan het vervaardigen van één enkel programma.
Als ik Ronda goed begrijp zegt hij vervolgens dat een 4gl geschikter is dan een 3gl voor het bouwen van een generator. Dit lijkt me toch wat kort door de bocht. Ik denk dat een aantal aspecten van programmeren en genereren onvoldoende van elkaar worden onderscheiden en daardoor tot een onjuiste stelling leiden.

Abstracter

Ik ben het met Ronda eens dat een 4gl abstracter is dan een 3gl. Veel (met name technische) specificaties hoeven niet meer te worden gemaakt in een 4gl, omdat de automatische afleidingsmechanismen worden ingezet om de technische specificaties toe te voegen, zodat een geheel van specificaties ontstaat dat een computer kan uitvoeren. 4Gl is altijd bedoeld voor een bepaalde groep of klasse van beschrijvingen, zoals het maken van transactionele- of registratietoepassingen met een Windows gui. Voor bepaalde problemen kom je sneller tot een oplossing, maar dat gaat ten koste van algemenere inzetbaarheid van de taal. Ronda noemt dit spanningsveld zelf ook.
Een 4gl is door z'n hogere abstractieniveau altijd minder algemeen inzetbaar. Ik denk dat je een device-driver sneller in een derde generatietaal als C programmeert dan in een bepaalde 4gl voor transactionele systemen (als het je überhaupt al lukt om die device-driver in die 4gl te maken).
Generatoren zijn dus alleen goed met een 4gl te maken als in de woorden van Roda "generatoren binnen het domein van de werkelijkheid vallen dat met die specifieke 4gl beschreven kan worden". Met andere woorden: men zou dus voor het efficiënt ontwikkelen van generatoren over een 4gl willen beschikken die speciaal geschikt is voor het maken van generatoren.
Ik ken geen vierde generatietool om generatoren mee te maken. Zou er eigenlijk wel een markt zijn voor een dergelijke 4gl-generator? Een 4gl ga je je immers alleen eigen maken als er tientallen producten mee te maken zijn. Ik kan me moeilijk voorstellen dat er zoveel mensen zijn die een substantieel deel van hun tijd besteden aan het bouwen van generatoren dat er een markt is om hen te ondersteunen met een generator-4gl. Een dergelijke generator zou er natuurlijk wel kunnen komen in een academische omgeving; og gebouwd kunnen worden door bevlogen mensen.

Generator voor generatoren

Een 4gl-generator lijkt dus weinig realistisch omdat er geen markt voor lijkt te zijn. Een codegenerator ga je dus in een derde generatietaal maken. Als je echt goed bent en veel generatoren maakt, kom je wellicht op het idee een generator voor generatoren te maken (gewoon geschreven in een 3gl). Ik denk dat de weg naar een dergelijke generator voor generatoren realistischer is dan de weg naar een 4gl-generator.
In het stuk van Ronda wordt volgens mij te weinig onderscheid gemaakt tussen de term '4gl' en de term 'generator'. Daarbij komt nog de complicerende factor dat generatoren onderling niet goed te vergelijken zijn.
Er zijn generatoren in heel verschillende soorten en maten. Zo zijn er taalomzetters (parsers), generatoren die bijvoorbeeld meta-informatie van een dbms gebruiken om een 'data access layer' te maken en generatoren die complete functionele specificaties kunnen vertalen naar -door de computer uitvoerbare- code ('model based development'). Al deze generatoren op één hoop gooien lijkt me in veel situaties niet bijdragen tot een goed begrip. De gedachte dat er één goede 4gl zou kunnen bestaan voor het ontwikkelen van al deze soorten generatoren lijkt met niet realistisch.
Ik zou wel eens een redelijk compleet lijstje van alle soorten generatoren willen zien om te onderzoeken op welke manier verschillende soorten generatoren efficiënt te bouwen zijn.

Eerste generator in Pascal

Ik kan me nog levendig herinneren hoe ik in 1987 mijn eerste generator in Pascal schreef die een compleet FO kon omzetten naar database definities en programmacode (compileertijd: negentig minuten!). Het ging om een generator die software genereerde voor het zenden, ontvangen, manipuleren en printen van edi-berichten. De input bestond uit alle gewenste Edifact berichtdefinities met hun onderlinge scenario. Ook in de jaren daarna heb ik gelukkig diverse opdrachten gehad om generatoren te specificeren en te bouwen.
Ik heb het idee dat er zich momenteel betrekkelijk weinig professionals bezig houden met het ontwikkelen van generatoren. Voor die geringe aandacht zijn vele oorzaken aan te dragen. Ik denk dat de snelheid van de technische veranderingen van de laatste jaren ervoor heeft zorgt dat steeds weer de aandacht wordt weggetrokken van de meer conceptuele niveaus van programmeren naar allerlei issues op gebied van de technische architectuur. En een ander aspect is dat programmeren van applicaties de laatste jaren meer en meer gelijk staat aan kennis hebben van de desbetreffende 'library' en het kunnen omgaan met de ide. De mindset van veel programmeurs is daardoor minder bij genereren komen te liggen.
 
Ik ga er echter van uit dat er wel weer andere tijden zullen komen, waarin meer ruimte bestaat voor het nadenken over generatoren. Of misschien kunnen we een hype creëren? Ronda zet daarvoor immers al een belangrijke stap. De naam van het nieuwe voorgestelde ontwikkelparadigma van Ronda, 'Conceptueel georiënteerd ontwikkelen', is het in mijn ogen waard tot een hype uit te groeien.< BR>
 
Guus van der Meulen, Amsterdam

Dit artikel is afkomstig van Computable.nl (https://www.computable.nl/artikel/1377848). © Jaarbeurs IT Media.

?


Lees meer over


 
Vacatures

Stuur door

Stuur dit artikel door

Je naam ontbreekt
Je e-mailadres ontbreekt
De naam van de ontvanger ontbreekt
Het e-mailadres van de ontvanger ontbreekt

×
×