De uitspraak 'verandering is de enige constante' van de Griekse filosoof Heraclitus lijkt tegenwoordig nog toepasselijker dan in de oudheid. Bedrijven worden geconfronteerd met een stortvloed van technologische ontwikkelingen en potentiële disrupties en moeten verandering en innovatie omarmen om relevant te blijven. Future-proof it-oplossingen (toekomstbestendige it) zouden kunnen helpen, maar bestaan die al? Ik voorspel dat low-code hierbij een centrale rol zal spelen.
Voor veel bedrijven is legacy-it nog steeds een bottleneck die ze van echte verandering en innovatie weerhoudt. De software die ten tijde van de aanschaf vooruitstrevend was, is verworden tot rem. En niet alleen de software kan dat effect hebben. De bedrijfscultuur, de interne en externe processen, en zelfs het bedrijfspand kunnen uiterst bepalend zijn voor de innovatieve slagkracht van een organisatie.
Al jaren is mijn droom dat zakelijke it-oplossingen bedrijven veel beter ondersteunen bij die ontwikkeling, en ze bevrijden van de remmende werking van technologisch ‘schuld’ en ingesleten processen. Bedrijven van nu hebben behoefte aan future-proof it; een technologisch fundament dat flexibel kan meebewegen met de technologische ontwikkelingen en hun bedrijfsmatige behoeften.
Future-proof
Future-proof bedrijfssoftware moet om te beginnen naadloos kunnen aansluiten op het dna van je organisatie met al zijn unieke werkwijzen, informatiebehoeften en functionele eisen. Maar de software moet tegelijk ook zijn flexibiliteit behouden, zodat je kunt inspelen op technologische ontwikkelingen en organisatorische wijzigingen. Dit laatste blijkt met traditionele softwarepakketten of standaard SaaS-producten vrijwel onmogelijk. Na de initiële configuratie voldoet de software misschien wel aan de gestelde eisen, maar wil je daarna nog dingen wijzigen, dan is dat vaak net zo complex als sleutelen aan maatwerksoftware.
Modelgedreven software
Low-code software biedt een betere basis voor future-proof it, omdat die je in staat stelt veel flexibeler en zonder (veel) programmeren software te ontwikkelen en configureren. Steeds meer bedrijven lijken zich inmiddels te realiseren dat low-code de toekomst is. Volgens Gartner zijn er nu al meer dan tweehonderd low-code platformen op de markt, en uit een recent rapport van Forrester getiteld ‘Low-Code Development Platforms For AD&D Professionals’ uit begin 2019, blijkt dat 23 procent van de wereldwijde ontwikkelaars in 2018 met low-code platformen werkte. Nog 22 procent gaf aan binnen een jaar met low-code te willen beginnen.
De interesse in low-code platformen neemt dus zeer snel toe, en dat is goed nieuws. Met veel van de beschikbare oplossingen kun je dan ook razendsnel zakelijk applicaties ontwikkelen, maar elke wijziging daarna is toch weer bijzonder arbeidsintensief. Bij veel van die low-code platformen is de software vergelijkbaar met een bouwwerk van bij elkaar geklikte en gesleepte blokjes functionaliteit, die bij wijzigingen allemaal individueel aangepast moeten worden.
Dit probleem wordt opgelost door low-code platformen met een modelgedreven benadering. Daarmee worden de werking, functionaliteit en de processen van de software namelijk in grafische modellen vastgelegd. Dat levert een soort digitale bouwtekening op, die een afspiegeling is van de organisatie en hoe die functioneert. Dat low-code fundament kan vervolgens altijd probleemloos aangepast worden, waarbij de wijzigingen vervolgens automatisch in alle applicaties en schermen doorgevoerd worden. Om die reden is low-code modelgedreven software volgens mij de ideale basis om als organisatie een future-proof it-platform te realiseren. Een technologisch fundament waarmee je het dna van je organisatie echt tot zijn recht kunt laten komen en zonder beperkingen aan de toekomst kunt bouwen.
Interessante observatie, komende uit een legacy tijdperk zowel qua hardware als software, merkte je al bij de introductie van pakketten al SAP, Oracle enzovoort dat er een enorme frictie ontstond tussen veranderen wij onze processen of passen wij ons aan de aangeboden oplossing aan. Je vroeg je ook af waarom software niet kon worden afgebroken en geconverteerd naar de nieuwe oplossingen. Meestal kwam het erop neer dat er iets nieuws werd geïntroduceerd en het oude werd verwijderd. Mijn vraag blijft hoe toekomstbestendig is low-code dan wel, of is dit weer een brug naar een toekomstige oplossing.
Er zijn een aantal bekende argumenten tegen low code:
– zwakheden in de model (veelal gemaakt door niet-IT-ers) vertalen zich uiteindelijke in zwakke code
– om fouten in de gegenereerde code te herstellen zal je toch onder de motorkap moeten kunnen duiken
– performance. Om uit te vinden waarom het zo langzaam is zal je toch je handen moeten vuilmaken
– security en bedrijfsspecifieke compliance zitten meestal niet in low-code platforms
Maar er is er nog een: maatwerk wordt uiteindelijk legacy. Daarbij maakt het niet uit of dat maatwerk is geproduceerd door code-kloppers of een low-code platform. Elk stuk coding heeft een run-time environment nodig om uitgevoerd te worden.
Dat betekent dat er afhankelijkheden bestaan tussen de omgeving waar de code wordt geproduceerd en de run-time omgeving van de code. Uiteindelijk is het “just another thing to patch” en wanneer de runtime omgeving periodiek moet ge-upgrade moet je ook gaan kijken naar de afhankelijkheden met de codegenerator en kan het zo wezen dat:
– de code opnieuw gegenereerd dient te worden.
– de runtime omgeving van de codegenerator ook gepatched moet worden
Als dan blijkt dat er een probleem in de codegenerator zit waardoor de codegenerator of de gegenereerde code niet meer werkt, heb je een reeel probleem als bedrijf.
Low code introduceert nieuwe afhankelijkheden in de applicatiestack. Wellicht dat de produktie van code goedkoper wordt, maar het uiteindelijke beheer ervan wordt duurder.
En dan heb je een mooi low code systeem stand alone voor op de pc en dan wil de klant het op een app….
Waar gebruikmakend van de gps coördinaten heel veel automatisch moet kunnen..
En na 5 jaar low code zijn er allemaal nieuwe google achtige dingen bij gekomen die er ook nog in moeten waardoor 70% van de low code niet meer nodig is omdat nu spraakherkenning wordt gebruikt.
Blijkt ook nog de fabrikant van het lowcode platform niets te maken voor android telefoons.
Ik ben overigens best fan van low code zoals out systems. Hiermee werd naar keuze java of C# mee gegenereerd. Op een gegeven moment zijn ze gestopt met java…
Best lullig als je alles op een linux omgeving draait…
@ KJ : snel iets gerealiseerd, ideaal. Maar iets wijzigen, moet je dan geen rekening houden met wat bestond aan data structurne en relaties ? Of wordt de in het verleden bekomen waardevolle data automatisch aangepast om te gebruiken in de nieuwe opvattingen , of gooi je alles maar overboord en herbegin je telkens maar opnieuw?
KJ , je hebt gelijk, het onderhoud kan zeer duur komen te staan, en veel tijd vragen.
Wat we zien is dat Low-code erg in opkomst is en dat hierin een aantal type platformen aan het ontstaan zijn met ieder hun kracht en ook hun zwaktes. Deze komen vooral naar voren wanneer de type low-code niet voor het bedoelde domein ingezet worden. Ik denk dat je de low-code platformen kunt indelen in no-code, low-code en modelgedreven platformen.
No-code heeft als doel om de business grafisch applicaties te laten maken. Dit stelt een veel grotere groep in staat om invulling te geven aan business wensen m.b.t. IT, maar heeft ook als valkuil dat niet elke ontwikkelaar de juiste keuzes maakt, omdat hij daarvoor niet de achtergrond heeft. Goed programma management is hier essentieel.
Low-code heeft als doel om de realisatie van Apps te laten versnellen. Een low-code tool kan prima een grafische modelleertool bieden die onder water er direct HTML en JavaScript van maakt. Transformatie naar een nieuw platform zal dan vrijwel niet mogelijk zijn. Ook het onderhouden en verbeteren van de transformatie wordt dan een grote uitdaging, omdat het in een platform-specifiek model is opgeslagen (PSM). Hier zie je ook soms dat de kosten van de gehele lifecycle hoger is dan wanneer je dit traditioneel programmeert. De term wegwerp software hoor je hier vaker.
Modelgedreven heeft als doel om technologie te kunnen overleven en het realiseren van grote applicaties beheersbaar te maken. Een modelgedreven low-code tool met een platform independent model (PIM) biedt mogelijkheden voor transformatie naar nieuwe platformen én voor onderhoud en doorontwikkeling van deze transformatie. Runtime interpretatie versterkt dit nog eens, waardoor er zelfs geen generatieslag overheen te gaan om een technologie te updaten (@KJ) of om een nieuwe technologie te introduceren t.b.v. een nieuw OS (@Corne Smiesing). Ook heb je bij het gebruik van runtime interpretatie minder reden om zelf de moterkap duiken van gegenereerde code (@KJ) en daarmee je toekomstbestendigheid te verminderen.
Dus heb je een dependency op de code generator (of runtime interpreter) en op het patchen/updaten van de runtime omgeving (@KJ)? Ja. Maar laten we wel wezen, die heb je evengoed op frameworks, operating systems, talen, etc. Selectie van een low-code vendor die een goede lifecycle, een duidelijke roadmap en een compatibility plan heeft is daarbij van belang.
Security en compliance is een groot aandachtspunt. Het is ook belangrijk om het low-code platform hierop te selecteren. In een modelgedreven platform is dit wel goed te scheiden, doordat technische implementatie van security in het platform model is ondergebracht en samen met het PIM transformeert naar een PSM met zowel de juiste functionaliteit als ook de gewenste security.
Ik denk dat het een sterk punt zou zijn om @Corne Smiesing te laten zoeken naar een platform die ontwikkeld is met het eigen platform. De noodzaak om future proof te zijn is dan de levenslijn voor de low-code vendor, waar de afnemer van het platform ook de vruchten van plukt.
Uiteindelijk is het reduceren van code voor alle toepassingen interessant. Traditionele software realisatie kan nooit technologie overleven doordat het volledig is opgebouwd door code in een bepaalde technologie. De juiste keuze voor het type platform die bij de IT uitdaging hoort is echter wel enorm belangrijk om het gewenste resultaat te behalen.
@KJ, Uitstekende reactie !
Low Code is vooral de zoveelste poging om heikneuters software bijeen te laten kakken.
Wel je een gedegen, betrouwbare basis die ook nog eens onderhoudbaar en daarmee voorbereid op de toekomst is dan zul je gewoon op zoek moeten gaan naar gekwalificeerde mensen.
Er zijn al voorbeelden te over van slecht gebouwde projecten omdat we voor een habbekrats een paar Indieers wat functies willen laten maken zonder ons over de kwaliteit, architectur dan wel, onderhoudbaarheid druk te maken.
Ik denk dat Low Code gewoon thuishoord in het rijtje van buzzwords
@ Pascal: groot gelijk heb je. Als je mij als ervaren MRP in ERP een financieel systeem zou laten ontwerpen dan vrees ik dat, ondanks dat het efficient zal werken, er geen enkele boekhouder daar succesvol mee omgaat, gewoon omdat ik geen echte affinitiet heb met dit gebied. Ik weet wel, er is een grootboek, kostensoorten en kostenplaatsen, crediteuren en debiteuren, maar dat volstaat niet om als boekhouder te denken.
En IT ontwikkelen blijft een automatisering skill, ongeacht het platform en de ontwikkeltaal. Even een taal eigen maken volstaat niet.