From mboxrd@z Thu Jan  1 00:00:00 1970
X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on polar.synack.me
X-Spam-Level: 
X-Spam-Status: No, score=0.1 required=5.0 tests=BAYES_05,INVALID_MSGID
	autolearn=no autolearn_force=no version=3.4.4
X-Google-Language: ENGLISH,ASCII-7-bit
X-Google-Thread: 103376,de5dfd6df880dd3
X-Google-Attributes: gid103376,public
From: Richard D Riehle <laoXhai@ix.netcom.com>
Subject: Re: Bugs or Mistakes?
Date: 1999/11/13
Message-ID: <80i9la$i9e$1@nntp9.atl.mindspring.net>#1/1
X-Deja-AN: 547954259
References: <19991112202656.2368.rocketmail@web216.mail.yahoo.com>
Organization: MindSpring Enterprises
X-Server-Date: 12 Nov 1999 23:59:38 GMT
Newsgroups: comp.lang.ada
Date: 1999-11-12T23:59:38+00:00
List-Id: <comp.lang.ada>

In article <19991112202656.2368.rocketmail@web216.mail.yahoo.com>,
	MaryAnn Atkinson <maryann_30@yahoo.com> wrote:

>Richard D Riehle wrote:
> 
>> What we call a "bug" is actually a mistake. Someone tried to do
>> something and made a mistake.  
>
>Why so harsh words? You are talking about a "bug" like its 
>a dirty word, or like we are somehow not allowed to make them...
>
>Bugs are mistakes ONLY if they are not found and corrected!

I knew at the time of my posting that this concept would arouse
a certain amount of indignation.  At least I hoped it would.

In my experience, the word "bug" is often used as a euphemism
to deemphasize personal responsibility for a set of mistakes. 
Many programmers do not take a "bug" as seriously as we might hope.

A "bug" is something that originates outside your program.  The 
original "bug" was, in the apocrypha of our industry, an actual
moth wriggling into oblivion between the contacts of a hardware
relay.  Both the system and bug died.   In our current use of the
word, only the system dies.  The bug remains intact, ready to kill
again, until it is discovered and exterminated.

Most of the phenomena we call "bugs" are the result of our own action,
not the random accidents of innocent lepidoptera.  Our actions are 
mistakes.  Sometimes we make a mistake in our specification.  Sometimes
it is a mistake in our code.  Now and then, the mistake originates in
someone else's code that we naively trust in creating our own.  

I have long believed that software managers should begin to insist that
programmers should be accountable for their mistakes.  When I say, "I
have a bug in my program,"  I am really saying, "I made a mistake." 

As long as programmers euphemize away their mistakes by calling them
"bugs," we will not be accepting the kind of responsibility for our
actions demanded of other engineering disciplines.  

It is, to me, quite telling that there are those who have sent me 
private correspondence on this matter expressing their indignation.
"Bug" has such a long history of usage that we simply accept it as
the way things are.  We often hear someone say, "There is no such thing
as 'bug free' software."   I interpret the person saying that to mean,
"No one knows how to build software that is free of mistakes."  

Robert Eachus made a very good point in a separate posting about the
responsibility of a designer of bolts targeted to the construction of
a bridge.  Is a bolt that cannot handle the stress of its load a "bug?"
No. We would consider it a mistake.  It is an engineering mistake.   

In a computer program, a mistake leads to a defect and the defect to 
a possible execution fault.  The fault might simply mangle some accounting
data or it might kill some elderly patient depending on a CCU monitor. 
It is probably OK to call it a "bug" when the outcome is benign.  More 
and more, our software is human-rated.  If you are not familiar with
the term, human-rated means that someone can die or be maimed if it
fails.  For that kind of software we need to start acknowledging the
severity of our mistakes by calling them just that.  

>P.S. Besides, you can't easily make a verb out of "mistake", you know?
>     What, am I going to be "demistaking" my code now?

Clever, but unpersuasive.  How about doing what any other engineer
would do about a mistake?  If I make an error in the design of a
mechanical device, I do not "debug" it, I correct it.  Debugging
a program is nothing more than correcting the mistakes.  

It is interesting that the use of the prefix, de-, in this context
implies a removal of some pestilence from the code.  The connotation
is that, "Golly.  I did what I was supposed to do, but some nefarious
organism has begun to gnaw at it.  I must find this organism and 
destroy it."   When I have a mistake in my code, and I have a knack
for producing lots of mistakes, I do what you and everyone else must
do:  correct those mistakes.  

Perhaps it sastisfies some primitive instinct to imagine that correcting
mistakes is like eradicating evil spirits.  If I treat the correction
process as if it were an exorcism, I can have the satisfaction of 
conquest.  Perhaps I can paste little pictures of spotted arthropods
on my computer in imitation of fighter pilots who paint enemy flags
on a fuselage.  

Sorry, MaryAnn.  I am just having too much fun with this whole idea.  
Sometimes I simply go berserk about these things.  I'd better quit
now and wipe the white dribble from the corner of my mouth before it
begins to foam uncontrollably.

Richard Riehle