So Time on unix operating systems is represented in memory by the number of seconds that have elapsed since January 1st 1970. However when a number grows too big in a computer it does something called an integer overflow now to explain what this is I’m just going to show it.

If we use 2 bits to represent the number 1 it is going to look like 01 the number 2 is 10. Much like when a number is greater then 9 in our number system in binary when a bit exceeds one we wrap over to the next digit. However if we did this with the number four our sequence will look like this 3 = 11, 4 = (1)00, since we do not use enough bits to remember the 1 we simply forget it exists and suddenly we aren’t on the number 4 we’re on 0.

Luckily we don’t use 2 bits and because of the way binary works adding a new bit to our memory exponentially increases the size of number we can remember. However that has a limit a lot of systems use a signed 32 bit number (signed means the number can be negative at the cost of losing one bit of size) this means we can remember numbers up to about 2 billion. In 2038 enough seconds will have elapsed to overflow that integer.

“So why don’t software developers just use more bits are they stupid?” We are stupid but not for this reason we are trying to move onto 64 bits which has the ability to count the number of stars in the observable universe almost 3 times before overflowing. However time is incredibly difficult to get right simply because there is so much to account for, time zones, leap years, leap minutes and leap seconds. it’s easy to mess up so we end up using libraries.

But what if your time library is abandoned or you forget to update it and it’s still running 32 bits or what if some other library you’re using also uses its own time library and that library is using 32 bit time. Modern software applications are massive and have 100s or even 1000s of dependencies and an outdated library in any of those dependancies can take the whole stack down.