The First Software Bug in History: How a Moth Changed Computer History

Today, whenever we encounter an unexpected problem in a website, mobile app, or computer program, there is one word we often use:

Bug.

“There is a bug in the application.”

“We need to debug this problem.”

These words are so common in the software world that we rarely stop to think about where they came from.

But behind the word “bug” is one of the most fascinating stories in computer history.

And surprisingly, the main character of this story wasn't a programmer or a complicated piece of code.

It was a moth.

In 1947, engineers working on one of the world's earliest computers, the Harvard Mark II, encountered a problem that prevented the machine from working properly.

When they investigated the problem, they discovered a real moth trapped between the relays inside the computer.

They removed it.

Then they did something rather unusual.

They attached the moth to the computer's logbook.

Next to it, they wrote:

“First actual case of bug being found.”

The story became one of the most famous anecdotes in computer history.

But there is an important detail that is often overlooked:

The moth was not actually the first software bug in history.

t All Started on September 9, 1947

The date was September 9, 1947.

Computer technology was still in its infancy. The machines of the time were enormous compared with today's computers, and they worked in very different ways.

The Harvard Mark II was an electromechanical computer. It contained large numbers of cables, electrical circuits, and electromagnetic relays.

These relays played an important role in the machine's calculations. In simple terms, they can be thought of as early mechanical versions of the electronic switches used inside modern computers.

Because of this design, even a tiny physical problem could interfere with the operation of the entire machine.

And that is exactly what happened.

While investigating a malfunction, the engineers discovered a moth trapped between the contacts of one of the relays.

Today, the idea of an insect causing a computer problem may sound amusing.

At the time, however, it was a real technical problem that needed to be solved.

The moth was removed.

The computer started working again.

But the engineers didn't simply throw the insect away.

Instead, they attached it to the machine's logbook.

That small decision turned an ordinary technical problem into one of the most famous stories in the history of computing.

Was This Really the First Computer Bug?

This is where the story gets more interesting.

The incident is often described as “the first software bug in history.”

Technically, however, that isn't accurate.

The problem discovered in the Harvard Mark II was not a software error.

It was a physical hardware problem caused by a moth interfering with a mechanical component.

The word “bug” itself was also not invented in 1947.

Engineers had already been using the term long before computers existed to describe faults, defects, and unexpected problems in technical systems.

Thomas Edison, for example, is known to have used the word “bug” when discussing problems in electrical systems during the 19th century.

So what made the 1947 incident so famous?

The answer is simple:

This time, there really was a bug inside the machine.

The technical meaning of the word and its literal meaning happened to meet in the same place.

Where Did the Word “Bug” Come From?

In everyday English, a “bug” is an insect.

In software development, a bug is an error or unexpected behavior in a program.

The technical use of the word is much older than modern computers.

Engineers had been using “bug” to describe small defects, faults, and problems in mechanical and electrical systems for many years.

As computers developed, the term naturally became associated with problems in computer systems and software.

Eventually, a software problem became known simply as a software bug.

The Harvard Mark II incident didn't create the word.

Instead, it created one of the most memorable stories associated with it.

What Was Grace Hopper's Role?

Whenever the story of the first computer bug is told, another name often appears:

Grace Hopper.

Hopper was one of the most important figures in the early history of computing. She was part of the team working with the Harvard Mark I and Mark II computers.

However, there is a common misconception surrounding her role.

You may come across claims saying:

“Grace Hopper found the moth and invented the word bug.”

That isn't quite correct.

Grace Hopper did not invent the word “bug.”

And it would also be too strong to claim with certainty that she personally discovered the moth.

What makes Hopper important is her much broader contribution to computer science.

She worked on making computers easier for humans to program and played an important role in the development of early compilers. She also became one of the key figures associated with the development of COBOL.

Reducing her legacy to “the woman who found the moth in the computer” would overlook her much more significant contributions to computing.

Where Is the Moth Today?

Perhaps the most surprising part of this story is that the moth was not simply thrown away.

It was preserved.

The moth was attached to the Harvard Mark II logbook.

That logbook is now preserved as part of the Smithsonian's collection.

This means that the famous computer bug story isn't simply an urban legend passed down through generations.

There is an actual historical record associated with the event.

The tiny insect that caused a problem inside a computer nearly 80 years ago became part of one of the most famous artifacts in computer history.

Did the Word “Debug” Come From the Moth?

Today, one of the most common words in software development is debug.

When a program doesn't behave as expected, a developer examines the code, identifies the problem, and fixes it.

This process is known as debugging.

However, it would be inaccurate to say that the word “debug” was invented because of the moth in 1947.

The terms “bug” and “debug” have a longer history.

What the Harvard Mark II incident did was create an unforgettable connection between the word “bug” and computers.

It was almost a perfect coincidence:

There really was a bug inside the computer.

How Has the Meaning of “Bug” Changed Since 1947?

In the 1940s, computers were heavily dependent on physical hardware.

Relays, cables, vacuum tubes, and mechanical components were critical to their operation.

A physical fault could therefore directly prevent a computer from working.

As software development evolved, however, the concept of a bug changed as well.

Today, a single line of incorrect code can cause serious problems.

A calculation error on a website, a failed transaction in a banking application, a crash in a mobile app, or unexpected behavior in a video game can all be caused by software bugs.

Modern software can contain millions of lines of code.

As a result, debugging has become a major part of software engineering.

Developers examine logs, step through code, inspect variables, write tests, reproduce errors, and investigate the root cause of a problem.

Back in 1947, the solution was considerably simpler:

Remove the moth.

From One Moth to Millions of Lines of Code

There is an almost 80-year technological gap between the Harvard Mark II and today's software systems.

Back then, a physical insect could stop a computer from working.

Today, a single character in a program can potentially affect millions of users.

For example, consider the difference between:

if (user.isAdmin = true)

and:

if (user.isAdmin === true)

A small difference like this can completely change how a program behaves.

Modern debugging is essentially a much more sophisticated version of the problem-solving process engineers were already performing in the early days of computing.

First, a problem is detected.

Then its source is investigated.

The underlying cause is identified.

A solution is implemented.

Finally, the system is tested again.

The biggest difference is that programmers today don't usually need to open the computer case and look for an actual insect.

So, What Was the First Software Bug in History?

This question is actually more difficult to answer than it seems.

The earliest computers experienced both hardware and software problems, but not all of them were documented in the way modern software bugs are.

For this reason, it would be misleading to call the Harvard Mark II moth the first software bug in history.

A more accurate description would be:

The moth found inside the Harvard Mark II in 1947 is one of the earliest and most famous documented examples of a real computer bug.

What makes the incident special is not that the moth created the word “bug.”

It didn't.

The word was already being used to describe technical problems.

What made the incident unforgettable was the coincidence:

A technical “bug” was discovered inside a computer, and this time the bug was literally a bug.

Why Do We Still Tell This Story Today?

Because no matter how advanced technology becomes, computer systems still have bugs.

Today, bugs appear in artificial intelligence systems, mobile applications, websites, operating systems, video games, cloud platforms, and almost every other type of software.

Developers continue to find them and fix them every day.

That's why the story of the Harvard Mark II moth still feels surprisingly relevant.

In 1947, an engineer could open a computer and discover a physical insect causing the problem.

Today, a software developer might spend hours searching through millions of lines of code for an invisible mistake.

The tools have changed.

The computers have changed.

Software has become unimaginably more complex.

But the fundamental goal remains the same:

Find the problem, understand why it happened, and fix it.

Conclusion: The Most Famous “Bug” in Computer History

The moth found inside the Harvard Mark II in 1947 became one of the most fascinating stories in the history of computing.

It was not the first software bug, and the word “bug” did not originate with this incident.

But the fact that a real insect was found inside a computer created an unforgettable connection between the literal meaning of the word and its technical meaning.

The moth was preserved in the computer's logbook, turning a small technical problem into a lasting piece of computing history.

Today, when a developer says, “I'm debugging the application,” they probably aren't thinking about insects.

But one of the most famous debugging stories in computer history really did begin with a moth.

And perhaps the best lesson from the story is this:

Sometimes, before searching through millions of lines of code, you should check whether there is actually a bug inside the machine.