Full Text Archive logoFull Text Archive — Free Classic E-books

The New Hacker's Dictionary version 4.2.2 by Various editors

Part 4 out of 29

Adobe PDF icon
Download this document as a .pdf
File size: 1.8 MB
What's this? light bulb idea Many people prefer to read off-line or to print out text and read from the real printed page. Others want to carry documents around with them on their mobile phones and read while they are on the move. We have created .pdf files of all out documents to accommodate all these groups of people. We recommend that you download .pdfs onto your mobile phone when it is connected to a WiFi connection for reading off-line.

as to become completely disorganized has become bogotified. If you
tighten a nut too hard and strip the threads on the bolt, the bolt has
become bogotified and you had better not use it any more. This coinage
led to the notional `autobogotiphobia' defined as `the fear of
becoming bogotified'; but is not clear that the latter has ever been
`live' jargon rather than a self-conscious joke in jargon about
jargon. See also [1730]bogosity, [1731]bogus.

Node:bogue out, Next:[1732]bogus, Previous:[1733]bogotify, Up:[1734]=
B =

bogue out /bohg owt/ vi.

To become bogus, suddenly and unexpectedly. "His talk was relatively
sane until somebody asked him a trick question; then he bogued out and
did nothing but [1735]flame afterwards." See also [1736]bogosity,

Node:bogus, Next:[1738]Bohr bug, Previous:[1739]bogue out, Up:[1740]=
B =

bogus adj.

1. Non-functional. "Your patches are bogus." 2. Useless. "OPCON is a
bogus program." 3. False. "Your arguments are bogus." 4. Incorrect.
"That algorithm is bogus." 5. Unbelievable. "You claim to have solved
the halting problem for Turing Machines? That's totally bogus." 6.
Silly. "Stop writing those bogus sagas."

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 [1741]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 there about
1975-76. These coinages spread into hackerdom from CMU and MIT. Most
of them remained wordplay objects rather than actual vocabulary items
or live metaphors. Examples: `amboguous' (having multiple bogus
interpretations); `bogotissimo' (in a gloriously bogus manner);
`bogotophile' (one who is pathologically fascinated by the bogus);
`paleobogology' (the study of primeval bogosity).

Some bogowords, however, obtained sufficient live currency to be
listed elsewhere in this lexicon; see [1742]bogometer, [1743]bogon,
[1744]bogotify, and [1745]quantum bogodynamics and the related but
unlisted [1746]Dr. Fred Mbogo.

By the early 1980s `bogus' was also current in something like hacker
usage 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".

Node:Bohr bug, Next:[1747]boink, Previous:[1748]bogus, Up:[1749]= B =

Bohr bug /bohr buhg/ n.

[from quantum physics] A repeatable [1750]bug; one that manifests
reliably under a possibly unknown but well-defined set of conditions.
Antonym of [1751]heisenbug; see also [1752]mandelbug,

Node:boink, Next:[1754]bomb, Previous:[1755]Bohr bug, Up:[1756]= B =

boink /boynk/

[Usenet: variously ascribed to the TV series "Cheers" "Moonlighting",
and "Soap"] 1. v. To have sex with; compare [1757]bounce, sense 3.
(This is mainstream slang.) In Commonwealth hackish the variant `bonk'
is more common. 2. n. After the original Peter Korn `Boinkon'
[1758]Usenet parties, used for almost any net social gathering, e.g.,
Miniboink, a small boink held by Nancy Gillett in 1988; Minniboink, a
Boinkcon in Minnesota in 1989; Humpdayboinks, Wednesday get-togethers
held in the San Francisco Bay Area. Compare [1759]@-party. 3. Var of
`bonk'; see [1760]bonk/oif.

Node:bomb, Next:[1761]bondage-and-discipline language,
Previous:[1762]boink, Up:[1763]= B =


1. v. General synonym for [1764]crash (sense 1) except that it is not
used as a noun; esp. used of software or OS failures. "Don't run
Empire with less than 32K stack, it'll bomb." 2. n.,v. Atari ST and
Macintosh equivalents of a Unix `panic' or Amiga [1765]guru
meditation, in which icons of little black-powder bombs or mushroom
clouds are displayed, indicating that the system has died. On the Mac,
this may be accompanied by a decimal (or occasionally hexadecimal)
number indicating what went wrong, similar to the Amiga [1766]guru
meditation number. [1767]MS-DOS machines tend to get [1768]locked up
in this situation.

Node:bondage-and-discipline language, Next:[1769]bonk/oif,
Previous:[1770]bomb, Up:[1771]= B =

bondage-and-discipline language n.

A language (such as [1772]Pascal, [1773]Ada, APL, or Prolog) that,
though ostensibly general-purpose, is designed so as to enforce an
author's theory of `right programming' even though said theory is
demonstrably inadequate for systems hacking or even vanilla
general-purpose programming. Often abbreviated `B&D'; thus, one may
speak of things "having the B&D nature". See [1774]Pascal; oppose
[1775]languages of choice.

Node:bonk/oif, Next:[1776]book titles,
Previous:[1777]bondage-and-discipline language, Up:[1778]= B =

bonk/oif /bonk/, /oyf/ interj.

In the U.S. [1779]MUD community, it has become traditional to express
pique or censure by `bonking' the offending person. Convention holds
that one should acknowledge a bonk by saying `oif!' and there is a
myth to the effect that failing to do so upsets the cosmic bonk/oif
balance, causing much trouble in the universe. Some MUDs have
implemented special commands for bonking and oifing. Note: in parts of
the U.K. `bonk' is a sexually loaded slang term; care is advised in
transatlantic conversations (see [1780]boink). Commonwealth hackers
report a similar convention involving the `fish/bang' balance. See
also [1781]talk mode.

Node:book titles, Next:[1782]boot, Previous:[1783]bonk/oif, Up:[1784]=
B =

book titles

There is a tradition in hackerdom of informally tagging important
textbooks and standards documents with the dominant color of their
covers or with some other conspicuous feature of the cover. Many of
these are described in this lexicon under their own entries. See
[1785]Aluminum Book, [1786]Blue Book, [1787]Camel Book,
[1788]Cinderella Book, [1789]Devil Book, [1790]Dragon Book,
[1791]Green Book, [1792]Orange Book, [1793]Purple Book, [1794]Red
Book, [1795]Silver Book, [1796]White Book, [1797]Wizard Book,
[1798]Yellow Book, and [1799]bible; see also [1800]rainbow series.
Since about 1983 this tradition has gotten a boost from the popular
O'Reilly and Associates line of technical books, which usually feature
some kind of exotic animal on the cover.

Node:boot, Next:[1801]Borg, Previous:[1802]book titles, Up:[1803]= B =

boot v.,n.

[techspeak; from `by one's bootstraps'] To load and initialize the
operating system on a machine. This usage is no longer jargon (having
passed into techspeak) but has given rise to some derivatives that are
still jargon.

The derivative `reboot' implies that the machine hasn't been down for
long, or that the boot is a [1804]bounce (sense 4) intended to clear
some state of [1805]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 [1806]mess-dos emulator, control-alt-insert will cause a
soft-boot of the emulator, while leaving the rest of the system

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 [1807]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.

Node:Borg, Next:[1808]borken, Previous:[1809]boot, Up:[1810]= B =

Borg n.

In "Star Trek: The Next Generation" the Borg is a species of cyborg
that ruthlessly seeks to incorporate all sentient life into itself;
their slogan is "You will be assimilated. Resistance is futile." In
hacker parlance, the Borg is usually [1811]Microsoft, which is thought
to be trying just as ruthlessly to assimilate all computers and the
entire Internet to itself (there is a widely circulated image of Bill
Gates as a Borg). Being forced to use Windows or NT is often referred
to as being "Borged". Interestingly, the [1812]Halloween Documents
reveal that this jargon is live within Microsoft itself. (Other
companies, notably Intel and UUNet, have also occasionally been
equated to the Borg.) See also [1813]Evil Empire, [1814]Internet

In IETF circles, where direct pressure from Microsoft is not a daily
reality, the Borg is sometimes Cisco. This usage commemmorates their
tendency to pay any price to hire talent away from their competitors.
In fact, at the Spring 1997 IETF, a large number of ex-Cisco
employees, all former members of Routing Geeks, showed up with
t-shirts printed with "Recovering Borg".

Node:borken, Next:[1815]bot, Previous:[1816]Borg, Up:[1817]= B =

borken adj.

(also `borked') Common deliberate typo for `broken'.

Node:bot, Next:[1818]bot spot, Previous:[1819]borken, Up:[1820]= B =

bot n

[common on IRC, MUD and among gamers; from `robot'] 1. An [1821]IRC or
[1822]MUD user who is actually a program. On IRC, typically the robot
provides some useful service. Examples are NickServ, which tries to
prevent random users from adopting [1823]nicks already claimed by
others, and MsgServ, which allows one to send asynchronous messages to
be delivered when the recipient signs on. Also common are `annoybots',
such as KissServ, which perform no useful function except to send cute
messages to other people. Service bots are less common on MUDs; but
some others, such as the `Julia' bot active in 1990-91, have been
remarkably impressive Turing-test experiments, able to pass as human
for as long as ten or fifteen minutes of conversation. 2. An
AI-controlled player in a computer game (especially a first-person
shooter such as Quake) which, unlike ordinary monsters, operates like
a human-controlled player, with access to a player's weapons and
abilities. An example can be found at
[1824]http://www.telefragged.com/thefatal/. 3. Term used, though less
commonly, for a web [1825]spider. The file for controlling spider
behavior on your site is officially the "Robots Exclusion File" and
its URL is "http:///robots.txt")

Note that bots in all senses were `robots' when the terms first
appeared in the early 1990s, but the shortened form is now habitual.

Node:bot spot, Next:[1826]bottom feeder, Previous:[1827]bot,
Up:[1828]= B =

bot spot n.

[MUD] The user on a MUD with the longest connect time. Derives from
the fact that [1829]bots on MUDS often stay constantly connected and
appear at the bottom of the list.

Node:bottom feeder, Next:[1830]bottom-up implementation,
Previous:[1831]bot spot, Up:[1832]= B =

bottom feeder n.

1. An Internet user that leeches off ISPs - the sort you can never
provide good enough services for, always complains about the price, no
matter how low it may be, and will bolt off to another service the
moment there is even the slimmest price difference. While most bottom
feeders infest free or almost free services such as AOL, MSN, and
Hotmail, too many flock to whomever happens to be the cheapest
regional ISP at the time. Bottom feeders are often the classic problem
user, known for unleashing spam, flamage, and other breaches of
[1833]netiquette. 2. Syn. for [1834]slopsucker, derived from the
fishermen's and naturalists' term for finny creatures who subsist on
the primordial ooze. (This sense is older.)

Node:bottom-up implementation, Next:[1835]bounce,
Previous:[1836]bottom feeder, Up:[1837]= B =

bottom-up implementation n.

Hackish opposite of the techspeak term `top-down design'. It has been
received wisdom in most programming cultures that it is best to design
from higher levels of abstraction down to lower, specifying sequences
of action in increasing detail until you get to actual code. Hackers
often find (especially in exploratory designs that cannot be closely
specified in advance) that it works best to build things in the
opposite order, by writing and testing a clean set of primitive
operations and then knitting them together. Naively applied, this
leads to hacked-together bottom-up implementations; a more
sophisticated response is `middle-out implementation', in which
scratch code within primitives at the mid-level of the system is
gradually replaced with a more polished version of the lowest level at
the same time the structure above the midlevel is being built.

Node:bounce, Next:[1838]bounce message, Previous:[1839]bottom-up
implementation, Up:[1840]= B =

bounce v.

1. [common; perhaps by analogy to a bouncing check] An electronic mail
message that is undeliverable and returns an error notification to the
sender is said to `bounce'. See also [1841]bounce message. 2.
[Stanford] To play volleyball. The now-demolished [1842]D. C. Power
Lab building used by the Stanford AI Lab in the 1970s had a volleyball
court on the front lawn. From 5 P.M. to 7 P.M. was the scheduled
maintenance time for the computer, so every afternoon at 5 would come
over the intercom the cry: "Now hear this: bounce, bounce!", followed
by Brian McCune loudly bouncing a volleyball on the floor outside the
offices of known volleyballers. 3. To engage in sexual intercourse;
prob. from the expression `bouncing the mattress', but influenced by
Roo's psychosexually loaded "Try bouncing me, Tigger!" from the
"Winnie-the-Pooh" books. Compare [1843]boink. 4. To casually reboot a
system in order to clear up a transient problem. Reported primarily
among [1844]VMS and [1845]Unix users. 5. [VM/CMS programmers]
Automatic warm-start of a machine after an error. "I logged on this
morning and found it had bounced 7 times during the night" 6. [IBM] To
[1846]power cycle a peripheral in order to reset it.

Node:bounce message, Next:[1847]boustrophedon, Previous:[1848]bounce,
Up:[1849]= B =

bounce message n.

[common] Notification message returned to sender by a site unable to
relay [1850]email to the intended [1851]Internet address recipient or
the next link in a [1852]bang path (see [1853]bounce, sense 1).
Reasons might include a nonexistent or misspelled username or a
[1854]down relay site. Bounce messages can themselves fail, with
occasionally ugly results; see [1855]sorcerer's apprentice mode and
[1856]software laser. The terms `bounce mail' and `barfmail' are also

Node:boustrophedon, Next:[1857]box, Previous:[1858]bounce message,
Up:[1859]= B =

boustrophedon n.

[from a Greek word for turning like an ox while plowing] An ancient
method of writing using alternate left-to-right and right-to-left
lines. This term is actually philologists' techspeak and typesetters'
jargon. Erudite hackers use it for an optimization performed by some
computer typesetting software and moving-head printers. The adverbial
form `boustrophedonically' is also found (hackers purely love
constructions like this).

Node:box, Next:[1860]boxed comments, Previous:[1861]boustrophedon,
Up:[1862]= B =

box n.

1. A computer; esp. in the construction `foo box' where foo is some
functional qualifier, like `graphics', or the name of an OS (thus,
`Unix box', `MS-DOS box', etc.) "We preprocess the data on Unix boxes
before handing it up to the mainframe." 2. [IBM] Without qualification
but within an SNA-using site, this refers specifically to an IBM
front-end processor or FEP /F-E-P/. An FEP is a small computer
necessary to enable an IBM [1863]mainframe to communicate beyond the
limits of the [1864]dinosaur pen. Typically used in expressions like
the cry that goes up when an SNA network goes down: "Looks like the
[1865]box has fallen over." (See [1866]fall over.) See also [1867]IBM,
[1868]fear and loathing, [1869]Blue Glue.

Node:boxed comments, Next:[1870]boxen, Previous:[1871]box, Up:[1872]=
B =

boxed comments n.

Comments (explanatory notes attached to program instructions) that
occupy several lines by themselves; so called because in assembler and
C code they are often surrounded by a box in a style something like

* 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 [1873]winged comments.

Node:boxen, Next:[1874]boxology, Previous:[1875]boxed comments,
Up:[1876]= B =

boxen /bok'sn/ pl.n.

[very common; by analogy with [1877]VAXen] Fanciful plural of
[1878]box often encountered in the phrase `Unix boxen', used to
describe commodity [1879]Unix hardware. The connotation is that any
two Unix boxen are interchangeable.

Node:boxology, Next:[1880]bozotic, Previous:[1881]boxen, Up:[1882]= B

boxology /bok-sol'*-jee/ n.

Syn. [1883]ASCII art. This term implies a more restricted domain, that
of box-and-arrow drawings. "His report has a lot of boxology in it."
Compare [1884]macrology.

Node:bozotic, Next:[1885]BQS, Previous:[1886]boxology, Up:[1887]= B =

bozotic /boh-zoh'tik/ or /boh-zo'tik/ adj.

[from the name of a TV clown even more losing than Ronald McDonald]
Resembling or having the quality of a bozo; that is, clownish,
ludicrously wrong, unintentionally humorous. Compare [1888]wonky,
[1889]demented. Note that the noun `bozo' occurs in slang, but the
mainstream adjectival form would be `bozo-like' or (in New England)

Node:BQS, Next:[1890]brain dump, Previous:[1891]bozotic, Up:[1892]= B

BQS /B-Q-S/ adj.

Syn. [1893]Berkeley Quality Software.

Node:brain dump, Next:[1894]brain fart, Previous:[1895]BQS, Up:[1896]=
B =

brain dump n.

[common] The act of telling someone everything one knows about a
particular topic or project. Typically used when someone is going to
let a new party maintain a piece of code. Conceptually analogous to an
operating system [1897]core dump in that it saves a lot of useful
[1898]state before an exit. "You'll have to give me a brain dump on
FOOBAR before you start your new job at HackerCorp." See [1899]core
dump (sense 4). At Sun, this is also known as `TOI' (transfer of

Node:brain fart, Next:[1900]brain-damaged, Previous:[1901]brain dump,
Up:[1902]= B =

brain fart n.

The actual result of a [1903]braino, as opposed to the mental glitch
that is the braino itself. E.g., typing dir on a Unix box after a
session with DOS.

Node:brain-damaged, Next:[1904]brain-dead, Previous:[1905]brain fart,
Up:[1906]= B =

brain-damaged adj.

1. [common; generalization of `Honeywell Brain Damage' (HBD), a
theoretical disease invented to explain certain utter cretinisms in
Honeywell [1907]Multics] adj. Obviously wrong; [1908]cretinous;
[1909]demented. There is an implication that the person responsible
must have suffered brain damage, because he should have known better.
Calling something brain-damaged is really bad; it also implies it is
unusable, and that its failure to work is due to poor design rather
than some accident. "Only six monocase characters per file name? Now
that's brain-damaged!" 2. [esp. in the Mac world] May refer to free
demonstration software that has been deliberately crippled in some way
so as not to compete with the product it is intended to sell. Syn.

Node:brain-dead, Next:[1911]braino, Previous:[1912]brain-damaged,
Up:[1913]= B =

brain-dead adj.

[common] Brain-damaged in the extreme. It tends to imply terminal
design failure rather than malfunction or simple stupidity. "This comm
program doesn't know how to send a break -- how brain-dead!"

Node:braino, Next:[1914]branch to Fishkill, Previous:[1915]brain-dead,
Up:[1916]= B =

braino /bray'no/ n.

Syn. for [1917]thinko. See also [1918]brain fart.

Node:branch to Fishkill, Next:[1919]bread crumbs,
Previous:[1920]braino, Up:[1921]= B =

branch to Fishkill n.

[IBM: from the location of one of the corporation's facilities] Any
unexpected jump in a program that produces catastrophic or just plain
weird results. See [1922]jump off into never-never land,

Node:bread crumbs, Next:[1924]break, Previous:[1925]branch to
Fishkill, Up:[1926]= B =

bread crumbs n.

1. Debugging statements inserted into a program that emit output or
log indicators of the program's [1927]state to a file so you can see
where it dies or pin down the cause of surprising behavior. The term
is probably a reference to the Hansel and Gretel story from the
Brothers Grimm or the older French folktale of Thumbelina; in several
variants of these, a character leaves a trail of bread crumbs so as
not to get lost in the woods. 2. In user-interface design, any feature
that allows some tracking of where you've been, like coloring visited
links purple rather than blue in Netscape (also called `footrinting').

Node:break, Next:[1928]break-even point, Previous:[1929]bread crumbs,
Up:[1930]= B =


1. vt. To cause to be [1931]broken (in any sense). "Your latest patch
to the editor broke the paragraph commands." 2. v. (of a program) To
stop temporarily, so that it may debugged. The place where it stops is
a `breakpoint'. 3. [techspeak] vi. To send an RS-232 break (two
character widths of line high) over a serial comm line. 4. [Unix] vi.
To strike whatever key currently causes the tty driver to send SIGINT
to the current process. Normally, break (sense 3), delete or
[1932]control-C does this. 5. `break break' may be said to interrupt a
conversation (this is an example of verb doubling). This usage comes
from radio communications, which in turn probably came from landline
telegraph/teleprinter usage, as badly abused in the Citizen's Band
craze a few years ago.

Node:break-even point, Next:[1933]breath-of-life packet,
Previous:[1934]break, Up:[1935]= B =

break-even point n.

In the process of implementing a new computer language, the point at
which the language is sufficiently effective that one can implement
the language in itself. That is, for a new language called,
hypothetically, FOOGOL, one has reached break-even when one can write
a demonstration compiler for FOOGOL in FOOGOL, discard the original
implementation language, and thereafter use working versions of FOOGOL
to develop newer ones. This is an important milestone; see [1936]MFTL.

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 [1937]VAXen in the
early and mid-1980s. A FOOGOL implementation is available at the
Retrocomputing Museum [1938]http://www.ccil.org/retro.

Node:breath-of-life packet, Next:[1939]breedle,
Previous:[1940]break-even point, Up:[1941]= B =

breath-of-life packet n.

[XEROX PARC] An Ethernet packet that contains bootstrap (see
[1942]boot) code, periodically sent out from a working computer to
infuse the `breath of life' into any computer on the network that has
happened to crash. Machines depending on such packets have sufficient
hardware or firmware code to wait for (or request) such a packet
during the reboot process. See also [1943]dickless workstation.

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

Node:breedle, Next:[1944]Breidbart Index,
Previous:[1945]breath-of-life packet, Up:[1946]= B =

breedle n.

See [1947]feep.

Node:Breidbart Index, Next:[1948]bring X to its knees,
Previous:[1949]breedle, Up:[1950]= B =

Breidbart Index /bri:d'bart ind*ks/

A measurement of the severity of spam invented by long-time hacker
Seth Breidbart, used for programming cancelbots. The Breidbart Index
takes into account the fact that excessive multi-posting [1951]EMP is
worse than excessive cross-posting [1952]ECP. The Breidbart Index is
computed as follows: For each article in a spam, take the square-root
of the number of newsgroups to which the article is posted. The
Breidbart Index is the sum of the square roots of all of the posts in
the spam. For example, one article posted to nine newsgroups and again
to sixteen would have BI = sqrt(9) + sqrt(16) = 7. It is generally
agreed that a spam is cancelable if the Breidbart Index exceeds 20.

The Breidbart Index accumulates over a 45-day window. Ten articles
yesterday and ten articles today and ten articles tomorrow add up to a
30-article spam. Spam fighters will often reset the count if you can
convince them that the spam was accidental and/or you have seen the
error of your ways and won't repeat it. Breidbart Index can accumulate
over multiple authors. For example, the "Make Money Fast" pyramid
scheme exceeded a BI of 20 a long time ago, and is now considered
"cancel on sight".

Node:bring X to its knees, Next:[1953]brittle,
Previous:[1954]Breidbart Index, Up:[1955]= B =

bring X to its knees v.

[common] To present a machine, operating system, piece of software, or
algorithm with a load so extreme or [1956]pathological that it grinds
to a halt. "To bring a MicroVAX to its knees, try twenty users running
[1957]vi -- or four running [1958]EMACS." Compare [1959]hog.

Node:brittle, Next:[1960]broadcast storm, Previous:[1961]bring X to
its knees, Up:[1962]= B =

brittle adj.

Said of software that is functional but easily broken by changes in
operating environment or configuration, or by any minor tweak to the
software itself. Also, any system that responds inappropriately and
disastrously to abnormal but expected external stimuli; e.g., a file
system that is usually totally scrambled by a power failure is said to
be brittle. This term is often used to describe the results of a
research effort that were never intended to be robust, but it can be
applied to commercial software, which (due to closed-source
development) displays the quality far more often than it ought to.
Oppose [1963]robust.

Node:broadcast storm, Next:[1964]brochureware, Previous:[1965]brittle,
Up:[1966]= B =

broadcast storm n.

[common] An incorrect packet broadcast on a network that causes most
hosts to respond all at once, typically with wrong answers that start
the process over again. See [1967]network meltdown; compare [1968]mail

Node:brochureware, Next:[1969]broken, Previous:[1970]broadcast storm,
Up:[1971]= B =

brochureware n.

Planned but non-existent product like [1972]vaporware, but with the
added implication that marketing is actively selling and promoting it
(they've printed brochures). Brochureware is often deployed as a
strategic weapon; the idea is to con customers into not committing to
an existing product of the competition's. It is a safe bet that when a
brochureware product finally becomes real, it will be more expensive
than and inferior to the alternatives that had been available for

Node:broken, Next:[1973]broken arrow, Previous:[1974]brochureware,
Up:[1975]= B =

broken adj.

1. Not working properly (of programs). 2. Behaving strangely;
especially (when used of people) exhibiting extreme depression.

Node:broken arrow, Next:[1976]BrokenWindows, Previous:[1977]broken,
Up:[1978]= B =

broken arrow n.

[IBM] The error code displayed on line 25 of a 3270 terminal (or a PC
emulating a 3270) for various kinds of protocol violations and
"unexpected" error conditions (including connection to a [1979]down
computer). On a PC, simulated with `->/_', with the two center
characters overstruck.

Note: to appreciate this term fully, it helps to know that `broken
arrow' is also military jargon for an accident involving nuclear

Node:BrokenWindows, Next:[1980]broket, Previous:[1981]broken arrow,
Up:[1982]= B =

BrokenWindows n.

Abusive hackerism for the [1983]crufty and [1984]elephantine [1985]X
environment on Sun machines; properly called `OpenWindows'.

Node:broket, Next:[1986]Brooks's Law, Previous:[1987]BrokenWindows,
Up:[1988]= B =

broket /broh'k*t/ or /broh'ket`/ n.

[rare; by analogy with `bracket': a `broken bracket'] Either of the
characters < and >, when used as paired enclosing delimiters. This
word originated as a contraction of the phrase `broken bracket', that
is, a bracket that is bent in the middle. (At MIT, and apparently in
the [1989]Real World as well, these are usually called [1990]angle

Node:Brooks's Law, Next:[1991]brown-paper-bag bug,
Previous:[1992]broket, Up:[1993]= B =

Brooks's Law prov.

"Adding manpower to a late software project makes it later" -- a
result of the fact that the expected advantage from splitting
development work among N programmers is O(N) (that is, proportional to
N), but the complexity and communications cost associated with
coordinating and then merging their work is O(N^2) (that is,
proportional to the square of N). The quote is from Fred Brooks, a
manager of IBM's OS/360 project and author of "The Mythical Man-Month"
(Addison-Wesley, 1975, ISBN 0-201-00650-2), an excellent early book on
software engineering. The myth in question has been most tersely
expressed as "Programmer time is fungible" and Brooks established
conclusively that it is not. Hackers have never forgotten his advice
(though it's not the whole story; see [1994]bazaar); too often,
[1995]management still does. See also [1996]creationism,
[1997]second-system effect, [1998]optimism.

Node:brown-paper-bag bug, Next:[1999]browser, Previous:[2000]Brooks's
Law, Up:[2001]= B =

brown-paper-bag bug n.

A bug in a public software release that is so embarrassing that the
author notionally wears a brown paper bag over his head for a while so
he won't be recognized on the net. Entered popular usage after the
early-1999 release of the first Linux 2.2, which had one. The phrase
was used in Linus Torvalds's apology posting.

Node:browser, Next:[2002]BRS, Previous:[2003]brown-paper-bag bug,
Up:[2004]= B =

browser n.

A program specifically designed to help users view and navigate
hypertext, on-line documentation, or a database. While this general
sense has been present in jargon for a long time, the proliferation of
browsers for the World Wide Web after 1992 has made it much more
popular and provided a central or default techspeak meaning of the
word previously lacking in hacker usage. Nowadays, if someone mentions
using a `browser' without qualification, one may assume it is a Web

Node:BRS, Next:[2005]brute force, Previous:[2006]browser, Up:[2007]= B

BRS /B-R-S/ n.

Syn. [2008]Big Red Switch. This abbreviation is fairly common on-line.

Node:brute force, Next:[2009]brute force and ignorance,
Previous:[2010]BRS, Up:[2011]= B =

brute force adj.

Describes a primitive programming style, one in which the programmer
relies on the computer's processing power instead of using his or her
own intelligence to simplify the problem, often ignoring problems of
scale and applying naive methods suited to small problems directly to
large ones. The term can also be used in reference to programming
style: brute-force programs are written in a heavyhanded, tedious way,
full of repetition and devoid of any elegance or useful abstraction
(see also [2012]brute force and ignorance).

The [2013]canonical example of a brute-force algorithm is associated
with the `traveling salesman problem' (TSP), a classical [2014]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 [2015]bignum). Sometimes, unfortunately, there is no better
general solution than brute force. See also [2016]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 [2017]ha ha only serious, but the original Unix kernel's preference
for simple, robust, and portable algorithms over [2018]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.

Node:brute force and ignorance, Next:[2019]BSD, Previous:[2020]brute
force, Up:[2021]= B =

brute force and ignorance n.

A popular design technique at many software houses -- [2022]brute
force coding unrelieved by any knowledge of how problems have been
previously solved in elegant ways. Dogmatic adherence to design
methodologies tends to encourage this sort of thing. Characteristic of
early [2023]larval stage programming; unfortunately, many never
outgrow it. Often abbreviated BFI: "Gak, they used a [2024]bubble
sort! That's strictly from BFI." Compare [2025]bogosity.

Node:BSD, Next:[2026]BSOD, Previous:[2027]brute force and ignorance,
Up:[2028]= B =

BSD /B-S-D/ n.

[abbreviation for `Berkeley Software Distribution'] a family of
[2029]Unix versions for the [2030]DEC [2031]VAX and PDP-11 developed
by Bill Joy and others at [2032]Berzerkeley starting around 1977,
incorporating paged virtual memory, TCP/IP networking enhancements,
and many other features. The BSD versions (4.1, 4.2, and 4.3) and the
commercial versions derived from them (SunOS, ULTRIX, and Mt. Xinu)
held the technical lead in the Unix world until AT&T's successful
standardization efforts after about 1986; descendants including
Free/Open/NetBSD, BSD/OS and MacOS X are still widely popular. Note
that BSD versions going back to 2.9 are often referred to by their
version numbers alone, without the BSD prefix. See [2033]4.2,
[2034]Unix, [2035]USG Unix.

Node:BSOD, Next:[2036]BUAF, Previous:[2037]BSD, Up:[2038]= B =


Very commmon abbreviation for [2039]Blue Screen of Death. Both spoken
and written.

Node:BUAF, Next:[2040]BUAG, Previous:[2041]BSOD, Up:[2042]= B =

BUAF // n.

[abbreviation, from alt.fan.warlord] Big Ugly ASCII Font -- a special
form of [2043]ASCII art. Various programs exist for rendering text
strings into block, bloob, and pseudo-script fonts in cells between
four and six character cells on a side; this is smaller than the
letters generated by older [2044]banner (sense 2) programs. These are
sometimes used to render one's name in a [2045]sig block, and are
critically referred to as `BUAF's. See [2046]warlording.

Node:BUAG, Next:[2047]bubble sort, Previous:[2048]BUAF, Up:[2049]= B =

BUAG // n.

[abbreviation, from alt.fan.warlord] Big Ugly ASCII Graphic.
Pejorative term for ugly [2050]ASCII art, especially as found in
[2051]sig blocks. For some reason, mutations of the head of Bart
Simpson are particularly common in the least imaginative [2052]sig
blocks. See [2053]warlording.

Node:bubble sort, Next:[2054]bucky bits, Previous:[2055]BUAG,
Up:[2056]= B =

bubble sort n.

Techspeak for a particular sorting technique in which pairs of
adjacent values in the list to be sorted are compared and interchanged
if they are out of order; thus, list entries `bubble upward' in the
list until they bump into one with a lower sort value. Because it is
not very good relative to other methods and is the one typically
stumbled on by [2057]naive and untutored programmers, hackers consider
it the [2058]canonical example of a naive algorithm. (However, it's
been shown by repeated experiment that below about 5000 records
bubble-sort is OK anyway.) The canonical example of a really bad
algorithm is [2059]bogo-sort. A bubble sort might be used out of
ignorance, but any use of bogo-sort could issue only from brain damage
or willful perversity.

Node:bucky bits, Next:[2060]buffer chuck, Previous:[2061]bubble sort,
Up:[2062]= B =

bucky bits /buh'kee bits/ n.

1. obs. The bits produced by the CONTROL and META shift keys on a SAIL
keyboard (octal 200 and 400 respectively), resulting in a 9-bit
keyboard character set. The MIT AI TV (Knight) keyboards extended this
with TOP and separate left and right CONTROL and META keys, resulting
in a 12-bit character set; later, LISP Machines added such keys as
SUPER, HYPER, and GREEK (see [2063]space-cadet keyboard). 2. By
extension, bits associated with `extra' shift keys on any keyboard,
e.g., the ALT on an IBM PC or command and option keys on a Macintosh.

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). 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
[2064]double bucky, [2065]quadruple bucky.

Node:buffer chuck, Next:[2066]buffer overflow, Previous:[2067]bucky
bits, Up:[2068]= B =

buffer chuck n.

Shorter and ruder syn. for [2069]buffer overflow.

Node:buffer overflow, Next:[2070]bug, Previous:[2071]buffer chuck,
Up:[2072]= B =

buffer overflow n.

What happens when you try to stuff more data into a buffer (holding
area) than it can handle. This problem is commonly exploited by
[2073]crackers to get arbitrary commands executed by a program running
with root permissions. This may be due to a mismatch in the processing
rates of the producing and consuming processes (see [2074]overrun and
[2075]firehose syndrome), or because the buffer is simply too small to
hold all the data that must accumulate before a piece of it can be
processed. For example, in a text-processing tool that [2076]crunches
a line at a time, a short line buffer can result in [2077]lossage as
input from a long line overflows the buffer and trashes data beyond
it. Good defensive programming would check for overflow on each
character and stop accepting data when the buffer is full up. The term
is used of and by humans in a metaphorical sense. "What time did I
agree to meet you? My buffer must have overflowed." Or "If I answer
that phone my buffer is going to overflow." See also [2078]spam,
[2079]overrun screw.

Node:bug, Next:[2080]bug-compatible, Previous:[2081]buffer overflow,
Up:[2082]= B =

bug n.

An unwanted and unintended property of a program or piece of hardware,
esp. one that causes it to malfunction. Antonym of [2083]feature.
Examples: "There's a bug in the editor: it writes things out
backwards." "The system crashed because of a hardware bug." "Fred is a
winner, but he has a few bugs" (i.e., Fred is a good guy, but he has a
few personality problems).

Historical note: Admiral Grace Hopper (an early computing pioneer
better known for inventing [2084]COBOL) liked to tell a story in which
a technician solved a [2085]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 [2086]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!

Or perhaps not a joke. Historians of the field inform us that the term
"bug" was regularly used in the early days of telegraphy to refer to a
variety of semi-automatic telegraphy keyers that would send a string
of dots if you held them down. In fact, the Vibroplex keyers (which
were among the most common of this type) even had a graphic of a
beetle on them (and still do)! While the ability to send repeated dots
automatically was very useful for professional morse code operators,
these were also significantly trickier to use than the older manual
keyers, and it could take some practice to ensure one didn't introduce
extraneous dots into the code by holding the key down a fraction too
long. In the hands of an inexperienced operator, a Vibroplex "bug" on
the line could mean that a lot of garbled Morse would soon be coming
your way.

Further, the term "bug" has long been used among radio technicians to
describe a device that converts electromagnetic field variations into
acoustic signals. It is used to trace radio interference and look for
dangerous radio emissions. Radio community usage derives from the
roach-like shape of the first versions used by 19th century
physicists. The first versions consisted of a coil of wire (roach
body), with the two wire ends sticking out and bent back to nearly
touch forming a spark gap (roach antennae). The bug is to the radio
technician what the stethoscope is to the stereotype medical doctor.
This sense is almost certainly ancestral to modern use of "bug" for a
covert monitoring device, but may also have contributed to the use of
"bug" for the effects of radio interference itself.

Actually, use of `bug' in the general sense of a disruptive event goes
back to Shakespeare! (Henry VI, part III - Act V, Scene II: King
Edward: "So, lie thou there. Die thou; and die our fear; For Warwick
was a bug that fear'd us all.") 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."

A careful discussion of the etymological issues can be found in a
paper by Fred R. Shapiro, 1987, "Entomology of the Computer Bug:
History and Folklore", American Speech 62(4):376-378.

[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 was not actually
exhibited years afterwards. Thus, the process of investigating the
original-computer-bug bug fixed it in an entirely unexpected way, by
making the myth true! --ESR]

Node:bug-compatible, Next:[2087]bug-for-bug compatible,
Previous:[2088]bug, Up:[2089]= B =

bug-compatible adj.

[common] Said of a design or revision that has been badly compromised
by a requirement to be compatible with [2090]fossils or
[2091]misfeatures in other programs or (esp.) previous releases of
itself. "MS-DOS 2.0 used \ as a path separator to be bug-compatible
with some cretin's choice of / as an option character in 1.0."

Node:bug-for-bug compatible, Next:[2092]bug-of-the-month club,
Previous:[2093]bug-compatible, Up:[2094]= B =

bug-for-bug compatible n.

Same as [2095]bug-compatible, with the additional implication that
much tedious effort went into ensuring that each (known) bug was

Node:bug-of-the-month club, Next:[2096]buglix,
Previous:[2097]bug-for-bug compatible, Up:[2098]= B =

bug-of-the-month club n.

[from "book-of-the-month club", a time-honored mail-order-marketing
technique in the U.S.] A mythical club which users of `sendmail(8)'
(the UNIX mail daemon) belong to; this was coined on the Usenet
newsgroup comp.security.unix at a time when sendmail security holes,
which allowed outside [2099]crackers access to the system, were being
uncovered at an alarming rate, forcing sysadmins to update very often.
Also, more completely, `fatal security bug-of-the-month club'. See
also [2100]kernel-of-the-week club.

Node:buglix, Next:[2101]bulletproof, Previous:[2102]bug-of-the-month
club, Up:[2103]= B =

buglix /buhg'liks/ n.

[uncommon] Pejorative term referring to [2104]DEC's ULTRIX operating
system in its earlier severely buggy versions. Still used to describe
ULTRIX, but without nearly so much venom. Compare [2105]AIDX,
[2106]HP-SUX, [2107]Nominal Semidestructor, [2108]Telerat,

Node:bulletproof, Next:[2110]bullschildt, Previous:[2111]buglix,
Up:[2112]= B =

bulletproof adj.

Used of an algorithm or implementation considered extremely
[2113]robust; lossage-resistant; capable of correctly recovering from
any imaginable exception condition -- a rare and valued quality.
Implies that the programmer has thought of all possible errors, and
added [2114]code to protect against each one. Thus, in some cases,
this can imply code that is too heavyweight, due to excessive paranoia
on the part of the programmer. Syn. [2115]armor-plated.

Node:bullschildt, Next:[2116]bum, Previous:[2117]bulletproof,
Up:[2118]= B =

bullschildt /bul'shilt/ n.

[comp.lang.c on USENET] A confident, but incorrect, statement about a
programming language. This immortalizes a very bad book about [2119]C,
Herbert Schildt's "C - The Complete Reference". One reviewer commented
"The naive errors in this book would be embarassing even in a
programming assignment turned in by a computer science college

Node:bum, Next:[2120]bump, Previous:[2121]bullschildt, Up:[2122]= B =


1. vt. To make highly efficient, either in time or space, often at the
expense of clarity. "I managed to bum three more instructions out of
that code." "I spent half the night bumming the interrupt code." In
1996, this term and the practice it describes are semi-obsolete. In
[2123]elder days, John McCarthy (inventor of [2124]LISP) used to
compare some efficiency-obsessed hackers among his students to "ski
bums"; thus, optimization became "program bumming", and eventually
just "bumming". 2. To squeeze out excess; to remove something in order
to improve whatever it was removed from (without changing function;
this distinguishes the process from a [2125]featurectomy). 3. n. A
small change to an algorithm, program, or hardware device to make it
more efficient. "This hardware bum makes the jump instruction faster."
Usage: now uncommon, largely superseded by v. [2126]tune (and n.
[2127]tweak, [2128]hack), though none of these exactly capture sense
2. All these uses are rare in Commonwealth hackish, because in the
parent dialects of English the noun `bum' is a rude synonym for
`buttocks' and the verb `bum' for buggery.

Node:bump, Next:[2129]burble, Previous:[2130]bum, Up:[2131]= B =

bump vt.

Synonym for increment. Has the same meaning as C's ++ operator. Used
esp. of counter variables, pointers, and index dummies in for, while,
and do-while loops.

Node:burble, Next:[2132]buried treasure, Previous:[2133]bump,
Up:[2134]= B =

burble v.

[from Lewis Carroll's "Jabberwocky"] Like [2135]flame, but connotes
that the source is truly clueless and ineffectual (mere flamers can be
competent). A term of deep contempt. "There's some guy on the phone
burbling about how he got a DISK FULL error and it's all our comm
software's fault." This is mainstream slang in some parts of England.

Node:buried treasure, Next:[2136]burn-in period,
Previous:[2137]burble, Up:[2138]= B =

buried treasure n.

A surprising piece of code found in some program. While usually not
wrong, it tends to vary from [2139]crufty to [2140]bletcherous, and
has lain undiscovered only because it was functionally correct,
however horrible it is. Used sarcastically, because what is found is
anything but treasure. Buried treasure almost always needs to be dug
up and removed. "I just found that the scheduler sorts its queue using
[2141]bubble sort! Buried treasure!"

Node:burn-in period, Next:[2142]burst page, Previous:[2143]buried
treasure, Up:[2144]= B =

burn-in period n.

1. A factory test designed to catch systems with [2145]marginal
components before they get out the door; the theory is that burn-in
will protect customers by outwaiting the steepest part of the
[2146]bathtub curve (see [2147]infant mortality). 2. A period of
indeterminate length in which a person using a computer is so
intensely involved in his project that he forgets basic needs such as
food, drink, sleep, etc. Warning: Excessive burn-in can lead to
burn-out. See [2148]hack mode, [2149]larval stage.

Historical note: the origin of "burn-in" (sense 1) is apparently the
practice of setting a new-model airplane's brakes on fire, then
extinguishing the fire, in order to make them hold better. This was
done on the first version of the U.S. spy-plane, the U-2.

Node:burst page, Next:[2150]busy-wait, Previous:[2151]burn-in period,
Up:[2152]= B =

burst page n.

Syn. [2153]banner, sense 1.

Node:busy-wait, Next:[2154]buzz, Previous:[2155]burst page, Up:[2156]=
B =

busy-wait vi.

Used of human behavior, conveys that the subject is busy waiting for
someone or something, intends to move instantly as soon as it shows
up, and thus cannot do anything else at the moment. "Can't talk now,
I'm busy-waiting till Bill gets off the phone."

Technically, `busy-wait' means to wait on an event by [2157]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. In applications this is a
wasteful technique, and best avoided on time-sharing systems where a
busy-waiting program may [2158]hog the processor. However, it is often
unavoidable in kernel programming. In the Linux world, kernel
busy-waits are usually referred to as `spinlocks'.

Node:buzz, Next:[2159]BWQ, Previous:[2160]busy-wait, Up:[2161]= B =

buzz vi.

1. Of a program, to run with no indication of progress and perhaps
without guarantee of ever finishing; esp. said of programs thought to
be executing tight loops of code. A program that is buzzing appears to
be [2162]catatonic, but never gets out of catatonia, while a buzzing
loop may eventually end of its own accord. "The program buzzes for
about 10 seconds trying to sort all the names into order." See
[2163]spin; see also [2164]grovel. 2. [ETA Systems] To test a wire or
printed circuit trace for continuity, esp. by applying an AC rather
than DC signal. Some wire faults will pass DC tests but fail an AC
buzz test. 3. To process an array or list in sequence, doing the same
thing to each element. "This loop buzzes through the tz array looking
for a terminator type."

Node:BWQ, Next:[2165]by hand, Previous:[2166]buzz, Up:[2167]= B =

BWQ /B-W-Q/ n.

[IBM: abbreviation, `Buzz Word Quotient'] The percentage of buzzwords
in a speech or documents. Usually roughly proportional to
[2168]bogosity. See [2169]TLA.

Node:by hand, Next:[2170]byte, Previous:[2171]BWQ, Up:[2172]= B =

by hand adv.

[common] 1. Said of an operation (especially a repetitive, trivial,
and/or tedious one) that ought to be performed automatically by the
computer, but which a hacker instead has to step tediously through.
"My mailer doesn't have a command to include the text of the message
I'm replying to, so I have to do it by hand." This does not
necessarily mean the speaker has to retype a copy of the message; it
might refer to, say, dropping into a subshell from the mailer, making
a copy of one's mailbox file, reading that into an editor, locating
the top and bottom of the message in question, deleting the rest of
the file, inserting `>' characters on each line, writing the file,
leaving the editor, returning to the mailer, reading the file in, and
later remembering to delete the file. Compare [2173]eyeball search. 2.
By extension, writing code which does something in an explicit or
low-level way for which a presupplied library routine ought to have
been available. "This cretinous B-tree library doesn't supply a decent
iterator, so I'm having to walk the trees by hand."

Node:byte, Next:[2174]byte sex, Previous:[2175]by hand, Up:[2176]= B =

byte /bi:t/ n.

[techspeak] A unit of memory or data equal to the amount used to
represent one character; on modern architectures this is usually 8
bits, but may be 9 on 36-bit machines. Some older architectures used
`byte' for quantities of 6 or 7 bits, and the PDP-10 supported `bytes'
that were actually bitfields of 1 to 36 bits! These usages are now
obsolete, and even 9-bit bytes have become rare in the general trend
toward power-of-2 word sizes.

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 [2177]bit. See
also [2178]nybble.

Node:byte sex, Next:[2179]bytesexual, Previous:[2180]byte, Up:[2181]=
B =

byte sex n.

[common] The byte sex of hardware is [2182]big-endian or
[2183]little-endian; see those entries.

Node:bytesexual, Next:[2184]Bzzzt! Wrong., Previous:[2185]byte sex,
Up:[2186]= B =

bytesexual /bi:t`sek'shu-*l/ adj.

[rare] Said of hardware, denotes willingness to compute or pass data
in either [2187]big-endian or [2188]little-endian format (depending,
presumably, on a [2189]mode bit somewhere). See also [2190]NUXI

Node:Bzzzt! Wrong., Next:[2191]C, Previous:[2192]bytesexual,
Up:[2193]= B =

Bzzzt! Wrong. /bzt rong/ excl.

[common; Usenet/Internet; punctuation varies] From a Robin Williams
routine in the movie "Dead Poets Society" spoofing radio or TV quiz
programs, such as Truth or Consequences, where an incorrect answer
earns one a blast from the buzzer and condolences from the
interlocutor. A way of expressing mock-rude disagreement, usually
immediately following an included quote from another poster. The less
abbreviated "*Bzzzzt*, wrong, but thank you for playing" is also
common; capitalization and emphasis of the buzzer sound varies.

Node:= C =, Next:[2194]= D =, Previous:[2195]= B =, Up:[2196]The
Jargon Lexicon

= C =

* [2197]C:
* [2198]C Programmer's Disease:
* [2199]C&C:
* [2200]C++:
* [2201]calculator:
* [2202]Camel Book:
* [2203]can:
* [2204]can't happen:
* [2205]cancelbot:
* [2206]Cancelmoose[tm]:
* [2207]candygrammar:
* [2208]canonical:
* [2209]card walloper:
* [2210]careware:
* [2211]cargo cult programming:
* [2212]cascade:
* [2213]case and paste:
* [2214]casters-up mode:
* [2215]casting the runes:
* [2216]cat:
* [2217]catatonic:
* [2218]cathedral:
* [2219]cd tilde:
* [2220]CDA:
* [2221]cdr:
* [2222]chad:
* [2223]chad box:
* [2224]chain:
* [2225]channel:
* [2226]channel hopping:
* [2227]channel op:
* [2228]chanop:
* [2229]char:
* [2230]charityware:
* [2231]chase pointers:
* [2232]chawmp:
* [2233]check:
* [2234]cheerfully:
* [2235]chemist:
* [2236]Chernobyl chicken:
* [2237]Chernobyl packet:
* [2238]chicken head:
* [2239]chiclet keyboard:
* [2240]Chinese Army technique:
* [2241]choad:
* [2242]choke:
* [2243]chomp:
* [2244]chomper:
* [2245]CHOP:
* [2246]Christmas tree:
* [2247]Christmas tree packet:
* [2248]chrome:
* [2249]chug:
* [2250]Church of the SubGenius:
* [2251]Cinderella Book:
* [2252]CI$:
* [2253]Classic C:
* [2254]clean:
* [2255]CLM:
* [2256]clobber:
* [2257]clock:
* [2258]clocks:
* [2259]clone:
* [2260]clone-and-hack coding:
* [2261]clover key:
* [2262]clue-by-four:
* [2263]clustergeeking:
* [2264]co-lo:
* [2265]code:
* [2266]coaster:
* [2267]COBOL:
* [2268]COBOL fingers:
* [2269]cobweb site:
* [2270]code grinder:
* [2271]code monkey:
* [2272]Code of the Geeks:
* [2273]code police:
* [2274]codes:
* [2275]codewalker:
* [2276]coefficient of X:
* [2277]cokebottle:
* [2278]cold boot:
* [2279]COME FROM:
* [2280]comm mode:
* [2281]command key:
* [2282]comment out:
* [2283]Commonwealth Hackish:
* [2284]compact:
* [2285]compiler jock:
* [2286]compo:
* [2287]compress:
* [2288]Compu$erve:
* [2289]computer confetti:
* [2290]computer geek:
* [2291]computron:
* [2292]con:
* [2293]condition out:
* [2294]condom:
* [2295]confuser:
* [2296]connector conspiracy:
* [2297]cons:
* [2298]considered harmful:
* [2299]console:
* [2300]console jockey:
* [2301]content-free:
* [2302]control-C:
* [2303]control-O:
* [2304]control-Q:
* [2305]control-S:
* [2306]Conway's Law:
* [2307]cookbook:
* [2308]cooked mode:
* [2309]cookie:
* [2310]cookie bear:
* [2311]cookie file:
* [2312]cookie jar:
* [2313]cookie monster:
* [2314]copious free time:
* [2315]copper:
* [2316]copy protection:
* [2317]copybroke:
* [2318]copycenter:
* [2319]copyleft:
* [2320]copyparty:
* [2321]copywronged:
* [2322]core:
* [2323]core cancer:
* [2324]core dump:
* [2325]core leak:
* [2326]Core Wars:
* [2327]corge:
* [2328]cosmic rays:
* [2329]cough and die:
* [2330]courier:
* [2331]cow orker:
* [2332]cowboy:
* [2333]CP/M:
* [2334]CPU Wars:
* [2335]crack:
* [2336]crack root:
* [2337]cracker:
* [2338]cracking:
* [2339]crank:
* [2340]crapplet:
* [2341]CrApTeX:
* [2342]crash:
* [2343]crash and burn:
* [2344]crawling horror:
* [2345]cray:
* [2346]cray instability:
* [2347]crayola:
* [2348]crayola books:
* [2349]crayon:
* [2350]creationism:
* [2351]creep:
* [2352]creeping elegance:
* [2353]creeping featurism:
* [2354]creeping featuritis:
* [2355]cretin:
* [2356]cretinous:
* [2357]crippleware:
* [2358]critical mass:
* [2359]crlf:
* [2360]crock:
* [2361]cross-post:
* [2362]crossload:
* [2363]crudware:
* [2364]cruft:
* [2365]cruft together:
* [2366]cruftsmanship:
* [2367]crufty:
* [2368]crumb:
* [2369]crunch:
* [2370]cryppie:
* [2371]CTSS:
* [2372]cube:
* [2373]cubing:
* [2374]cup holder:
* [2375]cursor dipped in X:
* [2376]cuspy:
* [2377]cut a tape:
* [2378]cybercrud:
* [2379]cyberpunk:
* [2380]cyberspace:
* [2381]cycle:
* [2382]cycle crunch:
* [2383]cycle drought:
* [2384]cycle of reincarnation:
* [2385]cycle server:
* [2386]cypherpunk:
* [2387]C|N>K:

Node:C, Next:[2388]C Programmer's Disease, Previous:[2389]Bzzzt!
Wrong., Up:[2390]= C =

C n.

1. The third letter of the English alphabet. 2. ASCII 1000011. 3. The
name of a programming language designed by Dennis Ritchie during the
early 1970s and immediately used to reimplement [2391]Unix; so called
because many features derived from an earlier compiler named `B' in
commemoration of its parent, BCPL. (BCPL was in turn descended from an
earlier Algol-derived language, CPL.) Before Bjarne Stroustrup settled
the question by designing [2392]C++, there was a humorous debate over
whether C's successor should be named `D' or `P'. C became immensely
popular outside Bell Labs after about 1980 and is now the dominant
language in systems and microcomputer applications programming. See
also [2393]languages of choice, [2394]indent style.

C is often described, with a mixture of fondness and disdain varying
according to the speaker, as "a language that combines all the
elegance and power of assembly language with all the readability and
maintainability of assembly language".

Node:C Programmer's Disease, Next:[2395]C&C, Previous:[2396]C,
Up:[2397]= C =

C Programmer's Disease n.

The tendency of the undisciplined C programmer to set arbitrary but
supposedly generous static limits on table sizes (defined, if you're
lucky, by constants in header files) rather than taking the trouble to
do proper dynamic storage allocation. If an application user later
needs to put 68 elements into a table of size 50, the afflicted
programmer reasons that he or she can easily reset the table size to
68 (or even as much as 70, to allow for future expansion) and
recompile. This gives the programmer the comfortable feeling of having
made the effort to satisfy the user's (unreasonable) demands, and
often affords the user multiple opportunities to explore the marvelous
consequences of [2398]fandango on core. In severe cases of the
disease, the programmer cannot comprehend why each fix of this kind
seems only to further disgruntle the user.

Node:C&C, Next:[2399]C++, Previous:[2400]C Programmer's Disease,
Up:[2401]= C =

C&C //

[common, esp. on news.admin.net-abuse.email] Contraction of "Coffee &
Cats". This frequently occurs as a warning label on USENET posts that
are likely to cause you to [2402]snarf coffee onto your keyboard and
startle the cat off your lap.

Node:C++, Next:[2403]calculator, Previous:[2404]C&C, Up:[2405]= C =

C++ /C'-pluhs-pluhs/ n.

Designed by Bjarne Stroustrup of AT&T Bell Labs as a successor to
[2406]C. Now one of the [2407]languages of choice, although many
hackers still grumble that it is the successor to either Algol 68 or
[2408]Ada (depending on generation), and a prime example of
[2409]second-system effect. Almost anything that can be done in any
language can be done in C++, but it requires a [2410]language lawyer
to know what is and what is not legal-- the design is almost too large
to hold in even hackers' heads. Much of the [2411]cruft results from
C++'s attempt to be backward compatible with C. Stroustrup himself has
said in his retrospective book "The Design and Evolution of C++" (p.
207), "Within C++, there is a much smaller and cleaner language
struggling to get out." [Many hackers would now add "Yes, and it's
called [2412]Java" --ESR]

Node:calculator, Next:[2413]Camel Book, Previous:[2414]C++, Up:[2415]=
C =

calculator [Cambridge] n.

Syn. for [2416]bitty box.

Node:Camel Book, Next:[2417]can, Previous:[2418]calculator, Up:[2419]=
C =

Camel Book n.

Universally recognized nickname for the book "Programming Perl", by
Larry Wall and Randal L. Schwartz, O'Reilly and Associates 1991, ISBN
0-937175-64-1 (second edition 1996, ISBN 1-56592-149-6). The
definitive reference on [2420]Perl.

Node:can, Next:[2421]can't happen, Previous:[2422]Camel Book,
Up:[2423]= C =

can vt.

To abort a job on a time-sharing system. Used esp. when the person
doing the deed is an operator, as in "canned from the [2424]console".
Frequently used in an imperative sense, as in "Can that print job, the
LPT just popped a sprocket!" Synonymous with [2425]gun. It is said
that the ASCII character with mnemonic CAN (0011000) was used as a
kill-job character on some early OSes. Alternatively, this term may
derive from mainstream slang `canned' for being laid off or fired.

Node:can't happen, Next:[2426]cancelbot, Previous:[2427]can,
Up:[2428]= C =

can't happen

The traditional program comment for code executed under a condition
that should never be true, for example a file size computed as
negative. Often, such a condition being true indicates data corruption
or a faulty algorithm; it is almost always handled by emitting a fatal
error message and terminating or crashing, since there is little else
that can be done. Some case variant of "can't happen" is also often
the text emitted if the `impossible' error actually happens! Although
"can't happen" events are genuinely infrequent in production code,
programmers wise enough to check for them habitually are often
surprised at how frequently they are triggered during development and
how many headaches checking for them turns out to head off. See also
[2429]firewall code (sense 2).

Node:cancelbot, Next:[2430]Cancelmoose[tm], Previous:[2431]can't
happen, Up:[2432]= C =

cancelbot /kan'sel-bot/

[Usenet: compound, cancel + robot] 1. Mythically, a
[2433]robocanceller 2. In reality, most cancelbots are manually
operated by being fed lists of spam message IDs.

Node:Cancelmoose[tm], Next:[2434]candygrammar,
Previous:[2435]cancelbot, Up:[2436]= C =

Cancelmoose[tm] /kan'sel-moos/

[Usenet] The archetype and model of all good [2437]spam-fighters. Once
upon a time, the 'Moose would send out spam-cancels and then post
notice anonymously to news.admin.policy, news.admin.misc, and
alt.current-events.net-abuse. The 'Moose stepped to the fore on its
own initiative, at a time (mid-1994) when spam-cancels were irregular
and disorganized, and behaved altogether admirably - fair,
even-handed, and quick to respond to comments and criticism, all
without self-aggrandizement or martyrdom. Cancelmoose[tm] quickly
gained near-unanimous support from the readership of all three
above-mentioned groups.

Nobody knows who Cancelmoose[tm] really is, and there aren't even any
good rumors. However, the 'Moose now has an e-mail address
([2438]moose@cm.org) and a web site ([2439]http://www.cm.org.)

By early 1995, others had stepped into the spam-cancel business, and
appeared to be comporting themselves well, after the 'Moose's manner.
The 'Moose has now gotten out of the business, and is more interested
in ending spam (and cancels) entirely.

Node:candygrammar, Next:[2440]canonical,
Previous:[2441]Cancelmoose[tm], Up:[2442]= C =

candygrammar n.

A programming-language grammar that is mostly [2443]syntactic sugar;
the term is also a play on `candygram'. [2444]COBOL, Apple's Hypertalk
language, and a lot of the so-called `4GL' database languages share
this property. The usual intent of such designs is that they be as
English-like as possible, on the theory that they will then be easier
for unskilled people to program. This intention comes to grief on the
reality that syntax isn't what makes programming hard; it's the mental
effort and organization required to specify an algorithm precisely
that costs. Thus the invariable result is that `candygrammar'
languages are just as difficult to program in as terser ones, and far
more painful for the experienced hacker.

[The overtones from the old Chevy Chase skit on Saturday Night Live
should not be overlooked. This was a "Jaws" parody. Someone lurking
outside an apartment door tries all kinds of bogus ways to get the
occupant to open up, while ominous music plays in the background. The
last attempt is a half-hearted "Candygram!" When the door is opened, a
shark bursts in and chomps the poor occupant. [There is a similar gag
in "Blazing Saddles" --ESR] There is a moral here for those attracted
to candygrammars. Note that, in many circles, pretty much the same
ones who remember Monty Python sketches, all it takes is the word
"Candygram!", suitably timed, to get people rolling on the floor. --

Node:canonical, Next:[2445]card walloper, Previous:[2446]candygrammar,
Up:[2447]= C =

canonical adj.

[very common; historically, `according to religious law'] The usual or
standard state or manner of something. This word has a somewhat more
technical meaning in mathematics. Two formulas such as 9 + x and x + 9
are said to be equivalent because they mean the same thing, but the
second one is in `canonical form' because it is written in the usual
way, with the highest power of x first. Usually there are fixed rules
you can use to decide whether something is in canonical form. The
jargon meaning, a relaxation of the technical meaning, acquired its
present loading in computer-science culture largely through its
prominence in Alonzo Church's work in computation theory and
mathematical logic (see [2448]Knights of the Lambda Calculus). Compare

Non-technical academics do not use the adjective `canonical' in any of
the senses defined above with any regularity; they do however use the
nouns `canon' and `canonicity' (not **canonicalness or
**canonicality). The `canon' of a given author is the complete body of
authentic works by that author (this usage is familiar to Sherlock
Holmes fans as well as to literary scholars). `The canon' is the body
of works in a given field (e.g., works of literature, or of art, or of
music) deemed worthwhile for students to study and for scholars to

The word `canon' has an interesting history. It derives ultimately
from the Greek `kanon' (akin to the English `cane') referring to a
reed. Reeds were used for measurement, and in Latin and later Greek
the word `canon' meant a rule or a standard. The establishment of a
canon of scriptures within Christianity was meant to define a standard
or a rule for the religion. The above non-techspeak academic usages
stem from this instance of a defined and accepted body of work.
Alongside this usage was the promulgation of `canons' (`rules') for
the government of the Catholic Church. The techspeak usages
("according to religious law") derive from this use of the Latin

Hackers invest this term with a playfulness that makes an ironic
contrast with its historical meaning. A true story: One Bob Sjoberg,
new at the MIT AI Lab, expressed some annoyance at the incessant use
of jargon. Over his loud objections, GLS and RMS made a point of using
as much of it as possible in his presence, and eventually it began to
sink in. Finally, in one conversation, he used the word `canonical' in
jargon-like fashion without thinking. Steele: "Aha! We've finally got
you talking jargon too!" Stallman: "What did he say?" Steele: "Bob
just used `canonical' in the canonical way."

Of course, canonicality depends on context, but it is implicitly
defined as the way hackers normally expect things to be. Thus, a
hacker may claim with a straight face that `according to religious
law' is not the canonical meaning of `canonical'.

Node:card walloper, Next:[2450]careware, Previous:[2451]canonical,
Up:[2452]= C =

card walloper n.

An EDP programmer who grinds out batch programs that do stupid things
like print people's paychecks. Compare [2453]code grinder. See also
[2454]punched card, [2455]eighty-column mind.

Node:careware, Next:[2456]cargo cult programming, Previous:[2457]card
walloper, Up:[2458]= C =

careware /keir'weir/ n.

A variety of [2459]shareware for which either the author suggests that
some payment be made to a nominated charity or a levy directed to
charity is included on top of the distribution charge. Syn.
[2460]charityware; compare [2461]crippleware, sense 2.

Node:cargo cult programming, Next:[2462]cascade,
Previous:[2463]careware, Up:[2464]= C =

cargo cult programming n.

A style of (incompetent) programming dominated by ritual inclusion of
code or program structures that serve no real purpose. A cargo cult
programmer will usually explain the extra code as a way of working
around some bug encountered in the past, but usually neither the bug
nor the reason the code apparently avoided the bug was ever fully
understood (compare [2465]shotgun debugging, [2466]voodoo

The term `cargo cult' is a reference to aboriginal religions that grew
up in the South Pacific after World War II. The practices of these
cults center on building elaborate mockups of airplanes and military
style landing strips in the hope of bringing the return of the
god-like airplanes that brought such marvelous cargo during the war.
Hackish usage probably derives from Richard Feynman's characterization
of certain practices as "cargo cult science" in his book "Surely
You're Joking, Mr. Feynman!" (W. W. Norton & Co, New York 1985, ISBN

Node:cascade, Next:[2467]case and paste, Previous:[2468]cargo cult
programming, Up:[2469]= C =

cascade n.

1. A huge volume of spurious error-message output produced by a
compiler with poor error recovery. Too frequently, one trivial syntax
error (such as a missing `)' or `}') throws the parser out of synch so
that much of the remaining program text is interpreted as garbaged or
ill-formed. 2. A chain of Usenet followups, each adding some trivial
variation or riposte to the text of the previous one, all of which is
reproduced in the new message; an [2470]include war in which the
object is to create a sort of communal graffito.

Node:case and paste, Next:[2471]casters-up mode,
Previous:[2472]cascade, Up:[2473]= C =

case and paste n.

[from `cut and paste'] 1. The addition of a new [2474]feature to an
existing system by selecting the code from an existing feature and
pasting it in with minor changes. Common in telephony circles because
most operations in a telephone switch are selected using case
statements. Leads to [2475]software bloat.

In some circles of EMACS users this is called `programming by Meta-W',
because Meta-W is the EMACS command for copying a block of text to a
kill buffer in preparation to pasting it in elsewhere. The term is
condescending, implying that the programmer is acting mindlessly
rather than thinking carefully about what is required to integrate the
code for two similar cases.

At [2476]DEC (now Compaq), this is sometimes called `clone-and-hack'

Node:casters-up mode, Next:[2477]casting the runes,
Previous:[2478]case and paste, Up:[2479]= C =

casters-up mode n.

[IBM, prob. fr. slang belly up] Yet another synonym for `broken' or
`down'. Usually connotes a major failure. A system (hardware or
software) which is `down' may be already being restarted before the
failure is noticed, whereas one which is `casters up' is usually a
good excuse to take the rest of the day off (as long as you're not
responsible for fixing it).

Node:casting the runes, Next:[2480]cat, Previous:[2481]casters-up
mode, Up:[2482]= C =

casting the runes n.

What a [2483]guru does when you ask him or her to run a particular
program and type at it because it never works for anyone else; esp.
used when nobody can ever see what the guru is doing different from
what J. Random Luser does. Compare [2484]incantation, [2485]runes,
[2486]examining the entrails; also see the AI koan about Tom Knight in
"[2487]Some AI Koans" (Appendix A).

A correspondent from England tells us that one of ICL's most talented
systems designers used to be called out occasionally to service
machines which the [2488]field circus had given up on. Since he knew
the design inside out, he could often find faults simply by listening
to a quick outline of the symptoms. He used to play on this by going
to some site where the field circus had just spent the last two weeks
solid trying to find a fault, and spreading a diagram of the system
out on a table top. He'd then shake some chicken bones and cast them
over the diagram, peer at the bones intently for a minute, and then
tell them that a certain module needed replacing. The system would
start working again immediately upon the replacement.

Node:cat, Next:[2489]catatonic, Previous:[2490]casting the runes,
Up:[2491]= C =

cat [from `catenate' via [2492]Unix cat(1)] vt.

1. [techspeak] To spew an entire file to the screen or some other
output sink without pause (syn. [2493]blast). 2. By extension, to dump
large amounts of data at an unprepared target or with no intention of
browsing it carefully. Usage: considered silly. Rare outside Unix
sites. See also [2494]dd, [2495]BLT.

Among Unix fans, cat(1) is considered an excellent example of
user-interface design, because it delivers the file contents without
such verbosity as spacing or headers between the files, and because it
does not require the files to consist of lines of text, but works with
any sort of data.

Among Unix haters, cat(1) is considered the [2496]canonical example of
bad user-interface design, because of its woefully unobvious name. It
is far more often used to [2497]blast a file to standard output than
to concatenate two files. The name cat for the former operation is
just as unintuitive as, say, LISP's [2498]cdr.

Of such oppositions are [2499]holy wars made....

Node:catatonic, Next:[2500]cathedral, Previous:[2501]cat, Up:[2502]= C

catatonic adj.

Describes a condition of suspended animation in which something is so
[2503]wedged or [2504]hung that it makes no response. If you are
typing on a terminal and suddenly the computer doesn't even echo the
letters back to the screen as you type, let alone do what you're
asking it to do, then the computer is suffering from catatonia
(possibly because it has crashed). "There I was in the middle of a
winning game of [2505]nethack and it went catatonic on me! Aaargh!"
Compare [2506]buzz.

Node:cathedral, Next:[2507]cd tilde, Previous:[2508]catatonic,
Up:[2509]= C =

cathedral n.,adj.

[see [2510]bazaar for derivation] The `classical' mode of software
engineering long thought to be necessarily implied by [2511]Brooks's
Law. Features small teams, tight project control, and long release
intervals. This term came into use after analysis of the Linux
experience suggested there might be something wrong (or at least
incomplete) in the classical assumptions.

Node:cd tilde, Next:[2512]CDA, Previous:[2513]cathedral, Up:[2514]= C

Book of the day:
Facebook Google Reddit StumbleUpon Twitter Pinterest