Waarom is ICT complex?

Waarom is ICT complex?

Dat ICT complex is, lijkt iedereen te begrijpen. Maar hoe is dit zo gekomen? In deze blog proberen we dit vanuit historisch perspectief te verklaren. Aan de hand van de belangrijkste technische ontwikkelingen die de evolutie van ICT hebben voortgedreven zullen we aangeven wat deze ontwikkelingen aan de toenemende complexiteit hebben bijgedragen.

Technische ontwikkelingen ontstaan niet per toeval, maar worden gedreven door nieuwe inzichten, vragen vanuit de markt en ideeën over verbeteringen. ICT heeft van veel verschillende ontwikkelingen geprofiteerd, en daarmee op verschillende gebieden een evolutie doorgemaakt. Deze evoluties werden niet volgordelijk doorlopen, maar liepen parallel en beïnvloedden elkaar, zodat ze als dimensies gezien kunnen worden.

Computers bestaan al heel lang

Machines die berekeningen kunnen uitvoeren bestaan al eeuwen. Ze konden eenvoudige rekentaken uitvoeren of werden gebruikt om eenvoudige processen aan te sturen (b.v. weefgetouwen). De machines waren mechanisch, complex en vaak lastig te realiseren met de in die tijd beschikbare technieken.

Al in de 19^e eeuw ontstonden er ideeën over de mogelijkheden die een machine zou kunnen bieden voor het uitvoeren van complexe berekeningen, en zelfs hoe zo’n machine gebouwd zou moeten worden. Charles Babbage ontwierp een ‘Analytical Engine’ die kan worden beschouwd als de eerste computer. Deze, door stoomkracht aangedreven machine, ondersteunde al rekenkundige logica, kon primitieve programma’s uitvoeren, werd gevoed met gegevens en programma’s op primitieve ponskaarten en kon uitvoer zelfs middels een printer afdrukken. Helaas kwam het niet tot de volledige bouw, het bleef grotendeels bij een ontwerp.

Tijdens de Tweede Wereldoorlog nam de ontwikkeling van de computer een hoge vlucht. De eerste elektronische computers werden gebouwd. Hoewel revolutionair voor hun tijd, was een brede toepassing van deze computers nog ver weg. Deze eerste computers waren handgemaakte, grote dure, complexe machines die voornamelijk werden ingezet voor zeer specifieke toepassingen (het breken van codes). Bovendien konden deze computers slechts door specialisten worden gebouwd, geprogrammeerd en bediend.

Om de computer te kunnen inzetten voor meerdere doelen en voor (veel) meer gebruikers zou nog veel technologische ontwikkeling nodig zijn. Deze ontwikkelingen zorgden er enerzijds voor dat toepassingen makkelijker te realiseren en functioneel omvangrijker werden, maar anderzijds voor toenemende complexiteit. Dit is een tegenstelling die aan de hand van een aantal voorbeelden in de onderstaande tekst wordt toegelicht.

Evolutie dimensie: fysieke realiseerbaarheid en betrouwbaarheid

Bij de bouw van een mechanische computer als die van Babbage liep men aan tegen de fysieke grenzen wat je met mechanische onderdelen nog betrouwbaar en betaalbaar kon bouwen. Doordat begin van de 20ste eeuw gebruik kon worden gemaakt van elektriciteit en electronica, konden primitieve schakelingen worden gebouwd waarmee de computer in kracht toenam. De snelheid en betrouwbaarheid liet echter veel te wensen over. Doordat de computers bijvoorbeeld nog analoog gegevens verwerkten, was de betrouwbaarheid bijvoorbeeld afhankelijk van de fysieke omstandigheden waarin deze gebruikt werden. Toen computers gegevens digitaal gingen opslaan en verwerken, en zaken als foutcorrectie mogelijk werden, nam de betrouwbaarheid significant toe. Met de uitvinding van elektronische componenten als transistoren en integrated circuits (chips) die in computers toegepast konden worden, nam de betrouwbaarheid en de verwerkingssnelheid enorm toe en namen de productiekosten af.

Kortom: een toename in betrouwbaarheid en snelheid betekende afname van transparantie. Immers: het proces was niet meer zichtbaar, alleen het resultaat.

Evolutie dimensie: Schaling en flexibiliteit door opdelen in meerdere abstractie niveaus

Met het door Von Neumann geïntroduceerde stored-program concept is de basis gelegd voor de moderne computer. Door de programmatuur te scheiden van de processor en in het geheugen onder te brengen, wordt de computer veel flexibeler. Het programma is nu immers te wijzigen door nieuwe instructies in het geheugen te laden in plaats van dat een engineer nieuwe fysieke verbindingen moet aanleggen. Hiermee is ook de eerste abstractie een feit, de code staat nu los van de hardware.

Een belangrijke ontwikkeling die volgde op de Von Neumann architectuur is de introductie van het Operating System (OS). Het OS is te zien als een abstractielaag die de aansturing van de hardware en randapparatuur (voor bijvoorbeeld data opslag) verbergt voor de applicatieprogrammeur. Met het OS worden ook nieuwe mogelijkheden als het ’gelijktijdig’ draaien van meerdere programma’s (time sharing) en het ondersteunen van meerdere gebruikers (multi-user) mogelijk. Op, of als onderdeel van het OS komen ook specifieke toepassingen beschikbaar die het gebruik vereenvoudigen, zoals bijvoorbeeld bestandsbeheer.

Functionaliteiten die door meerdere programma’s worden gebruikt, groeien uit tot zelfstandige applicaties. Denk hierbij aan database management systemen. Eén DBMS kan zo meerdere toepassingen bedienen, maar is in zichzelf een complexe toepassing.

Kortom:

Deze ontwikkelingen maakten het voor ontwikkelaars makkelijker om programma’s te maken, maar de totale complexiteit van IT nam wel toe. Immers: voor de uitvoering van deze programma’s was extra programmatuur nodig om de processen te kunnen coördineren.

Evolutie dimensie: van exclusieve toepassing naar massagebruik (schaling)

De eerste computers werden gebouwd met vacuumbuizen, waren kamervullend en exorbitant duur. Dankzij de uitvinding van de transistor en later het Integrated Circuit (IC) werd de miniaturisering van de computer ingezet. Doordat steeds meer transistoren op een IC konden worden geplaatst nam de verwerkingskracht enorm toe. Ook massaproductie werd daardoor mogelijk en de prijs daalde, waardoor de aanschaf van een computer ook voor kleine bedrijven en consumenten (homecomputer) haalbaar werd.

Met het steeds breder beschikbaar worden van computers is ook de behoefte aan software-toepassingen sterk gestegen. Keerzijde van deze toename is dat daardoor de beheersbaarheid onder druk komt te staan.

Maar ook deze evolutielijn bracht extra complexiteit met zich mee:

• In het algemeen zorgt ‘massa’ ervoor dat problemen voor kunnen komen op meerdere lokaties, waardoor de kans dat problemen ontstaan groter wordt en relatief kleine problemen door schaling ineens groot en complex kunnen worden. Ook wordt de tijdspanne waarin problemen ontstaan en opgelost groter.
• Toename van gebruikers vergt meer capaciteit, waarmee schaalbaarheid een belangrijke factor wordt.

Kortom: Massa is kassa maar heeft ook grote impact op beheer, gebruik, ondersteuning, wijzigingen et cetera.

Evolutie dimensie: gedistribueerde verwerking (netwerken, internet en mobiele revolutie)

Met de opkomst van netwerken en het internet vindt de verwerking niet altijd meer plaats op de computer waar je achter zit maar vindt deze veelal gedistribueerd over het netwerk, of in geval van het internet over de wereld plaats. Het Client/Server-model stond aan de basis van deze ontwikkeling. In deze tijd van Micro Service Architectuur en API’s kunnen vele computers (al of niet virtueel) betrokken zijn bij de verwerking van een voor het oog van de gebruiker eenduidige applicatie. Doordat de dataverwerking op meerdere plaatsen plaats vindt wordt complexiteit toegevoegd waardoor de  kans op fouten toe neemt. Ook zijn fouten in een gedistribueerde omgeving lastiger op te sporen.

Met de komst van de smartphone zijn mensen bijna continue met internet verbonden en worden apps de hele dag door gebruikt (Any time, any place, anywhere, on any device). Zeker voor de jongere generaties is het gebruik van ICT daardoor een belangrijk deel van hun leven geworden.

De grote variatie aan apparatuur, Operating Systems (Android, Windows, Apple IoS, Linux…) en applicaties samen met het feit dat niet ieder apparaat centraal wordt beheerd, zorgen voor een omvangrijke, complexe  en dynamische lappendeken van versies van programmatuur. Ook dit doet de complexiteit toenemen. Applicaties zijn tegenwoordig afhankelijk van een hele keten aan zelfstandige softwarecomponenten. Als een van de schakels het niet doet kan de hele keten uitvallen. Recentelijk werd dit pijnlijk zichtbaar door een storing bij een Content Delivery Network (CDN) waardoor vele websites en mobile apps niet konden werken.

Kortom: Any time, any place, anywhere, on any device geeft de gebruiker veel vrijheid, maar gaat ten koste van de beheersbaarheid. Immers: doordat veel verschillende processen onafhankelijk van elkaar werken is coordinatie van gegevensverwerking lastiger.

Evolutie dimensie: programmeren

De eerste automaten werden ontworpen voor vaste en specifieke werkzaamheden die in vaste stappen moesten worden uitgevoerd; bijvoorbeeld het aansturen van weeftouwen en het uitvoeren van eenvoudige berekeningen. Op basis van Babbage’s rekenmachine bedacht Ada Lovelace halverwege de 19^e eeuw echter dat deze machines voor veel meer opdrachten konden worden ingezet wanneer ze via losse ponskaarten instructies (een soort ‘programma’) en gegevens toegediend konden krijgen. Turing ging in 1936 een stap verder. Voortbouwend op de ideeën van Lovelace en Babbage publiceerde hij zijn ideeën over een wiskundig model voor gegevensverwerking. Dit model, de zogenaamde Turing-machine, beschrijft hoe ingevoerde gegevens in stappen kunnen worden verwerkt en tot uitvoergegevens leiden. De Turing machine werd de basis voor de werking van moderne computers. En dat is het model nog steeds; het is bepalend voor de complexiteit van problemen waarvoor we computers kunnen inzetten. Een programma ‘werkt’ als het ware als een Turing machine.

Middels de eerste echte programmeertalen kon de programmeur met primitieve instructies, specifiek voor iedere computer waarop die werden uitgevoerd, eenvoudige programma’s maken. Deze ‘machinecode’ kon goed door machines gelezen worden, maar was voor de mens een grote verzameling lastig te doorgronden cijfers en letters. Door deze primitieve taal leesbaarder te maken ontstond Assembly Code. Door talen met krachtiger instructies te ontwikkelen konden met minder programmacode, meer problemen opgelost worden. Met de introductie van deze hogere programmeertalen, werd het mogelijk beter leesbare code te schrijven die ook beter aansloot bij de taal die de business spreekt. Zo ontstonden voor veel verschillende business gebieden specifieke talen. Ook werd het met zogenaamde low code platformen mogelijk om met relatief weinig programmacode applicaties te maken, waarbij een groot deel van de code automatisch werd gegenereerd. Deze talen zijn bijzonder efficiënt voor het maken van applicaties voor de klasse van problemen waarvoor ze zijn ontworpen. Het oplossen van problemen buiten de klasse waarvoor ze zijn ontworpen leidt meestal tot complexe constructies.

Door deze sterke ontwikkelingen ontstond een explosieve groei van programmatuur. Dit zorgt voor anderssoortige complexiteit.

Wanneer verschillende ontwikkeltalen worden gebruikt is het lastig het geheel te overzien. De talen, en daarmee programmatuur, sluiten namelijk niet altijd goed op elkaar aan. Net zoals de specialisten in deze talen. Door deze complexiteit ontstaat begripsverwarring. Moderne talen zijn weliswaar krachtig, ze zijn ontworpen voor problematiek op een (veel) hoger abstractieniveau dan machine code en daarmee niet geschikt voor ieder probleem waarvoor een lagere programmeertaal wel geschikt voor zou kunnen zijn. Een taal gebruiken waarvoor deze niet geschikt is, veroorzaakt extra complexiteit omdat ‘trucs’ (lastig te doorgronden en onderhouden taalconstructies) moeten worden gebruikt om toch het doel te bereiken.

Kortom: Met hogere, krachtiger of specialistischer ontwikkeltalen kun je sneller en gemakkelijker ontwikkelen, maar kan spraakverwarring veroorzaken en is niet altijd de juiste taal voor de problematiek.

Dus: Wat maakt ICT complex?

Technologische vooruitgang maakt meer mogelijk: meer toepassingen voor meer mensen. Maar wat maakt dat complex? Complexiteit ontstaat rond grenzen, in de breedste zijn van het woord. Grenzen in capaciteit, sterkte, verantwoordelijkheid, bereikbaarheid, begrip enzovoort enzovoort. Bovendien zijn deze grenzen continu in beweging; immers: programmatuur en apparatuur wordt continu aangepast en vervangen, en oplossingen zijn mobiel en worden in voortdurende veranderende contexten gebruikt.

Deze grenzen moeten bewaakt worden, immers: want wanneer grenzen overschreden worden, kan een oplossing of technologie niet meer als verwacht werken. Inzicht in dit voortdurend veranderende ecosysteem van techniek is cruciaal, en dat is een behoorlijke uitdaging. Doordat continu grenzen worden toegevoegd en worden verlegd wordt het ecosysteem groter en lastiger te beheersen en is specialisatie nodig. Specialisten werken vaak in verschillende domeinen en op verschillende abstractieniveaus, waarbij ze vaak hun eigen ‘taal’ gebruiken. Hierdoor is het krijgen van een gezamenlijk inzicht een extra uitdaging, wat de complexiteit doet toenemen.

Complexiteit kan gereduceerd worden door deze te verpakken in raamwerken of platformen. Dit lijkt vaak een mooie oplossing, maar kan aanvullende complexiteit veroorzaken doordat grenzen onzichtbaar worden.

Binnen de ICT hebben we dus nog wel wat huiswerk om ervoor te zorgen dat we de complexiteit beheersbaar houden en tegelijkertijd nieuwe technologieën en mogelijkheden te omarmen en te benutten.

Maar dat maakt ICT wel zo leuk om in te werken!

Authors

Hans van Rijs	Andre Schrander