Historically, back doors have often lurked in systems longer than
anyone expected or planned, and a few have become widely known.
The infamous RTM worm of late 1988, for example, used a back door
in the BSD UNIX `sendmail(8)' utility.
Ken Thompson's 1983 Turing Award lecture to the ACM revealed the
existence of a back door in early UNIX versions that may have
qualified as the most fiendishly clever security hack of all time.
The C compiler contained code that would recognize when the
`login' command was being recompiled and insert some code
recognizing a password chosen by Thompson, giving him entry to the
system whether or not an account had been created for him.
Normally such a back door could be removed by removing it from the
source code for the compiler and recompiling the compiler. But to
recompile the compiler, you have to *use* the compiler --- so
Thompson also arranged that the compiler would *recognize when
it was compiling a version of itself*, and insert into the
recompiled compiler the code to insert into the recompiled
`login' the code to allow Thompson entry --- and, of course, the
code to recognize itself and do the whole thing again the next time
around! And having done this once, he was then able to recompile
the compiler from the original sources; the hack perpetuated itself
invisibly, leaving the back door in place and active but with no
trace in the sources.
The talk that revealed this truly moby hack was published as
"Reflections on Trusting Trust", "Communications of the
ACM 27", 8 (August 1984), pp. 761--763.
Technically, a task running in background is detached from the
terminal where it was started (and often running at a lower
priority); oppose foreground. Nowadays this term is primarily
associated with "UNIX", but it appears to have been first used
in this sense on OS/360.
ITS's lexiphage program is the first and to date only known
example of a program *intended* to be a bagbiter.
In the bad old days of not so long ago, before autorouting mailers
became commonplace, people often published compound bang addresses
using the [ ] convention (see glob) to give paths from
*several* big machines, in the hopes that one's correspondent
might be able to get mail to one of them reliably (example:
...![seismo, ut-sally, ihnp4]!rice!beta!gamma!me). Bang paths
of 8 to 10 hops were not uncommon in 1981. Late-night dial-up
UUCP links would cause week-long transmission times. Bang paths
were often selected by both transmission time and reliability, as
messages would often get lost. See "Internet address",
network, the, and sitename.
In the world of personal computing, bare metal programming
(especially in sense 1 but sometimes also in sense 2) is often
considered a Good Thing, or at least a necessary evil
(because these machines have often been sufficiently slow and
poorly designed to make it necessary; see ill-behaved).
There, the term usually refers to bypassing the BIOS or OS
interface and writing the application to directly access device
registers and machine addresses. "To get 19.2 kilobaud on the
serial port, you need to get down to the bare metal." People who
can do this sort of thing well are held in high regard.
Historical note: `baud' was originally a unit of telegraph signalling
speed, set at one pulse per second. It was proposed at the
International Telegraph Conference of 1927, and named after J.M.E.
Baudot (1845--1903), the French engineer who constructed the first
successful teleprinter.
Earlier versions of this lexicon derived `baz' as a Stanford
corruption of bar. However, Pete Samson (compiler of the
TMRC lexicon) reports it was already current when he joined TMRC
in 1958. He says "It came from "Pogo". Albert the Alligator,
when vexed or outraged, would shout `Bazz Fazz!' or `Rowrbazzle!'
The club layout was said to model the (mythical) New England
counties of Rowrfolk and Bassex (Rowrbazzle mingled with
(Norfolk/Suffolk/Middlesex/Essex)."
In either of senses 1 or 2, the term is usually prefixed by the
name of the intended board (`the Moonlight Casino bboard' or
`market bboard'); however, if the context is clear, the better-read
bboards may be referred to by name alone, as in (at CMU) "Don't
post for-sale ads on general".
Note to British and Commonwealth readers: that's /berk'lee/, not
/bark'lee/ as in British Received Pronunciation.
Mainstream use of this term in reference to the cultural and
political peculiarities of UC Berkeley as a whole has been reported
from as far back as the 1960s.
Historical note: More formally, to beta-test is to test a
pre-release (potentially unreliable) version of a piece of software
by making it available to selected customers and users. This term
derives from early 1960s terminology for product cycle checkpoints,
first used at IBM but later standard throughout the industry.
`Alpha Test' was the unit, module, or component test phase; `Beta
Test' was initial system test. These themselves came from earlier
A- and B-tests for hardware. The A-test was a feasibility and
manufacturability evaluation done before any commitment to design
and development. The B-test was a demonstration that the
engineering model functioned as specified. The C-test
(corresponding to today's beta) was the B-test performed on early
samples of the production design.
[1993: Now It Can Be Told! My spies inform me that BIFF was
originally created by Joe Talmadge
author of the infamous and much-plagiarized "Flamer's Bible".
The BIFF filter he wrote was later passed to Richard Sexton, who
posted BIFFisms much more widely. Versions have since been posted
for the amusement of the net at large. --- ESR]
Sense 1 may require some explanation. Most computer languages
provide a kind of data called `integer', but such computer
integers are usually very limited in size; usually they must be
smaller than than 2^(31) (2,147,483,648) or (on a
bitty box) 2^(15) (32,768). If you want to work
with numbers larger than that, you have to use floating-point
numbers, which are usually accurate to only six or seven decimal
places. Computer languages that provide bignums can perform exact
calculations on very large numbers, such as 1000! (the factorial
of 1000, which is 1000 times 999 times 998 times ... times 2
times 1). For example, this value for 1000! was computed by the
MacLISP system using bignums:
40238726007709377354370243392300398571937486421071
46325437999104299385123986290205920442084869694048
00479988610197196058631666872994808558901323829669
94459099742450408707375991882362772718873251977950
59509952761208749754624970436014182780946464962910
56393887437886487337119181045825783647849977012476
63288983595573543251318532395846307555740911426241
74743493475534286465766116677973966688202912073791
43853719588249808126867838374559731746136085379534
52422158659320192809087829730843139284440328123155
86110369768013573042161687476096758713483120254785
89320767169132448426236131412508780208000261683151
02734182797770478463586817016436502415369139828126
48102130927612448963599287051149649754199093422215
66832572080821333186116811553615836546984046708975
60290095053761647584772842188967964624494516076535
34081989013854424879849599533191017233555566021394
50399736280750137837615307127761926849034352625200
01588853514733161170210396817592151090778801939317
81141945452572238655414610628921879602238389714760
88506276862967146674697562911234082439208160153780
88989396451826324367161676217916890977991190375403
12746222899880051954444142820121873617459926429565
81746628302955570299024324153181617210465832036786
90611726015878352075151628422554026517048330422614
39742869330616908979684825901254583271682264580665
26769958652682272807075781391858178889652208164348
34482599326604336766017699961283186078838615027946
59551311565520360939881806121385586003014356945272
24206344631797460594682573103790084024432438465657
24501440282188525247093519062092902313649327349756
55139587205596542287497740114133469627154228458623
77387538230483865688976461927383814900140767310446
64025989949022222176590433990188601856652648506179
97023561938970178600408118897299183110211712298459
01641921068884387121855646124960798722908519296819
37238864261483965738229112312502418664935314397013
74285319266498753372189406942814341185201580141233
44828015051399694290153483077644569099073152433278
28826986460278986432113908350621709500259738986355
42771967428222487575867657523442202075736305694988
25087968928162753848863396909959826280956121450994
87170124451646126037902930912088908694202851064018
21543994571568059418727489980942547421735824010636
77404595741785160829230135358081840096996372524230
56085590370062427124341690900415369010593398383577
79394109700277534720000000000000000000000000000000
00000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000
000000000000000000.
"I just need one bit from you" is a polite way of indicating that
you intend only a short interruption for a question that can
presumably be answered yes or no.
A bit is said to be `set' if its value is true or 1, and
`reset' or `clear' if its value is false or 0. One speaks of
setting and clearing bits. To toggle or `invert' a bit is
to change it, either from 0 to 1 or from 1 to 0. See also
flag, trit, mode bit.
The term `bit' first appeared in print in the computer-science
sense in 1949, and seems to have been coined by early computer
scientist John Tukey. Tukey records that it evolved over a lunch
table as a handier alternative to `bigit' or `binit'.
Bit bang was used on certain early models of Prime computers,
presumably when UARTs were too expensive, and on archaic Z80 micros
with a Zilog PIO but no SIO. In an interesting instance of the
cycle of reincarnation, this technique is now (1991) coming
back into use on some RISC architectures because it consumes such
an infinitesimal part of the processor that it actually makes sense
not to have a UART.
This term is used purely in jest. It is based on the fanciful
notion that bits are objects that are not destroyed but only
misplaced. This appears to have been a mutation of an earlier term
`bit box', about which the same legend was current; old-time
hackers also report that trainees used to be told that when the CPU
stored bits into memory it was actually pulling them `out of the
bit box'. See also chad box.
Another variant of this legend has it that, as a consequence of the
`parity preservation law', the number of 1 bits that go to the bit
bucket must equal the number of 0 bits. Any imbalance results in
bits filling up the bit bucket. A qualified computer technician
can empty a full bit bucket as part of scheduled maintenance.
There actually are physical processes that produce such effects
(alpha particles generated by trace radionuclides in ceramic chip
packages, for example, can change the contents of a computer memory
unpredictably, and various kinds of subtle media failures can
corrupt files in mass storage), but they are quite rare (and
computers are built with error-detecting circuitry to compensate
for them). The notion long favored among hackers that cosmic
rays are among the causes of such events turns out to be a myth;
see the cosmic rays entry for details.
The term software rot is almost synonymous. Software rot is
the effect, bit rot the notional cause.
Looking at the ASCII chart, we find:
high low bits
bits 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001
010 ! " # $ % & ' ( )
011 0 1 2 3 4 5 6 7 8 9
This is why the characters !"#$%&'() appear where they do on a
Teletype (thankfully, they didn't use shift-0 for space). This was
*not* the weirdest variant of the QWERTY layout widely
seen, by the way; that prize should probably go to one of several
(differing) arrangements on IBM's even clunkier 026 and 029 card
punches.
When electronic terminals became popular, in the early 1970s, there
was no agreement in the industry over how the keyboards should be
laid out. Some vendors opted to emulate the Teletype keyboard,
while others used the flexibility of electronic circuitry to make
their product look like an office typewriter. These alternatives
became known as `bit-paired' and `typewriter-paired' keyboards. To
a hacker, the bit-paired keyboard seemed far more logical --- and
because most hackers in those days had never learned to touch-type,
there was little pressure from the pioneering users to adapt
keyboards to the typewriter standard.
The doom of the bit-paired keyboard was the large-scale
introduction of the computer terminal into the normal office
environment, where out-and-out technophobes were expected to use
the equipment. The `typewriter-paired' standard became universal,
`bit-paired' hardware was quickly junked or relegated to dusty
corners, and both terms passed into disuse.
ACHTUNG! ALLES LOOKENSPEEPERS! Das computermachine
ist nicht fuer gefingerpoken und mittengrabben. Ist easy schnappen
der springenwerk, blowenfusen und poppencorken mit spitzensparken.
Ist nicht fuer gewerken bei das dumpkopfen. Das rubbernecken
sichtseeren keepen das cotten-pickenen hans in das pockets muss;
relaxen und watchen das blinkenlichten.
This silliness dates back at least as far as 1959 at Stanford
University and had already gone international by the early 1960s,
when it was reported at London University's ATLAS computing site.
There are several variants of it in circulation, some of which
actually do end with the word `blinkenlights'.
In an amusing example of turnabout-is-fair-play, German hackers
have developed their own versions of the blinkenlights poster in
fractured English, one of which is reproduced here:
ATTENTION
This room is fullfilled mit special electronische equippment.
Fingergrabbing and pressing the cnoeppkes from the computers is
allowed for die experts only! So all the "lefthanders" stay away
and do not disturben the brainstorming von here working
intelligencies. Otherwise you will be out thrown and kicked
anderswhere! Also: please keep still and only watchen astaunished
the blinkenlights.
See also geef.
This term has other meanings in other technical cultures; among
experimental physicists and hardware engineers of various kinds it
seems to mean any random object of unknown purpose (similar to
hackish use of frob). It has also been used to describe an
amusing trick-the-eye drawing resembling a three-pronged fork that
appears to depict a three-dimensional object until one realizes
that the parts fit together in an impossible way.
This translates into English as: "A postal-address consists of a
|
name-part, followed by a street-address part, followed by a
zip-code part. A personal-part consists of either a first name or
an initial followed by a dot. A name-part consists of either: a
personal-part followed by a last name followed by an optional
`jr-part' (Jr., Sr., or dynastic number) and end-of-line, or a
personal part followed by a name part (this rule illustrates the
use of recursion in BNFs, covering the case of people who use
multiple first and middle names and/or initials). A street address
consists of an optional apartment specifier, followed by a street
number, followed by a street name. A zip-part consists of a
town-name, followed by a comma, followed by a state code, followed
by a ZIP-code followed by an end-of-line." Note that many things
(such as the format of a personal-part, apartment specifier, or
ZIP-code) are left unspecified. These are presumed to be obvious
from context or detailed somewhere nearby. See also parse.
2. Any of a number number of variants and extensions of BNF proper,
possibly containing some or all of the regexp wildcards such
as `*' or `+'. In fact the example above isn't the pure
form invented for the Algol-60 report; it uses `[]', which was
introduced a few years later in IBM's PL/I definition but is now
universally recognized. 3. In "science-fiction fandom", a
`Big-Name Fan' (someone famous or notorious). Years ago a fan
started handing out black-on-green BNF buttons at SF conventions;
this confused the hacker contingent terribly.
The bogon has become the type case for a whole bestiary of nonce
particle names, including the `clutron' or `cluon' (indivisible
particle of cluefulness, obviously the antiparticle of the bogon)
and the futon (elementary particle of randomness, or sometimes
of lameness). These are not so much live usages in themselves as
examples of a live meta-usage: that is, it has become a standard
joke or linguistic maneuver to "explain" otherwise mysterious
circumstances by inventing nonce particle names. And these imply
nonce particle theories, with all their dignity or lack thereof (we
might note parenthetically that this is a generalization from
"(bogus particle) theories" to "bogus (particle theories)"!).
Perhaps such particles are the modern-day equivalents of trolls and
wood-nymphs as standard starting-points around which to construct
explanatory myths. Of course, playing on an existing word (as in
the `futon') yields additional flavor. Compare [magic
smoke}.
Astrology is bogus. So is a bolt that is obviously about to break.
So is someone who makes blatantly false claims to have solved a
scientific problem. (This word seems to have some, but not all, of
the connotations of random --- mostly the negative ones.)
It is claimed that `bogus' was originally used in the hackish sense
at Princeton in the late 1960s. It was spread to CMU and Yale by
Michael Shamos, a migratory Princeton alumnus. A glossary of bogus
words was compiled at Yale when the word was first popularized (see
autobogotiphobia under bogotify). The word spread into
hackerdom from CMU and MIT. By the early 1980s it was also
current in something like the hackish sense in West Coast teen
slang, and it had gone mainstream by 1985. A correspondent from
Cambridge reports, by contrast, that these uses of `bogus' grate on
British nerves; in Britain the word means, rather specifically,
`counterfeit', as in "a bogus 10-pound note".
The derivative `reboot' implies that the machine hasn't been down
for long, or that the boot is a bounce (sense 4) intended to
clear some state of wedgitude. This is sometimes used of
human thought processes, as in the following exchange: "You've
lost me." "OK, reboot. Here's the theory...."
This term is also found in the variants `cold boot' (from
power-off condition) and `warm boot' (with the CPU and all
devices already powered up, as after a hardware reset or software
crash).
Another variant: `soft boot', reinitialization of only part of a
system, under control of other software still running: "If
you're running the mess-dos emulator, control-alt-insert will
cause a soft-boot of the emulator, while leaving the rest of the
system running."
Opposed to this there is `hard boot', which connotes hostility
towards or frustration with the machine being booted: "I'll have
to hard-boot this losing Sun." "I recommend booting it
hard." One often hard-boots by performing a power cycle.
Historical note: this term derives from `bootstrap loader', a short
program that was read in from cards or paper tape, or toggled in
from the front panel switches. This program was always very short
(great efforts were expended on making it short in order to
minimize the labor and chance of error involved in toggling it in),
but was just smart enough to read in a slightly more complex
program (usually from a card or paper tape reader), to which it
handed control; this program in turn was smart enough to read the
application or operating system from a magnetic tape drive or disk
drive. Thus, in successive steps, the computer `pulled itself up
by its bootstraps' to a useful operating state. Nowadays the
bootstrap is usually found in ROM or EPROM, and reads the first
stage in from a fixed location on the disk, called the `boot
block'. When this program gains control, it is powerful enough to
load the actual OS and hand control over to it.
/*************************************************
*
* This is a boxed comment in C style
*
*************************************************/
Common variants of this style omit the asterisks in column 2 or add
a matching row of asterisks closing the right side of the box. The
sparest variant omits all but the comment delimiters themselves;
the `box' is implied. Oppose winged comments.
[Since this entry was first written, several correspondents have
reported that there actually was a compiler for a tiny Algol-like
language called Foogol floating around on various [vaxen] in the
early and mid-1980s. The above example may not, after all, be
hypothetical. -- ESR]
The notional `kiss-of-death packet', with a function
complementary to that of a breath-of-life packet, is recommended
for dealing with hosts that consume too many network resources.
Though `kiss-of-death packet' is usually used in jest, there is
at least one documented instance of an Internet subnet with limited
address-table slots in a gateway machine in which such packets were
routinely used to compete for slots, rather like Christmas shoppers
competing for scarce parking spaces.
Note: to appreciate this term fully, it helps to know that `broken
arrow' is also military jargon for an accident involving nuclear
weapons....
The canonical example of a brute-force algorithm is associated
with the `traveling salesman problem' (TSP), a classical
NP-hard problem: Suppose a person is in, say, Boston, and
wishes to drive to N other cities. In what order should the
cities be visited in order to minimize the distance travelled? The
brute-force method is to simply generate all possible routes and
compare the distances; while guaranteed to work and simple to
implement, this algorithm is clearly very stupid in that it
considers even obviously absurd routes (like going from Boston to
Houston via San Francisco and New York, in that order). For very
small N it works well, but it rapidly becomes absurdly
inefficient when N increases (for N = 15, there are
already 1,307,674,368,000 possible routes to consider, and for
N = 1000 --- well, see bignum). Sometimes,
unfortunately, there is no better general solution than brute
force. See also NP-.
A more simple-minded example of brute-force programming is finding
the smallest number in a large list by first using an existing
program to sort the list in ascending order, and then picking the
first number off the front.
Whether brute-force programming should actually be considered
stupid or not depends on the context; if the problem is not
terribly big, the extra CPU time spent on a brute-force solution
may cost less than the programmer time it would take to develop a
more `intelligent' algorithm. Additionally, a more intelligent
algorithm may imply more long-term complexity cost and bug-chasing
than are justified by the speed improvement.
Ken Thompson, co-inventor of UNIX, is reported to have uttered the
epigram "When in doubt, use brute force". He probably intended
this as a ha ha only serious, but the original UNIX kernel's
preference for simple, robust, and portable algorithms over
brittle `smart' ones does seem to have been a significant
factor in the success of that OS. Like so many other tradeoffs in
software design, the choice between brute force and complex,
finely-tuned cleverness is often a difficult one that requires both
engineering savvy and delicate esthetic judgment.
It has long been rumored that `bucky bits' were named for
Buckminster Fuller during a period when he was consulting at
Stanford. Actually, bucky bits were invented by Niklaus Wirth when
*he* was at Stanford in 1964--65; he first suggested the idea
of an EDIT key to set the 8th bit of an otherwise 7-bit ASCII
character. best-known). It seems that, unknown to Wirth, certain
Stanford hackers had privately nicknamed him `Bucky' after a
prominent portion of his dental anatomy, and this nickname
transferred to the bit. Bucky-bit commands were used in a number
of editors written at Stanford, including most notably TV-EDIT and
NLS.
The term spread to MIT and CMU early and is now in general use.
Ironically, Wirth himself remained unaware of its derivation for
nearly 30 years, until GLS dug up this history in early 1993! See
double bucky, quadruple bucky.
Historical note: Admiral Grace Hopper (an early computing pioneer
better known for inventing COBOL) liked to tell a story in
which a technician solved a glitch in the Harvard Mark II
machine by pulling an actual insect out from between the contacts
of one of its relays, and she subsequently promulgated bug in
its hackish sense as a joke about the incident (though, as she was
careful to admit, she was not there when it happened). For many
years the logbook associated with the incident and the actual bug
in question (a moth) sat in a display case at the Naval Surface
Warfare Center (NSWC). The entire story, with a picture of the
logbook and the moth taped into it, is recorded in the "Annals
of the History of Computing", Vol. 3, No. 3 (July 1981),
pp. 285--286.
The text of the log entry (from September 9, 1947), reads "1545
Relay #70 Panel F (moth) in relay. First actual case of bug being
found". This wording establishes that the term was already
in use at the time in its current specific sense --- and Hopper
herself reports that the term `bug' was regularly applied to
problems in radar electronics during WWII.
Indeed, the use of `bug' to mean an industrial defect was already
established in Thomas Edison's time, and a more specific and rather
modern use can be found in an electrical handbook from 1896
("Hawkin's New Catechism of Electricity", Theo. Audel & Co.)
which says: "The term `bug' is used to a limited extent to
designate any fault or trouble in the connections or working of
electric apparatus." It further notes that the term is "said to
have originated in quadruplex telegraphy and have been transferred
to all electric apparatus."
The latter observation may explain a common folk etymology of the
term; that it came from telephone company usage, in which "bugs in
a telephone cable" were blamed for noisy lines. Though this
derivation seems to be mistaken, it may well be a distorted memory
of a joke first current among *telegraph* operators more than
a century ago!
Actually, use of `bug' in the general sense of a disruptive event
goes back to Shakespeare! In the first edition of Samuel Johnson's
dictionary one meaning of `bug' is "A frightful object; a
walking spectre"; this is traced to `bugbear', a Welsh term for
a variety of mythological monster which (to complete the circle)
has recently been reintroduced into the popular lexicon through
fantasy role-playing games.
In any case, in jargon the word almost never refers to insects.
Here is a plausible conversation that never actually happened:
"There is a bug in this ant farm!"
"What do you mean? I don't see any ants in it."
"That's the bug."
[There has been a widespread myth that the original bug was moved
to the Smithsonian, and an earlier version of this entry so
asserted. A correspondent who thought to check discovered that the
bug was not there. While investigating this in late 1990, your
editor discovered that the NSWC still had the bug, but had
unsuccessfully tried to get the Smithsonian to accept it --- and
that the present curator of their History of American Technology
Museum didn't know this and agreed that it would make a worthwhile
exhibit. It was moved to the Smithsonian in mid-1991, but due to
space and money constraints has not yet been exhibited. Thus, the
process of investigating the original-computer-bug bug fixed it in
an entirely unexpected way, by making the myth true! --- ESR]
Technically, `busy-wait' means to wait on an event by
spinning through a tight or timed-delay loop that polls for
the event on each pass, as opposed to setting up an interrupt
handler and continuing execution on another part of the task. This
is a wasteful technique, best avoided on time-sharing systems where
a busy-waiting program may hog the processor.
Historical note: The term was coined by Werner Buchholz in 1956
during the early design phase for the IBM Stretch computer;
originally it was described as 1 to 6 bits (typical I/O equipment
of the period used 6-bit chunks of information). The move to an
8-bit byte happened in late 1956, and this size was later adopted
and promulgated as a standard by the System/360. The word was
coined by mutating the word `bite' so it would not be
accidentally misspelled as bit. See also nybble.