icon
en

De zelftrivialisering van softwareontwikkeling

Hero-afbeelding bij het artikel van Stef van Wijchen over de zelftrivialisering van softwareontwikkeling

Geschreven door

Stef van Wijchen

Geplaatst op

Deel artikel

LinkedIn

Facebook

X

Softwareontwikkeling heeft een ingewikkelde relatie met complexiteit. Als developers zijn we er trots op dat we moeilijke problemen oplossen. Maar daar zit een paradoxaal instinct achter: Het verlangen om complexiteit zó grondig op te lossen dat het nooit meer opgelost hoeft te worden. We willen complexiteit laten aanvoelen als iets triviaals. De beste oplossing is vaak degene die de lelijke details wegabstraheert en een taak die ooit moeizaam was verandert in een simpele library-import of een functieaanroep van één regel. Dit fenomeen, dat ik de “zelftrivialisering” van softwareontwikkeling noem, betekent dat developers, door problemen op te lossen en de oplossingen te delen, de noodzaak van hun eigen inspanningen voor verdere ontwikkeling in dat gebied effectief verkleinen. Nou ja, in ieder geval tot er nieuwe complexiteit opduikt.

Er zijn twee manieren om een softwareontwerp te maken: de ene is het zo simpel maken dat er duidelijk geen tekortkomingen zijn, de andere is het zo ingewikkeld maken dat er geen duidelijke tekortkomingen zijn.

Zelftrivialisering sluit aan bij de eerste aanpak: complexiteit aanpakken door die te elimineren via eenvoud en abstractie. In dit artikel duiken we in de geschiedenis van deze mindset, hoe die zich vandaag manifesteert, wat erachter zit en wat het op de lange termijn kan betekenen voor softwaredevelopers.

Een korte geschiedenis van complexiteit één keer (en voorgoed) oplossen

Vanaf het allereerste begin van computing zoeken developers naar manieren om complexiteit te abstraheren en te voorkomen dat ze dezelfde problemen opnieuw moeten oplossen. In de goede oude tijd (en ik schrijf dit niet als ooggetuige) gingen programmeurs van ruwe machinecode naar assembly-talen, en daarna naar meer “high-level” talen zoals COBOL. Stap voor stap maakten ze programmeertaken toegankelijker door low-level details zoals geheugenbeheer of CPU-instructies te trivialiseren. Dit legde de basis voor het kernidee van zelftrivialisering: los het één keer op, hergebruik het overal.

In de jaren 70 en 80 ontstond de praktijk van codehergebruik via subroutine libraries en modules. Die werden vaak meegeleverd met compilers of door bedrijven verkocht. Zo namen developers de goed opgeloste oplossing van iemand anders over in plaats van zelf iets te schrijven. Zoals een stukje geschiedschrijving opmerkt, werd zelfs in die begindagen “code al hergebruikt in de vorm van libraries” om veelvoorkomende operaties op hardware of databases af te handelen. Dit was echter grotendeels een gesloten, vendor-gedreven model; updates waren zeldzaam en delen was beperkt.

Het grote keerpunt kwam met de opkomst van de Free Software- en open-source-bewegingen in de jaren 80 en 90.

De fundamentele daad van vriendschap tussen programmeurs is het delen van programma’s. ~ Richard Stallman

Stallmans filosofie, gecombineerd met de verspreiding van het internet, leidde tot een explosie aan samenwerking. Developers over de hele wereld begonnen hun oplossingen openlijk te delen, zodat anderen erop konden voortbouwen. Eind jaren 90 en begin jaren 2000, tijdens de dotcom-bubbel, werd codehergebruik een levend proces: libraries en frameworks werden nu onderhouden door communities en evolueerden continu mee met nieuwe behoeften. Als iemand een bug of verbetering ontdekte in een gedeelde module, kon iedereen die hem gebruikte vrijwel direct profiteren van de fix. In wezen werden hele probleemdomeinen één keer opgelost en daarna voorgoed weggeabstraheerd.

  • Operating systems maken CPU-scheduling en diskbeheer het probleem van iemand anders.
  • Programmeertalen en compilers laten ons high-level talen gebruiken die handmatig machinecode schrijven trivialiseren.
  • Garbage collectors elimineren een hele klasse aan bugs, zoals handmatige memory leaks.
  • Het web en al zijn frameworks veranderden complexe request handling in een oefening in conventies volgen.

Waar een team vroeger weken over bouwde, scaffolden we nu in minuten door simpelweg NextJS, Laravel of .NET te importeren.

Libraries voor alles

Tegen de jaren 2010 waren package managers (npm, Maven, enzovoort) en open-source libraries zo talrijk geworden dat er voor vrijwel elk veelvoorkomend probleem waarschijnlijk al een oplossing online stond. Moderne softwareontwikkeling begint vaak met zoeken naar libraries of API’s voordat iemand aan een nieuwe implementatie begint. Het gevolg: developers besteden meer tijd aan integreren en configureren dan aan bouwen vanaf nul.

Klein zijspoor: een pijnlijke illustratie van hoe ver “libraries voor alles” is doorgeschoten, was het incident uit 2016 rond een npm-package genaamd left-pad . Dit was een 11 regels tellende JavaScript-functie voor het padden van tekst. Hoewel de source van left-pad tests bevat en de logica wat validaties heeft, lijkt het nog steeds iets wat elke behoorlijke programmeur in een paar minuten had kunnen schrijven. Maar omdat het als package was gepubliceerd en veel andere packages ervan afhingen, gingen duizenden projecten kapot toen de auteur de package uit de registry verwijderde. Met andere woorden: zelfs een triviaal probleem (een string padden) was één keer opgelost en omgezet in een gedeelde triviale oplossing, tot op het punt dat veel developers nooit meer de moeite namen om het zelf nog eens op te lossen.

Dit incident was een eyeopener: het liet zien dat moderne software gebouwd is op laag na laag van eerdere oplossingen. Sterker nog: vrijwel alle software is gebouwd bovenop andere software, die zelf ook weer afhangt van andere software. Het instorten van zelfs een piepklein laagje kan enorme kettingreacties veroorzaken.

Door deze historische trends heen zien we zelftrivialisering als drijvende kracht achter de vooruitgang van ons vak. Elke generatie tools verlegt de grens van wat “makkelijk” is.

Taken die ooit complex genoeg waren om het werk van een developer te definiëren, kunnen in het volgende tijdperk basisvoorzieningen worden. Dat geeft developers de ruimte om zich te richten op nieuwe, onopgeloste problemen, maar het betekent ook dat we voortdurend op de schouders van reuzen staan (of van left-pad).

Hoe zelftrivialisering zich vandaag manifesteert

In de hedendaagse softwareontwikkeling is het instinct om “de moeilijke dingen weg te abstraheren” springlevend. Zo schreef ik onlangs een artikel over hoe we React omarmden als kernpijler van onze afdelingsoverstijgende gedeelde tech stack bij OWOW. We zien het terug op meerdere vlakken, van alledaagse codegewoonten tot de bredere developercultuur.

Dependency-first development

Developers van nu beginnen een taak vaak met de vraag: “Is er al een library of service die dit doet?” In plaats van het wiel opnieuw uit te vinden, nemen we bestaande packages op. Het npm-ecosysteem voor JavaScript bevat bijvoorbeeld honderdduizenden packages, van complex (zoals React) tot ongelooflijk simpel (zoals left-pad). Een feature implementeren draait daardoor misschien meer om het kiezen en integreren van de juiste kant-en-klare componenten dan om algoritmisch vernuft van de developer. En waarom ook niet, als de oplossing er al ligt en gratis te gebruiken is?

Open source & “het in het openbaar oplossen”

Open-source software is misschien wel de puurste vorm van zelftrivialisering op schaal. Wanneer een developer of team een moeilijk probleem oplost en het uitbrengt als gratis library of tool, trivialiseren ze dat probleem feitelijk voor de hele community. Een robuuste webserver nodig? Gebruik Apache of Nginx; niemand schrijft er vandaag nog één vanaf nul, behalve om te leren of voor hele specifieke behoeften. Een encryptie-algoritme nodig? Gebruik OpenSSL. Dankzij open source is de zichtbare behoefte aan maatwerkontwikkeling op veel vlakken verdwenen; we delen allemaal dezelfde battle-tested bouwstenen. De open-sourcecultuur stimuleert ook een soort positieve spiraal: “Ik heb dit moeilijke probleem opgelost, nu hoef jij dat niet meer, en je kunt zelfs helpen mijn oplossing te verbeteren in ieders voordeel.”. Het resultaat is dat veel developers meer tijd besteden aan glue code en configuratie dan aan het uitvinden van fundamenteel nieuwe stukken software.

DevOps en automatisering

Nergens wordt “de pijn weg-automatiseren” meer omarmd dan in DevOps. DevOps-engineers schrijven voortdurend scripts en zetten pipelines op om handmatige, complexe processen triviaal te maken met één druk op de knop (of één push van een commit?). Configuratiemanagement-tools (zoals Ansible, Puppet of Terraform) en CI/CD-pipelines (Jenkins, GitLab CI, enzovoort) veranderen wat ooit foutgevoelige deployklussen in meerdere stappen waren in one-click of volledig geautomatiseerde routines. Je zou kunnen zeggen dat het doel is om jezelf weg te automatiseren. In de praktijk betekent jezelf uit je huidige baan weg-automatiseren alleen maar dat je je gaat richten op nieuwe taken met meer waarde. Cope: de baan evolueert in plaats van dat hij verdwijnt (daar komen we later op terug). Wat ooit toegewijde operators en veel zorgvuldig handwerk vereiste, kan nu vaak worden afgehandeld met een handvol regels code, of volledig worden uitbesteed aan cloudautomatisering. DevOps is in wezen de zelftrivialisering van IT-operations.

No-code- & low-code-platformen

De beweging richting low-code of no-code platformen is nog een facet van trivialisering. Diensten als Zapier, SquareSpace, Framer of AI-buildertools willen zelfs niet-programmeurs applicaties laten maken via visuele interfaces en kant-en-klare modules. Ze destilleren de expertise van veelvoorkomende softwareworkflows tot configureerbare componenten die iedereen in elkaar kan klikken. Deze trend trekt het idee van “één keer oplossen voor iedereen” door tot het uiterste: de beoogde gebruiker is iemand die helemaal niet kan coderen, maar wél kan voortbouwen op wat developers al hebben opgelost.

Een kleine ondernemer kan via Shopify of WordPress met plugins een e-commercesite opzetten en zo in één dag bereiken waar een heel devteam 20 jaar geleden maanden aan maatwerk voor nodig had. Professionele developers gebruiken misschien geen no-code-builders voor complexe producten, maar profiteren zelf wel van higher-level frameworks en clouddiensten die complete lagen aan zorgen wegnemen. Een developer die vandaag een webapp bouwt, kan leunen op cloudinfrastructuur (geen fysieke servers beheren), serverless functions gebruiken (geen server-runtime beheren), gebruikers authenticeren via een API (geen auth vanaf nul schrijven), enzovoort. Elke service of elk framework trivialiseert een plakje van de stack.

Generatieve AI

De nieuwste vorm van development trivialiseren is AI. AI-gedreven codingassistenten zoals GitHub Copilot, Claude Code, Cursor of large language models (ChatGPT en vergelijkbare) kunnen codesnippets, functies of zelfs hele modules genereren op basis van natural language prompts of bestaande codecontext. Veel boilerplate- of routinematige codeertaken kunnen daardoor in seconden worden afgehandeld door een AI-suggestie, in plaats van handmatig geschreven.

AI is niet onfeilbaar en vereist nog steeds toezicht, maar het vormt opnieuw een abstractielaag: het abstraheert het schrijven van code zelf. We naderen een punt waarop een developer zich misschien vooral richt op het beschrijven van het probleem en de gewenste uitkomst, terwijl de AI de implementatiedetails afhandelt. Dit is zelftrivialisering on-the-fly: elke individuele developer kan nu via een AI-assistent profiteren van de verzamelde “opgeloste problemen” van de hele programmeercommunity. Het is een sterke opmaat voor de toekomst van development, en één die nieuwe vragen oproept over welke skills developers straks nodig hebben.

Importeren, runnen en door

Op al deze manieren is het patroon consistent: identificeer iets moeilijks of vervelends, los het één keer generiek op (of automatiseer het) en hergebruik die oplossing daarna voor altijd. Wat ooit een uitdaging was, wordt een basisvoorziening.

Het is pijnlijk voor de meeste softwaredevelopers om dit toe te geven, omdat ze zoveel van code houden, maar de beste code is helemaal geen code. Elke nieuwe regel code die je bewust de wereld in brengt, is code die gedebugd moet worden, code die gelezen en begrepen moet worden, code die onderhouden moet worden. Elke keer dat je nieuwe code schrijft, zou je dat met tegenzin moeten doen, onder dwang, omdat je al je andere opties volledig hebt uitgeput. Code is alleen onze vijand omdat er zoveel programmeurs zijn die er zo verdomd veel van schrijven. Als je niet wegkomt met geen code, is het op één na beste om te beginnen met beknoptheid.

Atwoods sentiment vangt de drive van developers om iets niet opnieuw op te lossen als het al opgelost is. Gebruik de import, roep de API aan, run het script en ga door naar het volgende probleem.

Motivaties

Wat drijft dit instinct om ons eigen werk te trivialiseren?

Een van Larry Walls (bedenker van Perl) “drie grote deugden” van programmeurs, is luiheid. Geen luiheid in de zin van niets doen, maar in de zin van nu moeite steken in iets om later veel meer moeite te besparen. Een goede developer schrijft liever een programma dat een repetitieve taak uitvoert (en deelt het) dan die taak steeds opnieuw met de hand te moeten doen. Deze productieve luiheid is een enorme motivator voor automatisering en abstractie. Als iets omslachtig is, voelen we de drang om dat op te lossen met code. Daarmee besparen we niet alleen onszelf toekomstig werk, maar delen we de oplossing ook vaak, zodat anderen niet hetzelfde hoeven te doorstaan.

Dan is er ongeduld; de keerzijde van luiheid. Ongeduld is de ergernis die we voelen als een proces te traag is, waardoor we dingen sneller of efficiënter maken. Developers zijn vaak ongeduldig om resultaat te zien. Duurt het opzetten van een omgeving te lang, dan scripten we het. Is code deployen traag of moeten we wachten op een ander team, dan stroomlijnen we het. Het netto-effect is een duw richting snellere iteratie door zoveel mogelijk frictie weg te nemen, wat natuurlijk betekent dat je bestaande oplossingen of automatiseringen gebruikt waar die er zijn. Ongeduld, in productieve zin, motiveert het bouwen van tools die developmentflows triviaal en instant maken (hot reloading van code, geautomatiseerde cloud-deployments, enzovoort).

De derde deugd is hoogmoed: trots op ons werk, die ons iets wil laten maken waar anderen geen kritiek op hebben. Dit raakt op een paar manieren aan het trivialiseren van problemen: developers zijn er vaak trots op dat ze een generieke oplossing voor een klasse aan problemen hebben gemaakt. Het geeft een gevoel van voldoening om te zeggen: “Ik heb een library gemaakt die probleem X netjes en optimaal oplost.” Maar het is nóg bevredigender als die library breed gebruikt wordt. Een kenmerk van een geweldige engineer is vaak de tools die hij maakte en die anderen adopteren. Deze professionele trots drijft developers om oplossingen te generaliseren tot voorbij eenmalige fixes. In plaats van alleen een bug te patchen in één project, maakt een trotse developer er misschien een framework van, of draagt hij een fix upstream bij zodat het hele ecosysteem verbetert. Hoogmoed in zijn positieve vorm leidt tot die staaltjes engineering die het leven daarna echt simpeler maken voor iedereen.

Businesswaarde

Het is niet allemaal verheven idealisme; er zijn ook pragmatische redenen. In een zakelijke context besparen herbruikbaarheid en abstractie geld en tijd. Als een bedrijf een kant-en-klare oplossing kan pakken in plaats van een engineeringproject van zes maanden te financieren, doet het dat. Developers weten dat en pleiten daarom vaak voor bewezen libraries of services om deadlines te halen. Dit heeft de opkomst gedreven van third-party API’s en clouddiensten die veelvoorkomende functionaliteit afhandelen: e-mail, betalingen, kaarten, authenticatie, enzovoort. Startups kunnen tegenwoordig een geavanceerd product lanceren door getrivialiseerde diensten te combineren die door anderen worden geleverd. Ze richten zich alleen op hun kernidee. De markt beloont dus degenen die complexiteit laten verdwijnen (de hele SaaS-industrie van “X as a Service” draait in feite om complexe capabilities trivialiseren en verkopen).

Developers die in zulke omgevingen werken, internaliseren dat het wiel opnieuw uitvinden zonde van de middelen is. Dit versterkt de cultuur van naar buiten kijken voor kant-en-klare oplossingen en draagt bij aan de cyclus van delen: veel bedrijven open-sourcen hun tools omdat ze weten dat de community ze verbetert, in ieders voordeel. Kortom, getrivialiseerde oplossingen gebruiken en eraan bijdragen is vaak de economisch slimme keuze.

Onderhoud en betrouwbaarheid

Nog een motivatie: een breed gebruikte oplossing is waarschijnlijk betrouwbaarder dan tientallen obscure varianten.

Eenvoud is een voorwaarde voor betrouwbaarheid.

Een codebase wordt simpeler (vanuit het perspectief van een buitenstaander) als die standaard, goed onderhouden componenten gebruikt voor veelvoorkomende taken. Door een populaire library te gebruiken, vermijd je het risico dat je je eigen subtiele bugs schrijft. Je vertrouwt op de beproefde oplossing en vergroot daarmee de betrouwbaarheid. Elke nieuwe regel code is zowel een last als een troef. Die wetenschap moedigt ons aan om er de voorkeur aan te geven iets een non-issue te maken (via een externe oplossing) boven zelf met alle complexiteit dealen. Als we deployment automatiseren, verkleinen we de kans op menselijke fouten. Als we een ORM gebruiken in plaats van raw SQL, verkleinen we de kans op vergissingen. Een drive naar kwaliteit en betrouwbaarheid duwt developers richting bewezen oplossingen.

In essentie trivialiseren developers zichzelf omdat het aansluit bij zowel onze persoonlijke deugden (luiheid, ongeduld, hoogmoed) als onze communitywaarden (delen, samenwerken), om nog maar te zwijgen van praktisch zakelijk inzicht.

Maken we onszelf overbodig?

Als we elk aspect van development blijven trivialiseren, wat blijft er dan eigenlijk nog over voor softwaredevelopers om te doen? Maken we ons eigen werk in feite overbodig door dingen zo simpel te maken dat iedereen ze kan doen (of machines)? Het huidige tijdperk van AI en no-code-tools maakt dit debat relevanter dan ooit.

Een niveau hoger

De geschiedenis laat zien dat developers niet irrelevant worden wanneer taken op een lager niveau triviaal worden. In plaats daarvan verschuiven ze naar problemen op een hoger niveau. Toen assembly machinecode abstraheerde, konden programmeurs zich richten op algoritmes en datastructuren in high-level talen. Toen open source webservers en database-engines voor zijn rekening nam, konden developers zich richten op applicatielogica en nieuwe features. Als AI en no-code nu het routinewerk afhandelen, zullen developers zich waarschijnlijk richten op architectuur, probleemdefinitie, integratie en het aanpakken van nieuwe problemen die nog niet zijn opgelost.

De aard van het werk verandert, niet het bestaan ervan.

Zelfs als een probleem “voorgoed opgelost” lijkt, draait de echte wereld door: requirements veranderen, nieuwe use cases duiken op of technologie verschuift. Het doel om jezelf weg te automatiseren wordt nooit echt bereikt, omdat je rol simpelweg verschuift naar het volgende niveau aan uitdagingen. Of je dat volgende niveau aan uitdagingen ook leuk vindt, is echter een andere vraag.

Nooit eindigende vraag naar nieuwe oplossingen

De software-industrie vindt vaak net zo snel nieuwe problemen als dat ze oude oplost. Elke abstractielaag maakt het mogelijk ambitieuzere oplossingen te bouwen, die op hun beurt weer nieuwe problemen opleveren. Zolang mensen nieuwe ideeën en behoeften hebben, zullen er complexe problemen zijn die nog niet zijn opgelost. Developers blijven nodig om die problemen te begrijpen, en ze misschien uiteindelijk op hun beurt te trivialiseren. De grens blijft opschuiven, en developers schuiven mee.

Veranderende skill sets & AI

De gemiddelde developer van morgen heeft misschien niet dezelfde skills nodig als die van gisteren. Bepaalde low-level skills kunnen uit het dagelijkse werk verdwijnen (net zoals handmatig geheugenbeheer of assembly schrijven, grotendeels). In plaats daarvan worden skills in het integreren van systemen en het begrijpen van grotere architecturen belangrijk, net als kunnen kiezen tussen kant-en-klare oplossingen en maatwerk. Ook “zachte” skills zoals domeinkennis en creatief denken kunnen relevanter worden. Als AI de boilerplate kan schrijven, ligt de waarde van een developer misschien meer in beslissen wat je bouwt, zorgen dat het klopt en de AI begeleiden. We worden misschien meer curatoren van onze tools: output verifiëren en kaders stellen.

Met de hand coderen kan een meer gespecialiseerde activiteit worden in niches waar maatwerk nog nodig is of waar de abstracties nog niet bestaan. 

Meer onderhoud

Niets blijft vanzelf triviaal.

Open-source libraries hebben maintainers nodig; abstracties moeten worden bijgeschaafd terwijl onderliggende platformen veranderen. Er blijft altijd werk in het onderhouden en verbeteren van de “opgeloste” oplossingen zelf. Zo zijn er engineers wier fulltime baan het is om de Linux-kernel te verbeteren, of de taal Python, of de codegeneratie van een AI-model. Die banen draaien om het managen van complexiteit in de kern, zodat de massa developers dat niet hoeft. Zolang we de grenzen van het mogelijke opzoeken, moet iemand zorgen voor de oplossingen die dingen trivialiseren. En naarmate systemen volwassener worden, zit er complexiteit in hun schaalbaarheid en betrouwbaarheid; gebieden die flink wat engineering vragen.

Risico’s, nadelen en fundamenten

Een risico van vergaande trivialisering is dat developers losraken van de fundamenten. Persoonlijk heb ik het gevoel dat juist dit risico nu groter is dan ooit tijdens mijn carrière. Vooral door gen AI. Als iemand op abstracties leunt zonder ze ook maar enigszins te begrijpen, is het gevaarlijk wanneer dingen onvermijdelijk misgaan. Zelfs de beste high-level oplossing kan complexiteit blootleggen als die stukgaat. Het left-pad incident is een grappig voorbeeld. Het laat zien dat developers misschien nét iets te veel hadden getrivialiseerd.

Een andere zorg is te veel leunen op third-party oplossingen. Als elk deel van je stack triviaal is dankzij andermans harde werk, is dat een afhankelijkheidsrisico.

Op de lange termijn moeten developers het gemak van trivialisering in balans houden met de wijsheid om te weten hoe dingen “onder de motorkap” werken, op zijn minst op conceptueel niveau.

Het eindspel

Komt er ooit een punt waarop alles in software triviaal is en developers zichzelf effectief hebben weggeëngineerd? Dat lijkt onwaarschijnlijk. Zolang software wordt geschreven om menselijke problemen op te lossen, en die behoeften evolueren, blijven we nieuwe “onopgeloste” problemen vinden. Het ziet er misschien niet uit als de codeerbaan van vandaag; het draait misschien meer om samenwerken met AI, of om human-computer interaction design, of om iets wat we nog niet eens kunnen voorzien, maar de essentie van oplossingen maken uit ideeën blijft.

Mijn persoonlijke hoop is dat, hoe meer we de mechanica van software maken trivialiseren, hoe meer creativiteit we vrijspelen. We zien misschien een tijdperk waarin de bottleneck niet langer is hóé je iets implementeert, maar wát je implementeert. In dat scenario schuiven developers (of hoe we die rol dan ook noemen) op richting productvisionairs en domeinexperts die tech als medium gebruiken. Triviale softwareconstructie kan toekomstige developers laten focussen op het oplossen van bredere maatschappelijke of wetenschappelijke uitdagingen via software, in plaats van worstelen met boilerplate.

Samengevat is de zelftrivialisering van softwareontwikkeling niet zozeer een weg naar overbodigheid als wel een motor van evolutie. Ze is er altijd geweest: we hebben de noodzaak om handmatig geheugen te beheren, UI’s pixel voor pixel te coderen, servers handmatig te beheren, enzovoort, opgelost en weggeabstraheerd. Onze focus verschuift omhoog en naar buiten, maar het hart van het vak; technologie gebruiken om problemen op te lossen, blijft!

Door zelftrivialisering te omarmen, herdefiniëren we voortdurend onze rol. De trivialiteiten van vandaag waren de doorbraken van gisteren. De uitdagingen van vandaag worden, eenmaal opgelost, de trivialiteiten van morgen. Ons vak is in zekere zin geplande veroudering. We streven ernaar ons eigen eerdere werk overbodig te maken door het onzichtbaar en makkelijk te maken. En daarmee versnellen we het vakgebied.

Conclusie

De zelftrivialisering van softwareontwikkeling draait om een kernethos van onze industrie: los moeilijke problemen op; niet alleen voor jezelf, maar zó dat niemand anders ze ooit nog vanaf nul hoeft op te lossen. Van de vroegste abstracties in het programmeren tot het AI-ondersteunde coderen van vandaag: de rode draad is complexe problemen omzetten in routinehandelingen.

Als developers zitten we in een voortdurende evenwichtsoefening tussen complexiteit en eenvoud. We omarmen complexiteit lang genoeg om haar te beheersen, en dan kapselen we haar in, verstoppen haar achter een interface of automatiseren haar weg, zodat het simpel (of in elk geval simpeler) wordt voor de volgende. Daarmee trivialiseren we aspecten van ons eigen werk, maar zo kunnen wij (en de volgende generatie developers) hoger reiken. Het is intellectueel altruïsme gecombineerd met efficiëntie (of luiheid?).

Vooruitkijkend schetst zelftrivialisering een toekomst waarin developers nog meer empowered worden door tools en abstracties. Het schetst ook een toekomst waarin we moeten blijven leren en aanpassen, omdat wat gisteren een relevante skill was, morgen door een AI of een platform kan worden afgehandeld. Onze waarde zit in hoe snel we nieuwe trivialiteiten kunnen benutten om iets innovatiefs te maken, en hoe effectief we het volgende grote onopgeloste probleem weten te vinden om onze tanden in te zetten.

Uiteindelijk heeft deze cyclus de gewoonte developers niet onbeduidend, maar juist nóg crucialer te maken; alleen opererend op een ander niveau. De wereld zal altijd problemen hebben die om creatieve oplossers vragen. En zolang dat waar is, blijven die oplossers (wij developers) doen wat we altijd al deden: de moeilijke dingen makkelijk maken. De tools en methoden veranderen, maar de missie blijft: neem het complexe en laat het triviaal aanvoelen.

Let’s collaborate

You are now being called to action.Choose wisely

30sec

Pitch

To save us both time, we created a 30-second pitch on why we are the right digital partner for you

Watch pitchicon
10min

Tour

Proposals and pricing? Watch this for everything you need to make the next step

View presentationicon
30min

Discovery call

Ready to speak to a human? We have some of those. Book a No-Commitment discovery call!

Book a callicon