Bizarre bugs and the stories behind them

Software development and the benefits of working with offshore teams: efficiency, expertise and cost savings

Searching the World Wide Web for strange, amazing, and funny bugs reveals many interesting stories. In this post, we’d like to summarize a few famous bug cases—from amusing to highly destructive. Interestingly, the discovery and resolution are often as intriguing as the bugs themselves.

The 500-Mile Email Bug

One of the most peculiar bugs was found in a university’s email system. A professor noticed that emails sent to recipients within a 500-mile radius were delivered without issue, while those sent to more distant recipients never arrived.

How could this be? After much puzzling and code examination, it turned out the error lay in a timeout parameter based on the time it took for light signals to travel a certain distance. Since the developers used the speed of light in their calculation, it resulted in a very real, albeit unintended, “horizon” of 500 miles for email communication. Adjusting the timeout parameter resolved the bug.

This bug is also responsible for the name of a newsletter and blog dedicated solely to absurd software bugs. The noteworthy newsletter is called 500 Mile Email and was founded by Harley Hicks.

The Mars Climate Orbiter

The Mars Climate Orbiter was a NASA probe sent to Mars in 1999 as part of the Discovery program but ultimately disintegrated due to a famous yet simple software bug. This ignominious end to a highly technological system of its time was caused by a simple unit conversion error: While the navigation team conducted calculations in metric units, the orbiter’s software used imperial units. It used units like pounds (for weight), inches and feet (for length), and gallons (for volume), differing from metric units like kilograms, meters, and liters. This discrepancy caused the orbiter to fly much closer to Mars than planned, ultimately leading to its demise in the Martian atmosphere.

What can we learn from this? The incident underscores the importance of agreeing on common standards and communication formats in software development and consistently adhering to those committed standards.

The Pentium FDIV Bug

Another extremely famous example is the FDIV bug in Intel’s Pentium processors in the mid-1990s. This flaw in the floating-point division operation caused the processor to produce incorrect results under certain divisions. Although the bug only occurred under very specific conditions and most users would likely never notice it, the public attention it received ultimately led Intel to initiate a recall. This incident highlighted the importance of accuracy in hardware development and the public’s growing awareness of technical details.

The bug is so well-known that it has its own Wikipedia article, which you can read here.

The Y2K Bug

One of the most famous and potentially catastrophic bugs in the history of technology was the Y2K bug, also known as the Year 2000 problem. The bug stemmed from the practice of encoding the year in computer systems with only two digits (e.g., “99” for 1999) to save memory space. This led to widespread concern that at the turn of the millennium from 1999 to 2000, computer systems would interpret the year “00” not as 2000 but as 1900, leading to erroneous calculations and failures in everything from banking systems to power plant controls.

Billions were invested worldwide in addressing the problem by updating software and testing systems to ensure they could handle the new millennium correctly. Thanks to these efforts, the feared catastrophic effects were largely averted, and the Y2K bug serves today as a cautionary tale about the importance of proactive planning in software development.

The Heartbleed Bug

Heartbleed was a serious security flaw in the OpenSSL software library discovered in April 2014. OpenSSL is widely used to implement the SSL and TLS protocols for internet communication, providing encryption for a variety of services to protect sensitive data like passwords and personal information.

The bug allowed attackers to read the memory of web servers, gaining access to a large amount of sensitive and confidential data without leaving any traces. What was concerning in this case wasn’t just the ease of exploitation but also the fact that the bug remained undiscovered for about two years.

Heartbleed ultimately led to increased investments in the security of open-source software and a better understanding of the importance of security in the digital world.


These anecdotes illustrate that bugs in software development can sometimes take bizarre forms. This should remind us that despite all advancements in technology, there’s still room for (human-made) errors, oversights, and misunderstandings that can have far-reaching consequences. The stories of these bugs are not only entertaining but also serve as valuable lessons about the importance of care and thorough examination of work results before their release (i.e., proper software testing).