Outsourcing overbodig met 7GL

Outsourcing van softwareontwikkeling wordt gezien als een methode om ontwikkelkosten te reduceren. Het is echter ook mogelijk om deze kosten op een duurzamere manier te verminderen, zodat uitwijken naar landen als India of het Oostblok niet meer nodig is. Volgens Marco Dumont van IBS is het gewoon een kwestie van de zaken slimmer aanpakken.

Eigenlijk werkt het met softwareontwikkeling nog steeds hetzelfde als bij banken halverwege de vorige eeuw. Destijds leken banken op enorme mierenhopen waar veel mensen werkten. Iedere medewerker voerde een routinematig onderdeel van het proces uit, zoals bijvoorbeeld de duizenden klerken die handmatig geld telden. Al heel vroeg gingen deze bedrijven (eerst met rekenmachines en later met computers) automatiseren om zo de kosten te reduceren. Zo waren er steeds minder handen nodig en werd de werkwijze van de banken steeds efficiënter. Op dit moment zijn er nog steeds veel mensen betrokken bij softwareontwikkeling. Zij verrichten allemaal routinematig een stukje van het werk. Net zoals dat bij de banken het geval was. Dit maakt ontwikkelen complex en duur. Geen wonder dat bedrijven dan uitwijken naar lagelonenlanden. Bedrijven en ontwikkelaars die in huis willen blijven ontwikkelen, zullen dus methoden moeten vinden om het ontwikkelproces efficiënter te maken. In dit artikel laat ik zien hoe je door de 3GL en 4GL-ontwikkeling te combineren zodanig sneller en slimmer ontwikkelt, dat outsourcing overbodig wordt.

3 GL + 4 GL = 7 GL

Bedrijfssoftware bestaat op hoog niveau eigenlijk uit drie onderdelen: het ontsluiten van de gegevens op een voor de programmeertaal makkelijk te muteren manier, een gebruikersinterface en de bedrijfslogica. Dit geldt zowel voor 3GL (talen als bijvoorbeeld C(++), Java en PHP, frameworks) als voor 4GL tools (generatoren die programma´s creëren op basis van bedrijfsregels). Veel van de code die nodig is voor het ontsluiten van gegevens, is in essentie gelijk aan elkaar. De gebruikersinterface vraagt flexibiliteit om aan de eisen van de belanghebbenden of opdrachtgevers te voldoen. Het zou mooi zijn als de ontwikkelaars zich zouden kunnen concentreren op hetgeen dat daadwerkelijk geautomatiseerd moet worden: het bedrijfsproces.

Het antwoord op de bovenstaande problemen is 7GL, een slimme ontwikkelmanier waarbij routinematige handelingen worden vervangen door een generator die broncode genereert (4GL) voor de gegevensopslag en een stevige bibliotheek aan componenten (3GL), die het mogelijk maakt de gebruikersinterface te construeren. Door deze intelligent met elkaar te laten samenwerken (3 + 4 = 7GL) versterken ze elkaar en versnelt het ontwikkelproces. 7GL maakt gebruik van de flexibiliteit van een 3GL-omgeving en de snelheid van 4GL. Vertragende factoren worden efficiënter of verdwijnen zelfs helemaal.

De vier elementen van 7 GL

Het 7GL-concept bestaat grofweg uit vier elementen: één of meerdere generatoren waarmee de routinematige handelingen in het ontwikkelproces worden weggenomen, een ruime bibliotheek met componenten om de gebruikersinterface mee te maken, slimme componenten die op basis van de gegenereerde programma-elementen met een eenvoudig statement complete functionaliteit creëren en een technische projectstructuur voor een betere beheersing van de bedrijfslogica.

Generatoren

Veel ontwikkelaars maken al gebruik van generatoren zonder zich daar bewust van te zijn. In de open source IDE Eclipse worden klassen – objectbeschrijvingen – gegenereerd uit een aantal gegevens die door de programmeur worden opgegeven. Het genereren geldt voor elke taal waarin gewerkt wordt, want de opbouw van de klassen is immers voor alle klassen gelijk. Ook op een hoger niveau van abstractie zijn er elementen te ontdekken die veel overeenkomsten tonen. Het benaderen van de tabellen in de database is daar een mooi voorbeeld van. Ondanks dat de softwareontwikkeling wordt versimpeld door het gebruik van generatoren, kom ik tot op heden meer ‘copy' en ‘paste' tegen dan dat er klassen worden gegenereerd. Dit is een gemiste kans. Het creëert nog meer gelegenheid tot het maken van fouten, wat resulteert in meer testwerk. In Eclipse en de varianten van Eclipse is bijvoorbeeld een generator (Eclipse Modelling Framework) aanwezig. Een projectteam kan hier gebruik van maken. Dit scheelt weer extra inspanning die nodig is voor het onderhouden of maken van een generator. De modellen waarmee gegenereerd wordt moeten uiteraard wel door het projectteam zelf gemaakt worden. Toch staat deze inspanning in geen verhouding tot het handmatig creëren van grote aantallen klassen die bijna of zelfs geheel gelijk zijn.

Componentenbibliotheek

De componentenbibliotheek bevat componenten waar default-waarden een uitgangspunt zijn. Dit maakt ontwikkelen eenvoudiger. Voor de slimme componenten geldt dat als je ervoor kiest om de databasetoegang te genereren, dit automatisch betekent dat het model van de database (de metagegevens) elektronisch toegankelijk is. In het 7GL-concept worden deze gegevens gebruikt om de gebruikersinterface real-time te creëren. Denk hierbij aan onderhoudsschermen en overzichten. In een 4GL-omgeving wordt het volledige programma gegenereerd. De tijdwinst die door het genereren ontstaat, wordt tenietgedaan door het gebrek aan flexibiliteit die in deze ontwikkelomgevingen geboden wordt . Bedrijfsapplicaties vragen echter wel om flexibiliteit om de processen zo efficiënt mogelijk te laten verlopen. Met de rijke componentenbibliotheek en een 3GL tot je beschikking is het eenvoudig om die noodzakelijke flexibiliteit te realiseren. Dit in tegenstelling tot een 4GL-omgeving waar ontwikkelaars zich in allerlei bochten moeten wringen om de gevraagde gebruikersinterfaces te realiseren. De beste strategie is dus de onderdelen te genereren waar niet zoveel flexibiliteit vereist is, en gedeelten die onderling sterk afwijken van elkaar met de hand te creëren.

Projectstructuur

Projecten vereisen een projectmanagementstructuur, zoals bijvoorbeeld RUP, DSDM of Prince(2). Daarnaast is het van belang dat er ook een structuur bestaat om het project technisch te bewaken. De architectuur van een applicatie vertelt namelijk hóe een programma gemaakt moet worden en het technisch beheer van de bedrijfslogica bewaakt juist wát er gemaakt wordt. Voor het technisch beheer kun je bijvoorbeeld Design by Contract (DBC) gebruiken. Daarmee voorkom je dat projectmedewerkers bedrijfslogica creëren die, zowel qua bugs als functioneel, niet correct is. Een bijkomend voordeel is dat het testen eenvoudiger wordt, omdat al opgegeven is wat het proces moet doen en wat het oplevert. Wordt er van een generator gebruik gemaakt, dan biedt DBC eveneens het voordeel dat validatie en testen voor één gegenereerd object slechts eenmaal hoeven worden uitgevoerd.

Voorbeelden van successen

Er bestaan al diverse voorbeelden van ontwikkelomgevingen waarin het 7GL-concept succesvol wordt gebruikt. Neem Eclipse, waar met het Eclipse Modelling Framework stukken code worden gegenereerd. Of het Java framework IBS Java Development Accelerator (JDA), waarin een generator wordt gebruikt voor het benaderen van de database en een bibliotheek voor de gebruikersinterface. En Qcodo, een PHP framework dat op basis van de database PHP-objecten genereert. Deze PHP-objecten maken de gegevens in de database beschikbaar, in combinatie met templates die het creëren van de gebruikersinterface vereenvoudigen.

Versnelling

De efficiëntie die bereikt wordt door de eenduidige benadering van de gegevens en de inzet van slimme componenten is enorm. In de code waarin een grote flexibiliteit nodig is, biedt de normale 3GL-omgeving voldoende flexibiliteit om de noodzakelijke functionaliteit te realiseren. Maar de efficiëntie is alleen te bereiken met een bibliotheek met componenten die functionaliteit implementeren, zoals onderhoudsschermen en tabellen. Het elimineren van routinematige handelingen in het implementatietraject levert een aanzienlijke versnelling op. De reden hiervoor is evident: minder testen, minder ‘copy-paste' en minder onderhoud. Efficiëntie met betrekking tot het creëren van bedrijfslogica wordt bereikt door duidelijke afspraken te maken in de vorm van een contract tussen de opdrachtgever, ontwerper en programmeur. In dit contract staat vermeld hoe en wat de bedrijfslogica in detail moet doen. Dit betekent dat je al in het ontwerpproces bepaalt wat de transformaties inhouden. Deze formaliseer en leg je vast in Hoare-triples, de basis van DBC. Uit kwaliteit volgt immers effectiviteit.

Oorlog

In een 4GL-omgeving verlies je de flexibiliteit die zo hard nodig is om de opdrachtgever tevreden te stellen. Terwijl werken met een 3GL-omgeving soms bijna gelijk staat aan het voeren van een oorlog op drie fronten: er wordt tegelijkertijd gewerkt aan zowel de database, de gebruikersinterface en de bedrijfslogica. Mijn ervaring is dat twee van deze drie onderdelen een ondergeschoven kindje blijven. In het 7GL-concept worden de ontwikkelaars ontzien met betrekking tot de gebruikersinterface en de database. Zij kunnen hun aandacht daardoor meer richten op het automatiseren van bedrijfsprocessen en maken zichzelf daardoor onmisbaar. En wat betreft outsourcing: Napoleon heeft reeds bewezen dat oorlog voeren in den verre weinig zin heeft.

Ing. Marco Dumont, IBS