Today's article is a little special because it is Halloween, the festival that marks the turn of October into November and which, in popular tradition, is ironic and irreverent.
Since we are a little ironic and irreverent ourselves, we thought we would mark the occasion with this article to tell you some tales of error, or rather of HORROR, from the world of IT.
We are talking about ten very serious "historic cases" in which a programming error caused genuine disasters that cost those responsible a great deal of money and their reputation. And, in the last case, sadly also human lives.
They are more or less well-known cases that all share one moral: a programming error is always lurking around the corner, because no project or software – however commendable the effort that went into it – is infallible.
We said it in our last article and we repeat it today: programming requires considerable intellectual effort, as well as adequate technological and financial resources. In our own small way, here at ESSE I we do our best to reduce the risk of errors. For example, before releasing new software we run a lot of tests. Our philosophy, after all, is harmony, a value we try to apply every day both in our relationships with stakeholders and in our approach to coding. Because it is not enough for software to look good; it also has to work well. For us, a lot depends on striking the right balance between the two.
But today we set harmony aside! Our motto will be "horror, not just bits".
Ready, then, for this short but scary journey into the world of IT failures?
1) The "Pentium FDIV" bug
In 1994 Intel, the world leader in microprocessors, released a faulty version of its first processors (with clock speeds up to 100 MHz) in the Pentium line. In practice, it produced and shipped thousands of units that returned incorrect results in some floating-point division operations.
The curious thing is that the error was not discovered by Intel but by a mathematics professor at an American college (Professor Nicely) while researching prime numbers and "Brun's constant".
The error cost the company a lot of money (almost 500 million dollars) in chip recalls and replacements.
(source: Wikipedia)
2) The failures of Ariane 4 and Ariane 5
Apart from the Intel case, the best-known "IT horrors" of the last century relate to the aerospace sector. Partly because the internet (and therefore the "security" problem) had not yet taken off, partly because of the media attention given to anything space-related, and partly because of the enormous resources (financial ones too) invested in this kind of project. This "horror story" and the next one are, in fact, out of this world.
The first two cases took place in 1996 and concern the European Ariane programme.
The first serious "horror" occurred during the launch of an Ariane 4 rocket and was caused by a division-by-zero exception in the guidance software that led to the flight being aborted. A bug that caused the loss of four satellites and millions of dollars of damage.
But the most serious failure was the next one, on 11 June 1996, when the maiden flight of Ariane 5 ended in disaster shortly after lift-off. Here too, the cause was a coding error in the flight control software, which tried to convert data from 64 bits to 16 bits, causing an arithmetic exception and the crash of the guidance system.
The accident destroyed the launcher and the satellites on board, causing huge financial losses.
3) The Mars Pathfinder and Mars Climate Orbiter errors
Just a year after the Ariane 4 and 5 disasters, during NASA's Mars Pathfinder mission, an error converting units between the metric and imperial systems led to the failure of the landing module. This further error showed how important consistent units of measurement are when working on space missions.
It sounds like a joke, but despite the lessons learned from the Mars Pathfinder error, just two years later NASA also lost the Mars Climate Orbiter probe because of the same unit conversion error. This bug, not fixed in time, brought the probe too close to Mars during orbital insertion, causing its destruction.
(source: Wikipedia)
4) The millennium bug
Anyone over forty will surely remember the "millennium bug".
At the end of the 1990s there was widespread anxiety about the Y2K bug, a problem caused by the fact that many computer systems of the last century used two-digit dates to represent the year (to save memory: it may seem crazy now, but back then memory and storage space were extremely limited), and it was feared this would cause problems when the year went from "99" to "00".
The correction and system migration efforts took enormous resources: the cost of the fix is estimated at between 200 and 600 billion dollars, making the millennium bug probably the most expensive bug in history.
(source: Wikipedia)
5) The Skype outage
In 2007 an IT incident occurred when a bug in Skype's software (not yet owned by Microsoft, which bought it in 2011) caused a global service outage, making it impossible to make calls or send messages for many hours. At the time Skype was the undisputed leader in video calling, so the damage to its image was significant.
This bug highlighted our dependence on software-based communication services and the need, from then on, for greater robustness and resilience.
(source: The Guardian)
6) The collapse of Knight Capital Group
Knight Capital Group, a major high-frequency trading firm, suffered huge financial losses because of an incredible software error.
On 1 August 2012, an incomplete and untested update was deployed to the firm's trading system, causing thousands of erroneous orders to be executed and leading to losses of around 440 million dollars in less than an hour.
The error was a clear example of the risks associated with high-frequency trading and of the importance of testing software rigorously, in finance as elsewhere.
(source: Wikipedia)
7) The Heartbleed bug
Heartbleed is a serious and famous programming error discovered in 2014 in OpenSSL, a library widely used to encrypt data on the internet. This security bug allowed potential attackers to access confidential information, such as encryption keys and user data, without leaving a trace.
The error had a significant impact on the security of many web applications and online services.
(source: heartbleed.com)
8) WannaCry
WannaCry was a "ransomware" attack in 2017 – that is, one that demands a ransom from its victims (usually in cryptocurrency) – carried out on a global scale by exploiting a previously disclosed vulnerability, and therefore a coding error, in Windows.
Many systems had not applied the critical security update, which allowed WannaCry to spread rapidly, causing financial damage and locking up many computers around the world.
(source: Wikipedia)
9) The Google+ bug
Not everyone knows or remembers that one of the possible reasons why Google+ – Google's social network – was shut down is a software bug which in 2018 had allowed developers to improperly access user data. Instead of disclosing the vulnerability, Google chose not to make the error public until it was discovered by third parties.
This led to the early closure of Google+ and to investigations into how the vulnerability had been handled.
(source: Wikipedia)
10) The Boeing 737 MAX
The 2018 and 2019 crashes of two Boeing 737 MAX aircraft (Lion Air and Ethiopian Airlines) were attributed to a design flaw in the MCAS flight control software. This error caused the loss of both aircraft and, tragically, the death of everyone on board.
The two tragic air disasters and the related technical and legal issues led to a complete overhaul of the MCAS system, as well as raising serious concerns about aviation safety.
(source: Wikipedia)
As you will have read and, we hope, understood, programming is an activity that carries a certain responsibility. A responsibility that grows with the importance of the field in which the software "runs".
Think of the medical or security sectors, for example. Or, as we have seen, aviation.
But, especially if you are reading this article on Halloween night, we don't want to lecture you. We just want to remind you of the importance of software quality and careful test planning.
It must be said that although the "IT horror stories" we have told you are tragic, and the last one in particular very sad, they do have at least one positive side: these bugs led to huge improvements in software development and management practices to prevent similar incidents in the future.
After all, as the saying goes, we learn from our mistakes. But be careful not to overdo it!
And to those reading us between 31 October and 1 November... happy Halloween!
