| |
LW1DSE > TECH 26.11.17 23:13l 374 Lines 17802 Bytes #999 (0) @ WW
BID : 1119-LW1DSE
Read: GUEST
Subj: Bugs
Path: IW8PGT<IR2UBX<EA2RCF<LU9DCE<LU1DBQ<LU7DQP
Sent: 171126/2025Z @:LU7DQP.#LAN.BA.ARG.SOAM #:22963 [Lanus Oeste] FBB7.00i
From: LW1DSE@LU7DQP.#LAN.BA.ARG.SOAM
To : TECH@WW
[ฏฏฏ TST HOST 1.43c, UTC diff:5, Local time: Mon Nov 20 18:45:52 2017 ฎฎฎ]
ษออออออออออออออออออออออป
บ * Technical "Bugs" * บ
ศออออออออออออออออออออออผ
(Best if viewed in ASCII or CP437)
A software bug (or just "bug") is an error, flaw, mistake, failure, or
fault in a computer program that prevents it from behaving as intended (e.g.,
producing an incorrect result). Most bugs arise from mistakes and errors made
by people in either a program's source code or its design, and a few are
caused by compilers producing incorrect code. A program that contains a large
number of bugs, and/or bugs that seriously interfere with its functionality,
is said to be buggy. Reports detailing bugs in a program are commonly known
as bug reports, fault reports, problem reports, trouble reports, change
requests, and so forth.
* Contents:
ออออออออ
1) Effects
2) Etymology
3) Prevention
4) Debugging
5) Managing bugs
6) Famous computer bugs
6.1) Space exploration
6.2) Medical
6.3) Computing
6.4) Electric power transmission
6.5) Telecommunications
6.6) Military
6.7) Video games
7) Security vulnerabilities
8) Common types of computer bugs
9) Bugs in popular culture
1) Effects:
----------
Bugs can have a wide variety of effects, with varying levels of
inconvenience to the user of the program. Some bugs have only a subtle effect
on the program's functionality, and may thus lie undetected for a long time.
More serious bugs may cause the program to crash or freeze leading to a
denial of service. Others qualify as security bugs and might for example
enable a malicious user to bypass access controls in order to obtain
unauthorized privileges.
The results of bugs may be extremely serious. A bug in the code
controlling the Therac-25 radiation therapy machine was directly responsible
for some patient deaths in the 1980s. In 1996, the European Space Agency's
US$1 billion prototype Ariane 5 rocket was destroyed less than a minute after
launch, due to a bug in the on-board guidance computer program. In June 1994,
a Royal Air Force Chinook crashed into the Mull of Kintyre, killing 29. This
was initially dismissed as pilot error, but an investigation by Computer
Weekly uncovered sufficient evidence to convince a House of Lords inquiry
that it may have been caused by a software bug in the aircraft's engine
control computer.
2) Etymology:
------------
The concept that software might contain errors dates back to 1842 in
Ada Byron's notes on the analytical engine in which she speaks of the
difficulty of preparing program 'cards' for Charles Babbage's Analytical
engine:
"...an analyzing process must equally have been performed in order
to furnish the Analytical Engine with the necessary operative data;
and that herein may also lie a possible source of error. Granted
that the actual mechanism is unerring in its processes, the cards
may give it wrong orders."
Usage of the term "bug" to describe inexplicable defects has been a
part of engineering jargon for many decades and predates computers and
computer software; it may have originally been used in hardware engineering
to describe mechanical malfunctions. For instance, Thomas Edison wrote the
following words in a letter to an associate in 1878:
"It has been just so in all of my inventions. The first step is an
intuition, and comes with a burst, then difficulties arise this
thing gives out and [it is] then that "Bugs" as such little faults
and difficulties are called show themselves and months of intense
watching, study and labor are requisite before commercial success
or failure is certainly reached."
Problems with radar electronics during World War II were referred to as
bugs (or glitches), and there is additional evidence that the usage dates
back much earlier.
There is a photo of what is possibly the first real bug found in a
computer. The invention of the term is often erroneously attributed to Grace
Hopper, who publicized the cause of a malfunction in an early
electromechanical computer. A typical version of the story is given by this
quote:
"In 1946, when Hopper was released from active duty, she joined
the Harvard Faculty at the Computation Laboratory where she
continued her work on the Mark II and Mark III. Operators traced
an error in the Mark II to a moth trapped in a relay, coining the
term 'bug'. This bug was carefully removed and taped to the log
book September 9th 1945 [sic]. Stemming from the first bug, today
we call errors or glitch's [sic] in a program a bug."
Hopper wasn't actually the one who found the insect, as she readily
acknowledged. And the date was September 9, but in 1947, not 1945. The
operators who did find it (including William "Bill" Burke, later of the Naval
Weapons Laboratory, Dahlgren Va.), were familiar with the engineering term
and, amused, kept the insect with the notation "First actual case of bug
being found." Hopper loved to recount the story.
While it is certain that the Mark II operators didn't coin the term
"bug", it has been suggested that they did coin the related term, "debug".
Even this is unlikely, since the Oxford English Dictionary entry for "debug"
contains a use of "debugging" in the context of airplane engines in 1945.
3) Prevention:
-------------
Bugs are a consequence of the nature of human factors in the programming
task. They arise from oversights made by computer programmers during design,
coding and data entry. For example: In creating a relatively simple program
to sort a list of words into alphabetical order, one's design might fail to
consider what should happen when a word contains a hyphen. Perhaps, when
converting the abstract design into the chosen programming lanugage, one
might inadvertently create an off-by-one error and fail to sort the last word
in the list. Finally, when typing the resulting program into the computer,
one might accidentally type a '+' where a '-' was intended, perhaps resulting
in the words being sorted into reverse alphabetical order. More complex bugs
can arise from unintended interactions between different parts of a computer
program. This frequently occurs because computer programs can be complex
- millions of lines long in some cases - often having been programmed by many
people over a great length of time, so that programmers are unable to
mentally track every possible way in which parts can interact. Another
category of bug called a race condition comes about when a program is running
in more than one thread.
The software industry has put much effort into finding methods for
preventing programmers from inadvertently introducing bugs while writing
software. These include:
a) Programming style: While typos in the program code most likely are caught
by the compiler, a bug usually appears when the programmer makes a logic
error. Various innovations in programming style and defensive programming
are designed to make these bugs less likely, or easier to spot.
b) Programming techniques: Bugs often create inconsistencies in the internal
data of a running program. Programs can be written to check the consistency
of their own internal data while running. If an inconsistency is
encountered, the program can immediately halt, so that the bug can be
located and fixed. Alternatively, the program can simply inform the user,
attempt to correct the inconsistency, and continue running.
c) Development methodologies: There are several schemes for managing
programmer activity, so that fewer bugs are produced. Many of these fall
under the discipline of software engineering (which addresses software
design issues as well.) For example, formal program specifications are
used to state the exact behavior of programs, so that design bugs can be
eliminated.
d) Programming language support: Programming languages often include features
which help programmers deal with bugs, such as exception handling. In
addition, many recently-invented languages have deliberately excluded
features which can easily lead to bugs. For example, the Java programming
language doesn't support pointer arithmetic.
4) Debugging:
------------
The typical bug history (GNU Classpath project data). A bug, submitted
by the user, is unconfirmed. A reproduced bug is a confirmed bug. The
confirmed bugs are later fixed. Bugs, belonging to other categories
(unreproducible, will not be fixed, etc) are usually in the minority. Finding
and fixing bugs, or "debugging", has always been a major part of computer
programming. Maurice Wilkes, an early computing pioneer, described his
realization in the late 1940s that much of the rest of his life would be
spent finding mistakes in his own programs. As computer programs grow more
complex, bugs become more common and difficult to fix. Often programmers
spend more time and effort finding and fixing bugs than writing new code.
Usually, the most difficult part of debugging is locating the erroneous
part of the source code. Once the mistake is found, correcting it is usually
easy. Programs known as debuggers exist to help programmers locate bugs.
However, even with the aid of a debugger, locating bugs is something of an
art. It isn't uncommon for a bug in one section of a program to cause
failures in a completely different section, thus making it especially
difficult to track (for example, an error in a graphic rendering routine
causing a file I/O routine to fail); this is most commonly caused by errors
that lead to the corruption of program instructions or variables in memory.
Typically, the first step in locating a bug is finding a way to
reproduce it easily. Once the bug is reproduced, the programmer can use a
debugger or some other tool to monitor the execution of the program in the
faulty region, and find the point at which the program went astray. Sometimes,
a bug isn't a single flawed instruction, but represents an error of thinking
or planning on the part of the programmer. Such logic errors require a
section of the program to be overhauled or rewritten.
It isn't always easy to reproduce bugs. Some bugs are triggered by
inputs to the program which may be difficult for the programmer to re-create.
One cause of the Therac-25 radiation machine deaths was a bug that occurred
only when the machine operator very rapidly entered a treatment plan; it took
days of practice to become able to do this, so the bug didn't manifest in
testing or when the manufacturer attempted to duplicate it. Other bugs may
disappear when the program is run with a debugger; these are heisenbugs
(humorously named after the Heisenberg uncertainty principle.)
Debugging is still a tedious task requiring considerable manpower.
Since the 1990s, particularly following the Ariane 5 Flight 501 disaster,
there has been a renewed interest in the development of effective automated
aids to debugging. For instance, methods of static code analysis by abstract
interpretation have already made significant achievements, while still
remaining much of a work in progress.
5) Managing bugs:
----------------
It is common practice for software to be released with known bugs that
are considered non-critical. While software products contain an unknown
number of unknown bugs when shipped, measurements during the testing may
provide a statistically reliable estimate of the number of likely bugs
remaining. Most big software projects maintain a list of "known bugs". This
list inform users about bugs that aren't fixed in the current release, or not
fixed at all, and often a workaround is offered additionally.
There are various reasons for such a list:
* The developers often don't have time to fix all non-severe bugs.
* The bug could be fixed in a new version or patch that is not yet released.
* The changes to the code required to fix the bug would be large, and would
bring with them the chance of introducing other bugs into the system.
* Given the above, it is often considered impossible to write completely
bug-free software of any real complexity. So bugs are categorized by
severity, and low-severity non-critical bugs are tolerated, as they don't
impact the proper operation of the system, for the majority of users.
NASA's SATC managed to reduce number of errors to fewer than 0.1 per 1000
lines of code (SLOC) but this wasn't felt to be feasible for any real
world projects.
One school of thought, popularized by Eric S. Raymond as Linus's Law
in his essay The Cathedral and the Bazaar, holds that popular open-source
software holds a better chance of having few or no bugs than other software,
because "given enough eyeballs, all bugs are shallow". This assertion has
been disputed, however: computer security specialist Elias Levy wrote that
"it is easy to hide vulnerabilities in complex, little understood and
undocumented source code," because, "even if people are reviewing the code,
that doesn't mean they're qualified to do so."
6) Famous computer bugs:
-----------------------
6.1) Space exploration
* NASA Mariner 1 went off-course during launch, due to a missing overbar in
the specifications for its FORTRAN software (July 22, 1962).
* NASA Apollo 11 landing problem (July 20, 1969).
* NASA Voyager 2 (January 25, 1986).
* Phobos 1 lost (September 10, 1988).
* ESA Ariane 5 Flight 501 self-destruction 40 seconds after takeoff (June 4,
1996).
* NASA Mars Climate Orbiter destroyed due to entry of momentum data in
imperial units instead of the metric system (September 23, 1999).
* Mars Polar Lander lost (December 3, 1999).
* NASA Mars Rover freezes due to too many open files in flash memory (January
21, 2004).
* NASA Mars Global Surveyor battery failure was the result of a series of
events linked to a computer error made five months before (November 2,
2006).
6.2) Medical
* The Therac-25 accidents (1985-1987), which caused at least five deaths.
6.3) Computing
* The year 2000 problem, popularly known as the "Y2K bug", spawned fears of
worldwide economic collapse and an industry of consultants providing
last-minute fixes.
* The Pentium FDIV bug.
6.4) Electric power transmission
* The 2003 North America blackout was triggered by a local outage that went
undetected due to a race condition in General Electric Energy's XA/21
monitoring software.
6.5) Telecommunications
* AT&T long distance network crash (January 15, 1990), documented in Bruce
Sterling's The Hacker Crackdown.
6.6) Military
* The software error of a MIM-104 Patriot, which ultimately contributed to
the deaths of 28 Americans in Dhahran, Saudi Arabia (February 25, 1991).
* Chinook crash on Mull of Kintyre: the cause of this event remains a
mystery, but strong suspicions have been raised that software problems were
a contributory factor.
6.7) Video games
* The Missingno. and Glitch City bugs, found in the Pokmon series
* The Minus World in NES version of Super Mario Brothers
7) Security vulnerabilities:
---------------------------
Malicious software may attempt to exploit known vulnerabilities in a
system - which may or may not be bugs. Viruses aren't bugs in themselves
- they are typically programs that are doing precisely what they were
designed to do. However, viruses are occasionally referred to as such in the
popular press.
8) Common types of computer bugs:
--------------------------------
* Divide by zero
* NULL pointer dereference
* Infinite loops
* Arithmetic overflow or underflow
* Exceeding array bounds
* Using an uninitialized variable
* Accessing memory not owned (Access violation)
* Memory leak or Handle leak
* Stack overflow or underflow
* Buffer overflow
* Deadlock
* Off by one error
* Race condition
* Loss of precision in type conversion
9) Bugs in popular culture:
--------------------------
In the 1968 novel 2001: A Space Odyssey (and the corresponding film),
a spaceship's onboard computer, HAL 9000, is programmed with two conflicting
objectives: to fully disclose all its information, and to keep the true
purpose of the flight secret from the crew. This conflict causes HAL to
eventually try to kill all the crew members (since, if there were no crew,
there would be no contradiction).
In the 1984 song 99 Red Balloons (though not in the original German
version), "bugs in the software" lead to a computer mistaking a group of
balloons for a nuclear missile and starting a nuclear war.
The 2004 novel The Bug, by Ellen Ullman, is about a programmer's
attempt to find an elusive bug in a database application.
ษออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออป
บ Compilled from Wikipedia.com . Translatted to ASCII by LW1DSE Osvaldo บ
บ F. Zappacosta. Barrio Garay, Almirante Brown, Buenos Aires, Argentina. บ
บ Made with MSDOS 7.10's Text Editor (edit.com) in my AMD's 80486. บ
บ November 17, 2007 บ
ศออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออผ
ษออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออป
บ Osvaldo F. Zappacosta. Barrio Garay (GF05tg) Alte. Brown, Bs As, Argentina.บ
บ Mother UMC ๆPC:AMD486@120MHz 32MbRAM HD SCSI 8.4Gb MSDOS 7.10 TSTHOST1.43C บ
บ 6 celdas 2V 150AH. 18 paneles solares 10W. บ
บ lw1dse@yahoo.com ; lw1dse@gmail.com บ
ศออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออออผ
Read previous mail | Read next mail
| |
