Chapter V: Rare: book (3)

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."

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 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]

:bug-compatible: /adj./ Said of a design or revision that has
been badly compromised by a requirement to be compatible with
{fossil}s or {misfeature}s 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."

:bug-for-bug compatible: /n./ Same as {bug-compatible}, with
the additional implication that much tedious effort went into
ensuring that each (known) bug was replicated.

: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(1)' (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 {cracker}s 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'.

:buglix: /buhg'liks/ /n./ Pejorative term referring to
{DEC}'s ULTRIX operating system in its earlier *severely*
buggy versions. Still used to describe ULTRIX, but without nearly
so much venom. Compare {AIDX}, {HP-SUX}, {Nominal
Semidestructor}, {Telerat}, {sun-stools}.

:bulletproof: /adj./ Used of an algorithm or implementation
considered extremely {robust}; lossage-resistant; capable of
correctly recovering from any imaginable exception condition -- a
rare and valued quality. Syn. {armor-plated}.

:bum: 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 {elder days}, John McCarthy
(inventor of {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 {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./ {tune}
(and /n./ {tweak}, {hack}), though none of these exactly
capture sense 2. All these uses are rare in Commonwealth hackish,
because in the parent dialects of English `bum' is a rude synonym
for `buttocks'.

: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.

:burble: /v./ [from Lewis Carroll's "Jabberwocky"] Like
{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.

:buried treasure: /n./ A surprising piece of code found in some
program. While usually not wrong, it tends to vary from
{crufty} to {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
{bubble sort}! Buried treasure!"

:burn-in period: /n./ 1. A factory test designed to catch
systems with {marginal} components before they get out the door;
the theory is that burn-in will protect customers by outwaiting the
steepest part of the {bathtub curve} (see {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 {hack mode},
{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.

:burst page: /n./ Syn. {banner}, sense 1.

: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
{spin}ning 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.

: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 {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 {spin}; see also
{grovel}. 2. [ETA Systems] To test a wire or printed circuit
trace for continuity by applying an AC rather than DC signal. Some
wire faults will pass DC tests but fail a 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."

:BWQ: /B-W-Q/ /n./ [IBM: abbreviation, `Buzz Word Quotient']
The percentage of buzzwords in a speech or documents. Usually
roughly proportional to {bogosity}. See {TLA}.

:by hand: /adv./ 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 {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."

: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 {bit}. See also {nybble}.

:bytesexual: /bi:t`sek'shu-*l/ /adj./ Said of hardware,
denotes willingness to compute or pass data in either
{big-endian} or {little-endian} format (depending,
presumably, on a {mode bit} somewhere). See also {NUXI
problem}.

:bzzzt, wrong: /bzt rong/ /excl./ [Usenet/Internet] 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.

= 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
{{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
{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 {languages of
choice}, {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".

: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 {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.

:C++: /C'-pluhs-pluhs/ /n./ Designed by Bjarne Stroustrup
of AT&T Bell Labs as a successor to {C}. Now one of the
{languages of choice}, although many hackers still grumble that
it is the successor to either Algol 68 or {Ada} (depending on
generation), and a prime example of {second-system effect}.
Almost anything that can be done in any language can be done in
C++, but it requires a {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 {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 Java" --ESR]

:calculator: [Cambridge] /n./ Syn. for {bitty box}.

:Camel Book: /n./ Universally recognized nickname for the book
"Programming Perl", by Larry Wall and Randal L. Schwartz,
O'Reilly Associates 1991, ISBN 0-937175-64-1. The definitive
reference on {Perl}.

: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 {{console}}". Frequently used in an imperative
sense, as in "Can that print job, the LPT just popped a
sprocket!" Synonymous with {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.

: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
{firewall code} (sense 2).

:candygrammar: /n./ A programming-language grammar that is
mostly {syntactic sugar}; the term is also a play on
`candygram'. {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 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. -- GLS]

:canonical: /adj./ [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 {Knights of the Lambda Calculus}).
Compare {vanilla}.

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 investigate.

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
`canon'.

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'.

:card walloper: /n./ An EDP programmer who grinds out batch
programs that do stupid things like print people's paychecks.
Compare {code grinder}. See also {{punched card}},
{eighty-column mind}.

:careware: /keir'weir/ /n./ A variety of {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. {charityware}; compare
{crippleware}, sense 2.

: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 {shotgun debugging}, {voodoo
programming}).

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 0-393-01921-7).

: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 {include war} in which the object is to create a
sort of communal graffito.

:case and paste: /n./ [from `cut and paste'] 1. The addition of a new
{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 {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 DEC, this is sometimes called `clone-and-hack' coding.

: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).

:casting the runes: /n./ What a {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 {incantation}, {runes}, {examining the entrails};
also see the AI koan about Tom Knight in "{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 {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.

:cat: [from `catenate' via {{Unix}} `cat(1)'] /vt./
1. [techspeak] To spew an entire file to the screen or some other
output sink without pause. 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 {dd}, {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 {canonical}
example of *bad* user-interface design, because of its
woefully unobvious name. It is far more often used to {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 {cdr}.

Of such oppositions are {holy wars} made....

:catatonic: /adj./ Describes a condition of suspended animation
in which something is so {wedged} or {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 {nethack} and
it went catatonic on me! Aaargh!" Compare {buzz}.

:cd tilde: /C-D til-d*/ /vi./ To go home. From the Unix
C-shell and Korn-shell command `cd ~', which takes one to
one's `$HOME' (`cd' with no arguments happens to do the
same thing). By extension, may be used with other arguments; thus,
over an electronic chat link, `cd ~coffee' would mean "I'm
going to the coffee machine."

:CDA: /C-D-A/ The "Communications Decency Act" of 1996,
passed on {Black Thursday} as section 502 of a major
telecommunications reform bill. The CDA made it a federal crime in
the USA to send a communication which is "obscene,
lewd, lascivious, filthy, or indecent, with intent to annoy, abuse,
threaten, or harass another person." It also threatens with
imprisonment anyone who "knowingly" makes accessible to minors
any message that "describes, in terms patently offensive as
measured by contemporary community standards, sexual or excretory
activities or organs".

While the CDA was sold as a measure to protect minors from the
putative evils of pornography, the repressive political aims of the
bill were laid bare by the Hyde amendment, which intended to
outlaw discussion of abortion on the Internet.

To say that this direct attack on First Amendment free-speech
rights was not well received on the Internet would be putting it
mildly. A firestorm of protest followed, including a February 29th
mass demonstration by thousands of netters who turned their
{home page}s black for 48 hours. Several civil-rights groups
and computing/telecommunications companies sought an immediate
injunction to block enforcement of the CDA pending a constitutional
challenge. This injunction was granted on the likelihood that
plaintiffs would prevail on the merits of the case. At time of
writing (Spring 1996), the fate of the CDA, and its effect on the
Internet, is still unknown. See also {Exon}.

To join the fight against the CDA (if it's still law) and other
forms of Internet censorship, visit the Center for Democracy and
Technology Home Page at http://www.cdt.org.

:cdr: /ku'dr/ or /kuh'dr/ /vt./ [from LISP] To skip past
the first item from a list of things (generalized from the LISP
operation on binary tree structures, which returns a list
consisting of all but the first element of its argument). In the
form `cdr down', to trace down a list of elements: "Shall we cdr
down the agenda?" Usage: silly. See also {loop through}.

Historical note: The instruction format of the IBM 704 that hosted
the original LISP implementation featured two 15-bit fields called
the `address' and `decrement' parts. The term `cdr' was originally
`Contents of Decrement part of Register'. Similarly, `car' stood
for `Contents of Address part of Register'.

The cdr and car operations have since become bases for
formation of compound metaphors in non-LISP contexts. GLS recalls,
for example, a programming project in which strings were
represented as linked lists; the get-character and skip-character
operations were of course called CHAR and CHDR.

:chad: /chad/ /n./ 1. The perforated edge strips on printer
paper, after they have been separated from the printed portion.
Also called {selvage} and {perf}. 2. obs. The confetti-like
paper bits punched out of cards or paper tape; this has also been
called `chaff', `computer confetti', and `keypunch
droppings'. This use may now be mainstream; it has been reported
seen (1993) in directions for a card-based voting machine in
California.

Historical note: One correspondent believes `chad' (sense 2)
derives from the Chadless keypunch (named for its inventor), which
cut little u-shaped tabs in the card to make a hole when the tab
folded back, rather than punching out a circle/rectangle; it was
clear that if the Chadless keypunch didn't make them, then the
stuff that other keypunches made had to be `chad'. There is a
legend that the word was originally acronymic, standing for
"Card Hole Aggregate Debris", but this has all the earmarks of
a bogus folk etymology.

:chad box: /n./ A metal box about the size of a lunchbox (or in
some models a large wastebasket), for collecting the {chad}
(sense 2) that accumulated in {Iron Age} card punches. You had
to open the covers of the card punch periodically and empty the
chad box. The {bit bucket} was notionally the equivalent device
in the CPU enclosure, which was typically across the room in
another great gray-and-blue box.

:chain: 1. /vi./ [orig. from BASIC's `CHAIN' statement]
To hand off execution to a child or successor without going
through the {OS} command interpreter that invoked it. The state
of the parent program is lost and there is no returning to it.
Though this facility used to be common on memory-limited micros and
is still widely supported for backward compatibility, the jargon
usage is semi-obsolescent; in particular, most Unix programmers
will think of this as an {exec}. Oppose the more modern
`subshell'. 2. /n./ A series of linked data areas within an
operating system or application. `Chain rattling' is the process
of repeatedly running through the linked data areas searching for
one which is of interest to the executing program. The implication
is that there is a very large number of links on the chain.

:channel: /n./ [IRC] The basic unit of discussion on {IRC}.
Once one joins a channel, everything one types is read by others on
that channel. Channels are named with strings that begin with a
`#' sign and can have topic descriptions (which are generally
irrelevant to the actual subject of discussion). Some notable
channels are `#initgame', `#hottub', and `#report'.
At times of international crisis, `#report' has hundreds of
members, some of whom take turns listening to various news services
and typing in summaries of the news, or in some cases, giving
first-hand accounts of the action (e.g., Scud missile attacks in
Tel Aviv during the Gulf War in 1991).

:channel hopping: /n./ [IRC, GEnie] To rapidly switch channels
on {IRC}, or a GEnie chat board, just as a social butterfly
might hop from one group to another at a party. This term may
derive from the TV watcher's idiom, `channel surfing'.

:channel op: /chan'l op/ /n./ [IRC] Someone who is endowed
with privileges on a particular {IRC} channel; commonly
abbreviated `chanop' or `CHOP'. These privileges include the
right to {kick} users, to change various status bits, and to
make others into CHOPs.

:chanop: /chan'-op/ /n./ [IRC] See {channel op}.

:char: /keir/ or /char/; rarely, /kar/ /n./ Shorthand for
`character'. Esp. used by C programmers, as `char' is C's
typename for character data.

:charityware: /cha'rit-ee-weir`/ /n./ Syn. {careware}.

:chase pointers: 1. /vi./ To go through multiple levels of
indirection, as in traversing a linked list or graph structure.
Used esp. by programmers in C, where explicit pointers are a very
common data type. This is techspeak, but it remains jargon when
used of human networks. "I'm chasing pointers. Bob said you
could tell me who to talk to about...." See {dangling
pointer} and {snap}. 2. [Cambridge] `pointer chase' or
`pointer hunt': The process of going through a {core dump}
(sense 1), interactively or on a large piece of paper printed with
hex {runes}, following dynamic data-structures. Used only in a
debugging context.

:chawmp: /n./ [University of Florida] 16 or 18 bits (half of a
machine word). This term was used by FORTH hackers during the late
1970s/early 1980s; it is said to have been archaic then, and may
now be obsolete. It was coined in revolt against the promiscuous
use of `word' for anything between 16 and 32 bits; `word' has
an additional special meaning for FORTH hacks that made the
overloading intolerable. For similar reasons, /gaw'bl/ (spelled
`gawble' or possibly `gawbul') was in use as a term for 32 or
48 bits (presumably a full machine word, but our sources are
unclear on this). These terms are more easily understood if one
thinks of them as faithful phonetic spellings of `chomp' and
`gobble' pronounced in a Florida or other Southern U.S. dialect.
For general discussion of similar terms, see {nybble}.

:check: /n./ A hardware-detected error condition, most commonly
used to refer to actual hardware failures rather than
software-induced traps. E.g., a `parity check' is the result of
a hardware-detected parity error. Recorded here because the word
often humorously extended to non-technical problems. For example,
the term `child check' has been used to refer to the problems
caused by a small child who is curious to know what happens when
s/he presses all the cute buttons on a computer's console (of
course, this particular problem could have been prevented with
{molly-guard}s).

:chemist: /n./ [Cambridge] Someone who wastes computer time
on {number-crunching} when you'd far rather the machine were
doing something more productive, such as working out anagrams of
your name or printing Snoopy calendars or running {life}
patterns. May or may not refer to someone who actually studies
chemistry.

:Chernobyl chicken: /n./ See {laser chicken}.

:Chernobyl packet: /cher-noh'b*l pak'*t/ /n./ A network
packet that induces a {broadcast storm} and/or {network
meltdown}, in memory of the April 1986 nuclear accident at
Chernobyl in Ukraine. The typical scenario involves an IP Ethernet
datagram that passes through a gateway with both source and
destination Ether and IP address set as the respective broadcast
addresses for the subnetworks being gated between. Compare
{Christmas tree packet}.

:chicken head: /n./ [Commodore] The Commodore Business
Machines logo, which strongly resembles a poultry part. Rendered
in ASCII as `C='. With the arguable exception of the Amiga (see
{amoeba}), Commodore's machines are notoriously crocky little
{bitty box}es (see also {PETSCII}). Thus, this usage may owe
something to Philip K. Dick's novel "Do Androids Dream of
Electric Sheep?" (the basis for the movie "Blade Runner"; the
novel is now sold under that title), in which a `chickenhead' is
a mutant with below-average intelligence.

:chiclet keyboard: /n./ A keyboard with a small, flat
rectangular or lozenge-shaped rubber or plastic keys that look like
pieces of chewing gum. (Chiclets is the brand name of a variety of
chewing gum that does in fact resemble the keys of chiclet
keyboards.) Used esp. to describe the original IBM PCjr
keyboard. Vendors unanimously liked these because they were cheap,
and a lot of early portable and laptop products got launched using
them. Customers rejected the idea with almost equal unanimity, and
chiclets are not often seen on anything larger than a digital watch
any more.

:chine nual: /sheen'yu-*l/ /n. obs./ [MIT] The LISP Machine
Manual, so called because the title was wrapped around the cover so
only those letters showed on the front.

:Chinese Army technique: /n./ Syn. {Mongolian Hordes
technique}.

:choad: /chohd/ /n./ Synonym for `penis' used in
alt.tasteless and popularized by the denizens thereof. They
say: "We think maybe it's from Middle English but we're all too
damned lazy to check the OED." [I'm not. It isn't. --ESR] This
term is alleged to have been inherited through 1960s underground
comics, and to have been recently sighted in the Beavis and
Butthead cartoons. Speakers of the Hindi, Bengali and Gujarati
languages have confirmed that `choad' is in fact an Indian
vernacular word equivalent to `fuck'; it is therefore likely to
have entered English slang via the British Raj.

:choke: /v./ 1. To reject input, often ungracefully. "NULs
make System V's `lpr(1)' choke." "I tried building an
{EMACS} binary to use {X}, but `cpp(1)' choked on all
those `#define's." See {barf}, {gag}, {vi}.
2. [MIT] More generally, to fail at any endeavor, but with some
flair or bravado; the popular definition is "to snatch defeat from
the jaws of victory."

:chomp: /vi./ To {lose}; specifically, to chew on something
of which more was bitten off than one can. Probably related to
gnashing of teeth. See {bagbiter}.

A hand gesture commonly accompanies this. To perform it, hold the
four fingers together and place the thumb against their tips. Now
open and close your hand rapidly to suggest a biting action (much
like what Pac-Man does in the classic video game, though this
pantomime seems to predate that). The gesture alone means `chomp
chomp' (see "{Verb Doubling}" in the "{Jargon
Construction}" section of the Prependices). The hand may be
pointed at the object of complaint, and for real emphasis you can
use both hands at once. Doing this to a person is equivalent to
saying "You chomper!" If you point the gesture at yourself, it
is a humble but humorous admission of some failure. You might do
this if someone told you that a program you had written had failed
in some surprising way and you felt dumb for not having anticipated
it.

:chomper: /n./ Someone or something that is chomping; a loser.
See {loser}, {bagbiter}, {chomp}.

:CHOP: /chop/ /n./ [IRC] See {channel op}.

:Christmas tree: /n./ A kind of RS-232 line tester or breakout
box featuring rows of blinking red and green LEDs suggestive of
Christmas lights.

:Christmas tree packet: /n./ A packet with every single option
set for whatever protocol is in use. See {kamikaze packet},
{Chernobyl packet}. (The term doubtless derives from a fanciful
image of each little option bit being represented by a
different-colored light bulb, all turned on.)

:chrome: /n./ [from automotive slang via wargaming] Showy features
added to attract users but contributing little or nothing to
the power of a system. "The 3D icons in Motif are just chrome,
but they certainly are *pretty* chrome!" Distinguished from
{bells and whistles} by the fact that the latter are usually
added to gratify developers' own desires for featurefulness.
Often used as a term of contempt.

:chug: /vi./ To run slowly; to {grind} or {grovel}.
"The disk is chugging like crazy."

:Church of the SubGenius: /n./ A mutant offshoot of
{Discordianism} launched in 1981 as a spoof of fundamentalist
Christianity by the `Reverend' Ivan Stang, a brilliant satirist
with a gift for promotion. Popular among hackers as a rich source
of bizarre imagery and references such as "Bob" the divine
drilling-equipment salesman, the Benevolent Space Xists, and the
Stark Fist of Removal. Much SubGenius theory is concerned with the
acquisition of the mystical substance or quality of {slack}.

:Cinderella Book: [CMU] /n./ "Introduction to Automata
Theory, Languages, and Computation", by John Hopcroft and Jeffrey
Ullman, (Addison-Wesley, 1979). So called because the cover
depicts a girl (putatively Cinderella) sitting in front of a Rube
Goldberg device and holding a rope coming out of it. On the back
cover, the device is in shambles after she has (inevitably) pulled
on the rope. See also {{book titles}}.

:CI$: // /n./ Hackerism for `CIS', CompuServe Information
Service. The dollar sign refers to CompuServe's rather steep line
charges. Often used in {sig block}s just before a CompuServe
address. Syn. {Compu$erve}.

:Classic C: /klas'ik C/ [a play on `Coke Classic'] /n./ The
C programming language as defined in the first edition of {K&R},
with some small additions. It is also known as `K&R C'. The name
came into use while C was being standardized by the ANSI X3J11
committee. Also `C Classic'.

An analogous construction is sometimes applied elsewhere: thus,
`X Classic', where X = Star Trek (referring to the original TV
series) or X = PC (referring to IBM's ISA-bus machines as opposed
to the PS/2 series). This construction is especially used of
product series in which the newer versions are considered serious
losers relative to the older ones.

:clean: 1. /adj./ Used of hardware or software designs, implies
`elegance in the small', that is, a design or implementation that
may not hold any surprises but does things in a way that is
reasonably intuitive and relatively easy to comprehend from the
outside. The antonym is `grungy' or {crufty}. 2. /v./ To
remove unneeded or undesired files in a effort to reduce clutter:
"I'm cleaning up my account." "I cleaned up the garbage and now
have 100 Meg free on that partition."

:CLM: /C-L-M/ [Sun: `Career Limiting Move'] 1. /n./ An action
endangering one's future prospects of getting plum projects and
raises, and possibly one's job: "His Halloween costume was a
parody of his manager. He won the prize for `best CLM'." 2. adj.
Denotes extreme severity of a bug, discovered by a customer and
obviously missed earlier because of poor testing: "That's a CLM
bug!"

:clobber: /vt./ To overwrite, usually unintentionally: "I
walked off the end of the array and clobbered the stack." Compare
{mung}, {scribble}, {trash}, and {smash the stack}.

:clocks: /n./ Processor logic cycles, so called because each
generally corresponds to one clock pulse in the processor's timing.
The relative execution times of instructions on a machine are
usually discussed in clocks rather than absolute fractions of a
second; one good reason for this is that clock speeds for various
models of the machine may increase as technology improves, and it
is usually the relative times one is interested in when discussing
the instruction set. Compare {cycle}.

:clone: /n./ 1. An exact duplicate: "Our product is a clone of
their product." Implies a legal reimplementation from
documentation or by reverse-engineering. Also connotes lower
price. 2. A shoddy, spurious copy: "Their product is a clone of
our product." 3. A blatant ripoff, most likely violating
copyright, patent, or trade secret protections: "Your product is a
clone of my product." This use implies legal action is pending.
4. `PC clone:' a PC-BUS/ISA or EISA-compatible 80x86-based
microcomputer (this use is sometimes spelled `klone' or
`PClone'). These invariably have much more bang for the buck
than the IBM archetypes they resemble. 5. In the construction
`Unix clone': An OS designed to deliver a Unix-lookalike
environment without Unix license fees, or with additional
`mission-critical' features such as support for real-time
programming. 6. /v./ To make an exact copy of something. "Let me
clone that" might mean "I want to borrow that paper so I can make
a photocopy" or "Let me get a copy of that file before you
{mung} it".

:clone-and-hack coding: /n./ [DEC] Syn. {case and paste}.

:clover key: /n./ [Mac users] See {feature key}.

:clustergeeking: /kluh'st*r-gee`king/ /n./ [CMU] Spending
more time at a computer cluster doing CS homework than most people
spend breathing.

:COBOL: /koh'bol/ /n./ [COmmon Business-Oriented Language]
(Synonymous with {evil}.) A weak, verbose, and flabby language
used by {card walloper}s to do boring mindless things on
{dinosaur} mainframes. Hackers believe that all COBOL
programmers are {suit}s or {code grinder}s, and no
self-respecting hacker will ever admit to having learned the
language. Its very name is seldom uttered without ritual
expressions of disgust or horror. One popular one is Edsger W.
Dijkstra's famous observation that "The use of COBOL cripples the
mind; its teaching should, therefore, be regarded as a criminal
offense." (from "Selected Writings on Computing: A Personal
Perspective") See also {fear and loathing}, {software
rot}.

:COBOL fingers: /koh'bol fing'grz/ /n./ Reported from Sweden,
a (hypothetical) disease one might get from coding in COBOL. The
language requires code verbose beyond all reason (see
{candygrammar}); thus it is alleged that programming too much in
COBOL causes one's fingers to wear down to stubs by the endless
typing. "I refuse to type in all that source code again; it would
give me COBOL fingers!"

:code grinder: /n./ 1. A {suit}-wearing minion of the sort
hired in legion strength by banks and insurance companies to
implement payroll packages in RPG and other such unspeakable
horrors. In its native habitat, the code grinder often removes the
suit jacket to reveal an underplumage consisting of button-down
shirt (starch optional) and a tie. In times of dire stress, the
sleeves (if long) may be rolled up and the tie loosened about half
an inch. It seldom helps. The {code grinder}'s milieu is about
as far from hackerdom as one can get and still touch a computer;
the term connotes pity. See {Real World}, {suit}. 2. Used
of or to a hacker, a really serious slur on the person's creative
ability; connotes a design style characterized by primitive
technique, rule-boundedness, {brute force}, and utter lack of
imagination. Compare {card walloper}; contrast {hacker},
{Real Programmer}.

:Code of the Geeks: /n./ see {geek code}.

:code police: /n./ [by analogy with George Orwell's `thought
police'] A mythical team of Gestapo-like storm troopers that might
burst into one's office and arrest one for violating programming
style rules. May be used either seriously, to underline a claim
that a particular style violation is dangerous, or ironically, to
suggest that the practice under discussion is condemned mainly by
anal-retentive {weenie}s. "Dike out that goto or the code
police will get you!" The ironic usage is perhaps more common.

:codes: /n./ [scientific computing] Programs. This usage is common
in people who hack supercomputers and heavy-duty
{number-crunching}, rare to unknown elsewhere (if you say
"codes" to hackers outside scientific computing, their
first association is likely to be "and cyphers").

:codewalker: /n./ A program component that traverses other
programs for a living. Compilers have codewalkers in their front
ends; so do cross-reference generators and some database front
ends. Other utility programs that try to do too much with source
code may turn into codewalkers. As in "This new `vgrind'
feature would require a codewalker to implement."

:coefficient of X: /n./ Hackish speech makes heavy use of
pseudo-mathematical metaphors. Four particularly important
ones involve the terms `coefficient', `factor', `index', and
`quotient'. They are often loosely applied to things you cannot
really be quantitative about, but there are subtle distinctions
among them that convey information about the way the speaker
mentally models whatever he or she is describing.

`Foo factor' and `foo quotient' tend to describe something for
which the issue is one of presence or absence. The canonical
example is {fudge factor}. It's not important how much you're
fudging; the term simply acknowledges that some fudging is needed.
You might talk of liking a movie for its silliness factor.
Quotient tends to imply that the property is a ratio of two
opposing factors: "I would have won except for my luck quotient."
This could also be "I would have won except for the luck factor",
but using *quotient* emphasizes that it was bad luck
overpowering good luck (or someone else's good luck overpowering
your own).

`Foo index' and `coefficient of foo' both tend to imply
that foo is, if not strictly measurable, at least something that
can be larger or smaller. Thus, you might refer to a paper or
person as having a `high bogosity index', whereas you would be less
likely to speak of a `high bogosity factor'. `Foo index' suggests
that foo is a condensation of many quantities, as in the mundane
cost-of-living index; `coefficient of foo' suggests that foo is a
fundamental quantity, as in a coefficient of friction. The choice
between these terms is often one of personal preference; e.g., some
people might feel that bogosity is a fundamental attribute and thus
say `coefficient of bogosity', whereas others might feel it is a
combination of factors and thus say `bogosity index'.

:cokebottle: /kohk'bot-l/ /n./ Any very unusual character,
particularly one you can't type because it it isn't on your
keyboard. MIT people used to complain about the
`control-meta-cokebottle' commands at SAIL, and SAIL people
complained right back about the `{altmode}-altmode-cokebottle'
commands at MIT. After the demise of the {space-cadet
keyboard}, `cokebottle' faded away as serious usage, but was
often invoked humorously to describe an (unspecified) weird or
non-intuitive keystroke command. It may be due for a second
inning, however. The OSF/Motif window manager, `mwm(1)', has
a reserved keystroke for switching to the default set of
keybindings and behavior. This keystroke is (believe it or not)
`control-meta-bang' (see {bang}). Since the exclamation point
looks a lot like an upside down Coke bottle, Motif hackers have
begun referring to this keystroke as `cokebottle'. See also
{quadruple bucky}.

:cold boot: /n./ See {boot}.

:COME FROM: /n./ A semi-mythical language construct dual to the
`go to'; `COME FROM' <label> would cause the referenced label
to act as a sort of trapdoor, so that if the program ever reached
it control would quietly and {automagically} be transferred to
the statement following the `COME FROM'. `COME FROM'
was first proposed in R. Lawrence Clark's "A Linguistic
Contribution to GOTO-less programming", which appeared in a 1973
{Datamation} issue (and was reprinted in the April 1984 issue of
"Communications of the ACM"). This parodied the then-raging
`structured programming' {holy wars} (see {considered
harmful}). Mythically, some variants are the `assigned COME
FROM' and the `computed COME FROM' (parodying some nasty control
constructs in FORTRAN and some extended BASICs). Of course,
multi-tasking (or non-determinism) could be implemented by having
more than one `COME FROM' statement coming from the same
label.

In some ways the FORTRAN `DO' looks like a `COME FROM'
statement. After the terminating statement number/`CONTINUE'
is reached, control continues at the statement following the DO.
Some generous FORTRANs would allow arbitrary statements (other than
`CONTINUE') for the statement, leading to examples like:

DO 10 I=1,LIMIT
C imagine many lines of code here, leaving the
C original DO statement lost in the spaghetti...
WRITE(6,10) I,FROB(I)
10 FORMAT(1X,I5,G10.4)

in which the trapdoor is just after the statement labeled 10.
(This is particularly surprising because the label doesn't appear
to have anything to do with the flow of control at all!)

While sufficiently astonishing to the unsuspecting reader, this
form of `COME FROM' statement isn't completely general. After
all, control will eventually pass to the following statement. The
implementation of the general form was left to Univac FORTRAN,
ca. 1975 (though a roughly similar feature existed on the IBM 7040
ten years earlier). The statement `AT 100' would perform a
`COME FROM 100'. It was intended strictly as a debugging aid,
with dire consequences promised to anyone so deranged as to use it
in production code. More horrible things had already been
perpetrated in production languages, however; doubters need only
contemplate the `ALTER' verb in {COBOL}.

`COME FROM' was supported under its own name for the first
time 15 years later, in C-INTERCAL (see {INTERCAL},
{retrocomputing}); knowledgeable observers are still reeling
from the shock.

:comm mode: /kom mohd/ /n./ [ITS: from the feature supporting
on-line chat; the term may spelled with one or two m's] Syn. for
{talk mode}.

:command key: /n./ [Mac users] Syn. {feature key}.

:comment out: /vt./ To surround a section of code with comment
delimiters or to prefix every line in the section with a comment
marker; this prevents it from being compiled or interpreted. Often
done when the code is redundant or obsolete, but is being left in
the source to make the intent of the active code clearer; also when
the code in that section is broken and you want to bypass it in
order to debug some other part of the code. Compare {condition
out}, usually the preferred technique in languages (such as {C})
that make it possible.

:Commonwealth Hackish:: /n./ Hacker jargon as spoken in
English outside the U.S., esp. in the British Commonwealth. It
is reported that Commonwealth speakers are more likely to pronounce
truncations like `char' and `soc', etc., as spelled (/char/,
/sok/), as opposed to American /keir/ and /sohsh/. Dots in
{newsgroup} names (especially two-component names) tend to be
pronounced more often (so soc.wibble is /sok dot wib'l/ rather
than /sohsh wib'l/). The prefix {meta} may be pronounced
/mee't*/; similarly, Greek letter beta is usually /bee't*/,
zeta is usually /zee't*/, and so forth. Preferred
{metasyntactic variable}s include {blurgle}, `eek',
`ook', `frodo', and `bilbo'; {wibble},
`wobble', and in emergencies `wubble'; `flob',
`banana', `tom', `dick', `harry',
`wombat', `frog', {fish}, and so on and on (see
{foo}, sense 4).

Alternatives to verb doubling include suffixes `-o-rama',
`frenzy' (as in feeding frenzy), and `city' (examples: "barf
city!" "hack-o-rama!" "core dump frenzy!"). Finally, note
that the American terms `parens', `brackets', and `braces' for (),
[], and {} are uncommon; Commonwealth hackish prefers
`brackets', `square brackets', and `curly brackets'. Also, the
use of `pling' for {bang} is common outside the United States.

See also {attoparsec}, {calculator}, {chemist},
{console jockey}, {fish}, {go-faster stripes},
{grunge}, {hakspek}, {heavy metal}, {leaky heap},
{lord high fixer}, {loose bytes}, {muddie}, {nadger},
{noddy}, {psychedelicware}, {plingnet}, {raster
blaster}, {RTBM}, {seggie}, {spod}, {sun lounge},
{terminal junkie}, {tick-list features}, {weeble},
{weasel}, {YABA}, and notes or definitions under {Bad
Thing}, {barf}, {bogus}, {bum}, {chase pointers},
{cosmic rays}, {crippleware}, {crunch}, {dodgy},
{gonk}, {hamster}, {hardwarily}, {mess-dos},
{nybble}, {proglet}, {root}, {SEX}, {tweak}, and
{xyzzy}.

:compact: /adj./ Of a design, describes the valuable property
that it can all be apprehended at once in one's head. This
generally means the thing created from the design can be used with
greater facility and fewer errors than an equivalent tool that is
not compact. Compactness does not imply triviality or lack of
power; for example, C is compact and FORTRAN is not, but C is more
powerful than FORTRAN. Designs become non-compact through
accreting {feature}s and {cruft} that don't merge cleanly
into the overall design scheme (thus, some fans of {Classic C}
maintain that ANSI C is no longer compact).

:compiler jock: /n./ See {jock} (sense 2).

:compress: [Unix] /vt./ When used without a qualifier,
generally refers to {crunch}ing of a file using a particular C
implementation of compression by James A. Woods et al. and widely
circulated via {Usenet}; use of {crunch} itself in this sense
is rare among Unix hackers. Specifically, compress is built around
the Lempel-Ziv-Welch algorithm as described in "A Technique for
High Performance Data Compression", Terry A. Welch, "IEEE
Computer", vol. 17, no. 6 (June 1984), pp. 8--19.

:Compu$erve: /n./ See {CI$}. Synonyms CompuSpend and
Compu$pend are also reported.

:computer confetti: /n./ Syn. {chad}. Though this term is
common, this use of punched-card chad is not a good idea, as the
pieces are stiff and have sharp corners that could injure the eyes.
GLS reports that he once attended a wedding at MIT during which he
and a few other guests enthusiastically threw chad instead of
rice. The groom later grumbled that he and his bride had spent most
of the evening trying to get the stuff out of their hair.