In 1999, corporate America was gripped by a fear – that the flipping of the calendar to 2000 would cause significant problems. Then 2000 came not with a bang, but with a whimper.

I was chatting with my brother yesterday, and he seems to be of the opinion that the entire situation was overblown. Was it – or were the fears well founded? This article is a decade late, but let’s take a deeper look at the Y2K bug.

What’s the problem, exactly? The problem was that many older computer program stored dates with two digit years instead of four digit years. This would cause a problem when the date flipped to 2000. Let’s use a simple example.

Let’s say the Social Security Administration had a computer program that checked to see if you were old enough to receive benefits. Let’s say that your birth date is January 1, 1920. This would be shortened to 01-01-20 in their system. This works fine in 1999. 1999 would be shortened to 99, and when the SSA computer takes the current data and subtracts your birth date, they determine that you are 79 years old (99-20).

Let’s flip to 2000. The program would shorten 2000 to 00. What does the program get when it takes the current date and subtracts your birth date? 80? Nope … -20.  (Yep, 00-20 = -20.  No check for you!)

This is a simple example. Any program using two digit years would have encountered problem. Imagine a nuclear power plant that used a program to determine if scheduled maintenance was needed …

Why didn’t they get it right the first time? An interesting thing about the Y2K bug is that is really wasn’t a bug. The programs were working exactly as designed – and the two-digit year was an intentional piece of the design. You could argue that it was a design flaw, but that would be pretty harsh. The real issue is that storage space at the time was much, much more expensive than it is today. Absurdly expensive. Using a two-digit year instead of a four digit year saved space, and thus money.

Certainly the programmers knew that the year 2000 would create problems. However, even the most optimistic programmers of the 1960s and 1970s could never have imagined that their programs would still be in use 30-40 years later.

What happened is that companies kept adding to the existing code base. Some programming languages were extremely good at certain tasks and simply refused to succumb to obsolescence. COBOL, I’m looking at you.

OK, then why didn’t they fix it later? I honestly think that each generation of programmers kept thinking that the old code would eventually be replaced by a completely new architecture, and that this resulted in less emphasis being placed on fixing Y2K issues. Going back and fixing all the instances of two digit dates would be a long process, with lots of testing. Simply building a new system would avoid this effort entirely.

Unfortunately, those replacement systems never got built, for a variety of reasons – lack of funding, or simply because the new languages simply couldn’t compete with the older ones. Finally, when Y2K was just around the corner, companies realized that something must be done, and NOW. Millions upon millions of hours were poured into testing and fixing problems with Y2K compliances issues.

OK, why didn’t I hear about any Y2K problems? In large part, Y2K went off without major problems because of the diligent work of programmers and other analysts. I have firsthand knowledge of this, having been in the trenches at the time.

There actually were some Y2K related problems. If you had your ear to the ground in early 2000, you may have heard about them. Of course, the public was expecting a dynamite-sized explosion and didn’t notice the firecrackers.

Another reason is that some people were looking in the wrong places. Your relatively new desktop computer was not going to stop working, your TV was not going to switch to black and white, nor was your freezer was not going to start boiling food. Even somewhat large companies could sidestep the issue if they were new enough to note have lots of code from the 60s and 70s lying around. The vulnerable systems were those belonging to major corporations.

The Y2K bug was definitely not a hoax. We dodged a bullet because a lot of people worked very hard in the late 90s to fix the problem.


Share this article via email

Kosmo is the founder of The Soap Boxers and writes on a variety of topics. Many of his short stories have been collected into Kindle books.

Like this site? Subscribe via RSS, Subscribe via Email, or Follow us on Twitter or Facebook.

The permanent URL for this article is: