On Computer Bugs

Little-known (and apocryphal) trivia: The first recorded computer “bug” was a processing error caused by a dead moth that had been caught inside a relay, blocking the switch.

This story is both true and false.  The insect existed, and in point of fact has been preserved as part of the collection at the National Museum of American History, but the term “bug” was in common use for many years before the moth was found in 1946.  Here are some other bugs that have been found and preserved as a part of my own collection:

 

Syntax Error:  Once thought to be due to a minor mistake in spelling or punctuation, this bug is caused by failing to make the necessary offerings and propitiations to St. Cathode of Ray, in penance for your many programming crimes — hence the “Sin Tax”.

Logic Error:  This is caused by a confusion in combining terms, often something as simple as adding instead of subtracting, but occasionally arises from such whimiscal causes as adding the date instead of the quantity.  This includes the Type Mismatch, which happens whenever tech support falls for the data analyst.

Heisenbug:  Only materializes when you’re not looking for it, but is impossible to recreate under observation.

Variant – Panopticon Bug:  This describes any code that behaves differently whenever it’s in a state where it could be observed and adjusted versus once deployed and “in the wild”.

Glitch:  Any transient bug that goes away on its own for no apparent reason.  Alternately, this can refer to the ability to achieve a state within a program that was designed to be unachievable; a bug in the latter instance would actually do the opposite.

Functional Bug:  Any part of the code that follows instructions perfectly yet doesn’t do what you intended it to do.  When the programmer is sent to the store with “Buy a loaf of bread, and if they have eggs get a dozen,” and he returns with twelve loaves, this is an example of a functional bug.

Bohrbug:  A good solid bug, usually caused by a missing semicolon.  Highly deterministic in behavior and easily found and repaired.  Never occurs in real life but frequently seen in the classroom.

Mandelbug:  A bug whose causes are so complex that it defies description, much less repair.  Any attempt at debugging will introduce three new Mandelbugs, and so on.  The solution is to take off and nuke the entire site from orbit; it’s the only way to be sure.

Eulerbug:  The bug is real, but the only possible root cause is imaginary.  (For you math geeks out there.)

Lance Armstrong Bug:  This is when the code never fails a test, but the results are indicative of improper behavior.

Gorilla Hands:  When offering a client two alternatives, programmers will occasionally try to circumvent the process by making one option appear obviously wrong to even the meanest intellect, such as putting gorilla gloves on an otherwise normal person.  The client will always choose the wrong option.

Out-Of-Bounds Bug:  These crop up whenever the user enters data where other things are supposed to live, such as the graphics driver.  Somehow, these are never found during testing.

System Resources Error:  Otherwise known as “Who loaded I-Tunes on the server?”

Hardware problem:  Any bug that cannot be repaired without exceeding the programmer’s expertise.  Examples include:  Broken light bulb, blown fuse, tripped circuit breaker in the eighteen daisy-chained power strips.

Communication Error:  This occurs somewhere in the long chain of documents that are generated between the time the client asks for a product and the programmer releases something entirely different.  Programmers explain that this only ever happens because they weren’t allowed to attend the first meeting, whereas Marketing knows exactly why programmers aren’t allowed into meetings and has the police reports to prove it.

Infinite Loop:  See Recursion Bug.

User Error:  No software can be made foolproof, because fools are so very ingenious.

Girlfriend Bug:  You know something’s definitely wrong, and the situation is rapidly becoming dire.  However, any test you can devise returns the result “Everything’s Fine.”  One known variant is the Boyfriend Bug, which instead of responding merely grunts.

Spouse Bug:  Even when nothing at all is wrong, you hear all about it.  Note these are gender non-specific.

Schrödinbug:  This sort of bug is only ever discovered after the programmer realizes that the code never should have worked in the first place.

Hindenbug:  When discovered, it’s already too late. If the program is the only thing that blows up you’re lucky. Duck for cover (someplace other than in the server room) and pray.

Eugenbug:  This bug was easy enough to fix, but it seems it was tied to this really huge monster bug that’s now out to raid your merchant shipping.  And now, for some unaccountable reason, you can’t even find the big bug.  (See Bismarckbug)

Recursion Bug:  See Infinite Loop.

Undetectable Error:  Undetectable errors are infinite in variety, in contrast to detectable errors, which by definition are limited.

Feature:  Any bug that cannot be easily fixed.

 

Remember:  New bugs appear whenever you open Windows.


You can send cash to PayPal in order to help support us, set up a subscription donation at Patreon, or buy us a coffee.

Buy Me A Coffee

Leave a Reply

Please log in using one of these methods to post your comment:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s