Een nieuwe millenniumbug staat voor de deur: in 2038 wordt het 1901

Licht zou uitvallen, bellen zou onmogelijk zijn, logistiek zou vastlopen, beurzen zouden crashen. Er zou zelfs een onbedoelde kernoorlog kunnen uitbreken door in de war geraakte waarschuwingssystemen. Talloze IT’ers beleefden Oudejaarsavond 1999 achter hun computer op kantoor, klaar om in te grijpen als chaos zou uitbreken. Vliegtuigen werden voor de zekerheid aan de grond gehouden. De nieuwsberichten uit 1998 en 1999 over het millenniumprobleem klinken bij herlezing haast hallucinant.

Eind jaren 90 hield de millenniumbug de wereld volop bezig. Studenten met aanleg voor programmeren werden verzocht een jaar te stoppen met hun studie om bedrijven en overheden te helpen ‘millenniumproof’ te worden – tegen een beloning van tachtigduizend gulden (ruim 36.300 euro). Alleen al in Nederland werd 20 miljard gulden uitgegeven aan het oplossen van het millenniumprobleem. Wereldwijd ging het om vele honderden miljarden.

De millenniumbug was een softwareprobleem: computers zouden denken dat na 1999 het jaar 1900 aanbrak in plaats van het jaar 2000, omdat veel software het jaartal noteerde met alleen de laatste twee cijfers – om ruimte te besparen of omdat de programmeur dat gemakkelijker vond. In de aanloop naar het nieuwe millennium werd alle software doorgenomen om de datumnotatie aan te passen.

In de jaren 70 leek het jaar 2038 nog heel ver weg

Arnd Bergmann ontwikkelaar

„Tijdens die jaarwisseling zat ik echt te kijken wat er met het licht gebeurde”, zegt Jan Friso Groote, hoogleraar embedded systems aan de TU Eindhoven. „Dat bleef gewoon branden. Dankzij de hoeveelheid tijd die er vooraf ingestopt was, dat was excessief. Want het was onmiskenbaar een probleem, overal stonden die twee cijfers. En het kan straks weer een probleem worden.”

‘Straks’, dat is in 2038. Want op 19 januari 2038, om 03:14:08u, is opnieuw een grens bereikt in de tijdnotatie die computers gebruiken. Vergelijkbaar met de millenniumbug zullen tijd en datum terugspringen, in dit geval naar 13 december 1901. Wederom is er een kans dat computersystemen chaos zullen veroorzaken.

Tenzij de tijdnotatie op tijd is aangepast natuurlijk. Met nog bijna 15 jaar te gaan voor het zover is, wordt nu al aan dit ‘jaar-2038-probleem’ gewerkt, en op veel belangrijke plekken is de manier van tijdnotatie al aangepast. Het is opnieuw een kwestie van software doorvlooien.

2.147.483.647 seconden

Het jaar-2038-probleem zit iets anders in elkaar dan het millenniumprobleem. Computersystemen houden datum en tijd bij als het aantal seconden dat verstreken is sinds 1 januari 1970, 00.00 uur en zij slaan dit op als een 32-bit integer. Dat wil zeggen: ze slaan het op als een geheel getal bestaande uit 32 bits, dus 32 plaatsen die een nul of een kunnen zijn. Deze integer kan waarden bevatten tussen -2.147.483.648 (een 1 die bepaalt dat het getal negatief is, gevolgd door 31 keer 0) en 2.147.483.647 (een 0 gevolgd door 31 keer 1). Op 19 januari 2038 zijn er 2.147.483.647 seconden verstreken sinds 1 januari 1970, en als die grens is bereikt springt het notatiesysteem over naar de minimale waarde. Wat in datum uitgedrukt uitkomt op 13 december 1901, al die seconden teruggeteld vanaf 1 januari 1970.

„Deze manier van het noteren van tijd werd voor het eerst gebruikt door het Unix-besturingssysteem en programmeertaal C in de jaren 70, en werd daarna de conventie”, zegt Arnd Bergmann, een ontwikkelaar die werkt aan het opensourcebesturingssysteem Linux. „Onder meer de besturingssystemen Windows, MacOS en Linux namen de manier van tijd noteren over, net als talloze andere software.”

Meteen bij de introductie was duidelijk dat dit 32-bit-format alleen tijd kon representeren tussen 13 december 1901 en 19 januari 2038, zegt Bergmann. „Maar in de jaren 70 leek het jaar 2038 nog heel ver weg. Uitgebreidere tijdnotatie was ook toen al mogelijk, maar dat zou systemen onnodig traag hebben gemaakt en energieverkwistend zijn geweest.”

Voor een mens erachter komt dat dit is gebeurd, kan er al veel schade geleden zijn

Jan Friso Groote TU Eindhoven

Het werd 32-bit dus. Maar inmiddels is het jaar 2038 tamelijk dichtbij.

De gevolgen van het jaar-2038-probleem kunnen miniem tot groots zijn. „De processen in computersystemen die met 32-bit-tijdnotatie werken stoppen ermee na 19 januari 2038, of ze gaan berekeningen doen met die grote negatieve getallen”, zegt Groote. „Neem bijvoorbeeld processen die checken of er vanaf het internet iets binnenkomt of processen die om de zoveel tijd opgepord worden, zoals een screensaver. Als de tijd ineens terugvalt krijgen die processen geen signaal meer om iets te doen.”

Nou is dat bij een screensaver niet zo erg. De gevolgen zijn van een heel andere orde als dit bijvoorbeeld in banksystemen mis gaat. „Denk aan renteberekeningen”, zegt Groote. „Als het banksysteem ineens denkt dat het rente moet uitkeren die niet is opgebouwd sinds vorige maand, maar sinds honderddertig jaar geleden, dan gaat het om enorme bedragen. Heel veel van zulke processen gaan volledig automatisch, en voor een mens erachter komt dat dit is gebeurd, kan er al veel schade geleden zijn.”

Schade bij een pensioenfonds

Dat dit laatste geen denkbeeldig voorbeeld is blijkt wel uit een reeks tweets die de Amerikaanse software-ontwikkelaar John Feminella in 2020 op Twitter postte. In vijftien tweets legt hij uit wat bij een opdrachtgever, een groot pensioenfonds, in 2018 gebeurde. Om de hoogte van pensioenbijdragen te bepalen werkt een pensioenfonds met verwachtingen over de toekomstige economie. Op een nacht ging een script stuk dat voor 20 jaar vooruit projecties maakt, voorbij de grens van de tijdnotatie dus. Dit was op zich nog niet zo’n groot probleem, maar andere programma’s van het pensioenfonds waren gekoppeld aan de uitkomsten die het projectiescript geeft. Een van die andere systemen kwam bij gebrek aan gegevens tot de conclusie dat er over 20 jaar 0 dollar zou worden ingelegd.

Er gingen allerlei alarmbellen af, zonder inkomsten kan een pensioenfonds niet uitkeren aan de gepensioneerden. De inleg nu zou enorm moeten veranderen wil je zoiets opvangen. En waarom dacht het systeem eigenlijk dat de economie er over 20 jaar zo belabberd voor zou staan dat er geen inkomsten meer zouden zijn? Voor de zekerheid werden alle systemen stilgelegd.

Het is geen verplichting om tijdnotatie van het besturingssysteem over te nemen

Arnd Bergmann ontwikkelaar

Maar wat er onder de motorkap was gebeurd, was niet meteen duidelijk. Het projectiescript had nog nooit gefaald, en de code ervan was moeilijk te doorgronden – de maker ervan was al vijftien jaar overleden. „We hebben uiteindelijk alle scripts geïsoleerd laten draaien en zo werd duidelijk waar het probleem zat”, schrijft Feminella. „We konden het oplossen, maar er was al veel schade geleden want de pensioenbijdragen waren een tijdje niet doorgevoerd. Het kostte het pensioenfonds uiteindelijk 1,7 miljoen dollar om dit in de twee weken daarna handmatig weer recht te breien.”

De moraal van het verhaal is dat het jaar-2038-probleem er niet ‘aankomt’, het ís er al. „Fix your stuff”, besluit Feminella zijn berichtenreeks.

Het probleem is goed op te lossen, door de tijd niet in 32-bit maar in 64-bit te noteren. Dan kunnen computers ineens weer miljarden jaren vooruit (9.223.372.036.854.775.807 seconden vanaf 1 januari 1970).

Oudere systemen

Veel computers draaien al lang op 64-bit-processoren, en inmiddels de meeste smartphones ook. Hoe groot is dit probleem eigenlijk? „Op 64-bit-computers is de meest natuurlijke manier om tijd te noteren in 64 bit”, zegt Bergmann. „De meeste software kiest ervoor om de tijd te noteren op de manier die het besturingssysteem aanhoudt. Bij Linux heeft een van mijn voormalige collega’s, Deepa Dinamani, enige jaren terug veel tijd gestoken in het aanpassen van het tijdformat naar 64 bit.”

Ook in Windows is de standaard tijd-datumnotatie inmiddels 64 bit. Dat klinkt alsof het met eventuele algehele ontwrichting mee zal vallen.

„Maar het probleem is, het is geen verplichting om tijdnotatie van het besturingssysteem over te nemen”, zegt Bergmann. „Software, of eigenlijk degene die het programma heeft geschreven, kan zelf kiezen om het anders te doen. Zo’n fout kan erin sluipen als je bijvoorbeeld de software met oudere systemen wilt laten communiceren.”

Software kan een warboel veroorzaken als er iets onverwachts gebeurt

Jan Friso Groote TU Eindhoven

„De meeste computers en telefoons die nu nog op 32 bit draaien zullen tegen de tijd dat het 2038 is wel vervangen zijn”, zegt Bergmann. „Maar vooral software die apparaten of installaties aanstuurt, embedded systems, gaat soms heel lang mee en krijgt vaak geen updates. Sommige systemen kunnen een hoop chaos veroorzaken, bijvoorbeeld in de luchtvaart, het leger en bij infrastructuur.”

„De kern van het verhaal is niet dat de oplossing zo moeilijk is, de kern is dat er zo gruwelijk veel software is”, zegt Groote. „Alles wordt tegenwoordig aangestuurd door software, tot het slot op de fiets aan toe. Je moet uitzoeken waar het probleem zich wel en niet voordoet. Het gaat over miljarden en miljarden regels software, kun je dat detecteren?”

Stilstaande trein

Mensen moeten software serieuzer nemen, vindt Groote. „Software kan onbegrensd ingewikkeld worden. Je weet vaak niet wat een programma voor gedrag gaat vertonen als je afwijkende waarden ingeeft. Onverwacht gedrag kan zich ook na jaren gebruik pas voordoen. Ik heb het gezien hoor, bij bediening van bruggen, een sensor geeft een foutieve waarde aan en ineens doet een brug iets wat niet de bedoeling is. En denk nog even aan de treinen van Fyra. Daar was niks mis met de trein zelf, maar de software dacht dat hij op volle snelheid de verkeerde kant op reed en voor de zekerheid ging hij dan maar stilstaan. Software kan een warboel veroorzaken als er iets onverwachts gebeurt.”

Bijkomend obstakel: van lang niet alle software kun je als gebruiker zomaar de broncode doornemen, als de kennis om die te begrijpen er al zou zijn. Bergmann: „Systemen die op Linux draaien zijn veelal open source, iedereen kan de code inzien. Dat geldt voor de meeste software niet, daar is de code alleen beschikbaar voor de originele auteur. Hoe groot het jaar-2038-probleem eigenlijk is, weet dus niemand precies.”

Gelukkig is er ook veel ten goede veranderd sinds het jaar 1999. „Toen was code tamelijk low level, veel meer houtje-touwtje”, zegt Groote. „Heden ten dage werken ontwikkelaars veel professioneler, het is gebruikelijker om netjes te programmeren en te documenteren. Daar hoort het gebruik van een standaard tijd-datumstructuur ook bij. Er moet echt nog wel wat aan dit probleem gebeuren, maar het meeste zal vanzelf goed gaan.”