- Full Text Free Book (Part 3/11)

Part 3 out of 11

:byte:: /bi:t/ [techspeak] n. 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 originated 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 term `byte' 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/ [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. 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
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 done his bit 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.

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

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

: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. This 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 often they are triggered
during development and how many headaches checking for them turns
out to head off.

: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 are like this. 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: [historically, `according to religious law'] adj. 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}.

This word has an interesting history. 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' 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 use
of jargon. Over his loud objections, GLS and RMS made a point of
using it as much 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: n. 1. An electronic printed-circuit board (see also {tall
card}, {short card}. 2. obs. Syn. {{punched card}}.

: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. {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. This can happen
when one initial error 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 of 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: [from `cut and paste'] n. 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.

:casters-up mode: [IBM] n. 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 "{A Selection
of AI Koans}" ({appendix A}).

: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 outputs 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. This because it is 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: /see-dee til-d*/ vi. To go home. From the UNIX
C-shell and Korn-shell command `cd ~', which takes
one `$HOME'. 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."

:cdr: /ku'dr/ or /kuh'dr/ [from LISP] vt. 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 7090 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 was also called `chaff', `computer
confetti', and `keypunch droppings'.

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

:chad box: n. {Iron Age} card punches contained boxes inside them,
about the size of a lunchbox (or in some models a large
wastebasket), that held the {chad} (sense 2). 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. [orig. from BASIC's `CHAIN' statement] vi. 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. 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: [IRC] n. The basic unit of discussion on {IRC}. Once
one joins a channel, everything one types is read by others on that
channel. Channels can either be named with numbers or 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 summarizing 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: [IRC, GEnie] n. To rapidly switch channels on
{IRC}, or GEnie chat board, just as a social butterfly might hop
from one group to another at a party. This may derive from the TV
watcher's idiom `channel surfing'.

:channel op: /chan'l op/ [IRC] n. 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/ [IRC] n. 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: /char'it-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 dump
(interactively or on a large piece of paper printed with hex
{runes}) following dynamic data-structures. Used only in a
debugging context.

: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 it's 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: [Cambridge] n. 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 {network meltdown} (the result of a {broadcast
storm}), 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: [Commodore] n. 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'), in which a
`chickenhead' is a mutant with below-average intelligence.

:chiclet keyboard: n. A keyboard with small 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/ [MIT] n.,obs. 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}.

: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/ [IRC] n. 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: [from automotive slang via wargaming] n. 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. The back cover depicts the
girl with the device in shambles after she has 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'. This 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. A `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".

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

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

:COBOL: /koh'bol/ [COmmon Business-Oriented Language] n.
(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. 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; 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 police: [by analogy with George Orwell's `thought police'] n.
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.

: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 rather 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' 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.L. 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/ [ITS: from the feature supporting on-line
chat; the term may spelled with one or two m's] Syn. for {talk
mode}.

:command key: [Mac users] n. 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 you want to leave
it 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 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 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 often
/bee't*/, zeta is often /zee't*/, and so forth. Preferred
{metasyntactic variable}s include {blurgle}, `eek',
`ook', `frodo', and `bilbo'; `wibble',
`wobble', and in emergencies `wubble'; `banana',
`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$}. The 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.

:computer geek: n. One who eats (computer) bugs for a living. One
who fulfills all the dreariest negative stereotypes about hackers:
an asocial, malodorous, pasty-faced monomaniac with all the
personality of a cheese grater. Cannot be used by outsiders
without implied insult to all hackers; compare black-on-black usage
of `nigger'. A computer geek may be either a fundamentally
clueless individual or a proto-hacker in {larval stage}. Also
called `turbo nerd', `turbo geek'. See also {propeller head},
{clustergeeking}, {geek out}, {wannabee}, {terminal
junkie}, {spod}, {weenie}.

:computron: /kom'pyoo-tron`/ n. 1. A notional unit of computing
power combining instruction speed and storage capacity, dimensioned
roughly in instructions-per-second times megabytes-of-main-store
times megabytes-of-mass-storage. "That machine can't run GNU
EMACS, it doesn't have enough computrons!" This usage is usually
found in metaphors that treat computing power as a fungible
commodity good, like a crop yield or diesel horsepower. See
{bitty box}, {Get a real computer!}, {toy}, {crank}.
2. A mythical subatomic particle that bears the unit quantity of
computation or information, in much the same way that an electron
bears one unit of electric charge (see also {bogon}). An
elaborate pseudo-scientific theory of computrons has been developed
based on the physical fact that the molecules in a solid object
move more rapidly as it is heated. It is argued that an object
melts because the molecules have lost their information about where
they are supposed to be (that is, they have emitted computrons).
This explains why computers get so hot and require air
conditioning; they use up computrons. Conversely, it should be
possible to cool down an object by placing it in the path of a
computron beam. It is believed that this may also explain why
machines that work at the factory fail in the computer room: the
computrons there have been all used up by the other hardware.
(This theory probably owes something to the "Warlock" stories
by Larry Niven, the best known being "What Good is a Glass
Dagger?", in which magic is fueled by an exhaustible natural
resource called `mana'.)

:condition out: vt. To prevent a section of code from being compiled
by surrounding it with a conditional-compilation directive whose
condition is always false. The {canonical} examples are `#if
0' (or `#ifdef notdef', though some find this {bletcherous})
and `#endif' in C. Compare {comment out}.

:condom: n. 1. The protective plastic bag that accompanies 3.5-inch
microfloppy diskettes. Rarely, also used of (paper) disk
envelopes. Unlike the write protect tab, the condom (when left on)
not only impedes the practice of {SEX} but has also been shown
to have a high failure rate as drive mechanisms attempt to access
the disk --- and can even fatally frustrate insertion. 2. The
protective cladding on a {light pipe}.

:confuser: n. Common soundalike slang for `computer'. Usually
encountered in compounds such as `confuser room', `personal
confuser', `confuser guru'. Usage: silly.

:connector conspiracy: [probably came into prominence with the
appearance of the KL-10 (one model of the {PDP-10}), none of
whose connectors matched anything else] n. The tendency of
manufacturers (or, by extension, programmers or purveyors of
anything) to come up with new products that don't fit together
with the old stuff, thereby making you buy either all new stuff or
expensive interface devices. The KL-10 Massbus connector was
actually *patented* by DEC, which reputedly refused to license
the design and thus effectively locked third parties out of
competition for the lucrative Massbus peripherals market. This is
a source of never-ending frustration for the diehards who maintain
older PDP-10 or VAX systems. Their CPUs work fine, but they are
stuck with dying, obsolescent disk and tape drives with low
capacity and high power requirements.

(A closely related phenomenon, with a slightly different intent, is
the habit manufacturers have of inventing new screw heads so that
only Designated Persons, possessing the magic screwdrivers, can
remove covers and make repairs or install options. The Apple
Macintosh takes this one step further, requiring not only a hex
wrench but a specialized case-cracking tool to open the box.)

In these latter days of open-systems computing this term has fallen
somewhat into disuse, to be replaced by the observation that
"Standards are great! There are so *many* of them to choose
from!" Compare {backward combatability}.

:cons: /konz/ or /kons/ [from LISP] 1. vt. To add a new element
to a specified list, esp. at the top. "OK, cons picking a
replacement for the console TTY onto the agenda." 2. `cons up':
vt. To synthesize from smaller pieces: "to cons up an example".

In LISP itself, `cons' is the most fundamental operation for
building structures. It takes any two objects and returns a
`dot-pair' or two-branched tree with one object hanging from each
branch. Because the result of a cons is an object, it can be used
to build binary trees of any shape and complexity. Hackers think
of it as a sort of universal constructor, and that is where the
jargon meanings spring from.

:considered harmful: adj. Edsger W. Dijkstra's note in the
March 1968 `Communications of the ACM', "Goto Statement
Considered Harmful", fired the first salvo in the structured
programming wars. Amusingly, the ACM considered the resulting
acrimony sufficiently harmful that it will (by policy) no longer
print an article taking so assertive a position against a coding
practice. In the ensuing decades, a large number of both serious
papers and parodies have borne titles of the form "X
considered Y". The structured-programming wars eventually blew
over with the realization that both sides were wrong, but use of
such titles has remained as a persistent minor in-joke (the
`considered silly' found at various places in this lexicon is
related).

:console:: n. 1. The operator's station of a {mainframe}. In
times past, this was a privileged location that conveyed godlike
powers to anyone with fingers on its keys. Under UNIX and other
modern timesharing OSes, such privileges are guarded by passwords
instead, and the console is just the {tty} the system was booted
from. Some of the mystique remains, however, and it is traditional
for sysadmins to post urgent messages to all users from the console
(on UNIX, /dev/console). 2. On microcomputer UNIX boxes, the main
screen and keyboard (as opposed to character-only terminals talking
to a serial port). Typically only the console can do real graphics
or run {X}. See also {CTY}.

:console jockey: n. See {terminal junkie}.

:content-free: [by analogy with techspeak `context-free'] adj.
Used of a message that adds nothing to the recipient's knowledge.
Though this adjective is sometimes applied to {flamage}, it more
usually connotes derision for communication styles that exalt form
over substance or are centered on concerns irrelevant to the
subject ostensibly at hand. Perhaps most used with reference to
speeches by company presidents and other professional manipulators.
"Content-free? Uh...that's anything printed on glossy
paper." See also {four-color glossies}. "He gave a talk on
the implications of electronic networks for postmodernism and the
fin-de-siecle aesthetic. It was content-free."

:control-C: vi. 1. "Stop whatever you are doing." From the
interrupt character used on many operating systems to abort a
running program. Considered silly. 2. interj. Among BSD UNIX
hackers, the canonical humorous response to "Give me a break!"

:control-O: vi. "Stop talking." From the character used on some
operating systems to abort output but allow the program to keep on
running. Generally means that you are not interested in hearing
anything more from that person, at least on that topic; a standard
response to someone who is flaming. Considered silly. Compare
{control-S}.

:control-Q: vi. "Resume." From the ASCII DC1 or {XON}
character (the pronunciation /X-on/ is therefore also used), used
to undo a previous {control-S}.

:control-S: vi. "Stop talking for a second." From the ASCII DC3
or XOFF character (the pronunciation /X-of/ is therefore also
used). Control-S differs from {control-O} in that the person is
asked to stop talking (perhaps because you are on the phone) but
will be allowed to continue when you're ready to listen to him ---
as opposed to control-O, which has more of the meaning of
"Shut up." Considered silly.

:Conway's Law: prov. The rule that the organization of the software and
the organization of the software team will be congruent; originally
stated as "If you have four groups working on a compiler, you'll
get a 4-pass compiler".

This was originally promulgated by Melvin Conway, an early
proto-hacker who wrote an assembler for the Burroughs 220 called
SAVE. The name `SAVE' didn't stand for anything; it was just that
you lost fewer card decks and listings because they all had SAVE
written on them.

:cookbook: [from amateur electronics and radio] n. A book of small
code segments that the reader can use to do various {magic}
things in programs. One current example is the `{PostScript}
Language Tutorial and Cookbook' by Adobe Systems, Inc
(Addison-Wesley, ISBN 0-201-10179-3) which has recipes for things
like wrapping text around arbitrary curves and making 3D fonts.
Cookbooks, slavishly followed, can lead one into {voodoo
programming}, but are useful for hackers trying to {monkey up}
small programs in unknown languages. This is analogous to the role
of phrasebooks in human languages.

:cooked mode: [UNIX] n. The normal character-input mode, with
interrupts enabled and with erase, kill and other special-character
interpretations done directly by the tty driver. Oppose {raw
mode}, {rare mode}. This is techspeak under UNIX but jargon
elsewhere; other operating systems often have similar mode
distinctions, and the raw/rare/cooked way of describing them has
spread widely along with the C language and other UNIX exports.
Most generally, `cooked mode' may refer to any mode of a
system that does extensive preprocessing before presenting data to
a program.

:cookie: n. A handle, transaction ID, or other token of agreement
between cooperating programs. "I give him a packet, he gives me
back a cookie." The claim check you get from a dry-cleaning shop
is a perfect mundane example of a cookie; the only thing it's
useful for is to relate a later transaction to this one (so you get
the same clothes back). Compare {magic cookie}; see also
{fortune cookie}.

:cookie bear: n. Syn. {cookie monster}.

:cookie file: n. A collection of {fortune cookie}s in a format
that facilitates retrieval by a fortune program. There are several
different ones in public distribution, and site admins often
assemble their own from various sources including this lexicon.

:cookie monster: [from "Sesame Street"] n. Any of a family of
early (1970s) hacks reported on {{TOPS-10}}, {{ITS}}, {{Multics}},
and elsewhere that would lock up either the victim's terminal (on a
time-sharing machine) or the {{console}} (on a batch
{mainframe}), repeatedly demanding "I WANT A COOKIE". The
required responses ranged in complexity from "COOKIE" through
"HAVE A COOKIE" and upward. See also {wabbit}.

:copious free time: [Apple; orig. fr. the intro to Tom Lehrer's
song "It Makes A Fellow Proud To Be A Soldier"] n. 1. [used
ironically to indicate the speaker's lack of the quantity in
question] A mythical schedule slot for accomplishing tasks held to
be unlikely or impossible. Sometimes used to indicate that the
speaker is interested in accomplishing the task, but believes that
the opportunity will not arise. "I'll implement the automatic
layout stuff in my copious free time." 2. [Archly] Time reserved
for bogus or otherwise idiotic tasks, such as implementation of
{chrome}, or the stroking of {suit}s. "I'll get back to him
on that feature in my copious free time."

:copper: n. Conventional electron-carrying network cable with a
core conductor of copper --- or aluminum! Opposed to {light
pipe} or, say, a short-range microwave link.

:copy protection: n. A class of (occasionally clever) methods for
preventing incompetent pirates from stealing software and
legitimate customers from using it. Considered silly.

:copybroke: /ko'pee-brohk/ adj. 1. [play on `copyright'] Used
to describe an instance of a copy-protected program that has been
`broken'; that is, a copy with the copy-protection scheme
disabled. Syn. {copywronged}. 2. Copy-protected software
which is unusable because of some bit-rot or bug that has confused
the anti-piracy check.

:copyleft: /kop'ee-left/ [play on `copyright'] n. 1. The
copyright notice (`General Public License') carried by {GNU}
{EMACS} and other Free Software Foundation software, granting reuse
and reproduction rights to all comers (but see also {General
Public Virus}). 2. By extension, any copyright notice intended to
achieve similar aims.

:copywronged: /ko'pee-rongd/ [play on `copyright'] adj. Syn. for
{copybroke}.

:core: n. Main storage or RAM. Dates from the days of ferrite-core
memory; now archaic as techspeak most places outside IBM, but also
still used in the UNIX community and by old-time hackers or those
who would sound like them. Some derived idioms are quite current;
`in core', for example, means `in memory' (as opposed to `on
disk'), and both {core dump} and the `core image' or `core
file' produced by one are terms in favor. Commonwealth hackish
prefers {store}.

:core cancer: n. A process which exhibits a slow but inexorable
resource {leak} --- like a cancer, it kills by crowding out
productive `tissue'.

:core dump: n. [common {Iron Age} jargon, preserved by UNIX]
1. [techspeak] A copy of the contents of {core}, produced when a
process is aborted by certain kinds of internal error. 2. By
extension, used for humans passing out, vomiting, or registering
extreme shock. "He dumped core. All over the floor. What a
mess." "He heard about X and dumped core." 3. Occasionally
used for a human rambling on pointlessly at great length; esp. in
apology: "Sorry, I dumped core on you". 4. A recapitulation of
knowledge (compare {bits}, sense 1). Hence, spewing all one
knows about a topic (syn. {brain dump}), esp. in a lecture or
answer to an exam question. "Short, concise answers are better
than core dumps" (from the instructions to an exam at Columbia).
See {core}.

:core leak: n. Syn. {memory leak}.

:Core Wars: n. A game between `assembler' programs in a
simulated machine, where the objective is to kill your opponent's
program by overwriting it. Popularized by A. K. Dewdney's column
in `Scientific American' magazine, this was actually
devised by Victor Vyssotsky, Robert Morris, and Dennis Ritchie in
the early 1960s (their original game was called `Darwin' and ran on
a PDP-1 at Bell Labs). See {core}.

:corge: /korj/ [originally, the name of a cat] n. Yet another
{metasyntactic variable}, invented by Mike Gallaher and propagated
by the {GOSMACS} documentation. See {grault}.

:cosmic rays: n. Notionally, the cause of {bit rot}. However, this is
a semi-independent usage that may be invoked as a humorous way to
{handwave} away any minor {randomness} that doesn't seem worth the
bother of investigating. "Hey, Eric --- I just got a burst of
garbage on my {tube}, where did that come from?" "Cosmic rays, I
guess." Compare {sunspots}, {phase of the moon}. The British seem
to prefer the usage `cosmic showers'; `alpha particles' is also
heard, because stray alpha particles passing through a memory chip
can cause single-bit errors (this becomes increasingly more likely
as memory sizes and densities increase).

Factual note: Alpha particles cause bit rot, cosmic rays do not
(except occasionally in spaceborne computers). Intel could not
explain random bit drops in their early chips, and one hypothesis
was cosmic rays. So they created the World's Largest Lead Safe,
using 25 tons of the stuff, and used two identical boards for
testing. One was placed in the safe, one outside. The hypothesis
was that if cosmic rays were causing the bit drops, they should see
a statistically significant difference between the error rates on
the two boards. They did not observe such a difference. Further
investigation demonstrated conclusively that the bit drops were due
to alpha particle emissions from thorium (and to a much lesser
degree uranium) in the encapsulation material. Since it is
impossible to eliminate these radioactives (they are uniformly
distributed through the earth's crust, with the statistically
insignificant exception of uranium lodes) it became obvious that
you have to design memories to withstand these hits.

:cough and die: v. Syn. {barf}. Connotes that the program is
throwing its hands up by design rather than because of a bug or
oversight. "The parser saw a control-A in its input where it was
looking for a printable, so it coughed and died." Compare
{die}, {die horribly}.

:cowboy: [Sun, from William Gibson's {cyberpunk} SF] n. Synonym
for {hacker}. It is reported that at Sun this word is often
said with reverence.

:CP/M:: /C-P-M/ n. [Control Program for Microcomputers] An early
microcomputer {OS} written by hacker Gary Kildall for 8080- and
Z80-based machines, very popular in the late 1970s but virtually
wiped out by MS-DOS after the release of the IBM PC in 1981.
Legend has it that Kildall's company blew its chance to write the
OS for the IBM PC because Kildall decided to spend a day IBM's reps
wanted to meet with him enjoying the perfect flying weather in his
private plane. Many of CP/M's features and conventions strongly
resemble those of early DEC operating systems such as
{{TOPS-10}}, OS/8, RSTS, and RSX-11. See {{MS-DOS}},
{operating system}.

:CPU Wars: /C-P-U worz/ n. A 1979 large-format comic by Chas
Andres chronicling the attempts of the brainwashed androids of IPM
(Impossible to Program Machines) to conquer and destroy the
peaceful denizens of HEC (Human Engineered Computers). This rather
transparent allegory featured many references to {ADVENT} and
the immortal line "Eat flaming death, minicomputer mongrels!"
(uttered, of course, by an IPM stormtrooper). It is alleged that
the author subsequently received a letter of appreciation on IBM
company stationery from the head of IBM's Thomas J. Watson Research
Laboratories (then, as now, one of the few islands of true
hackerdom in the IBM archipelago). The lower loop of the B in the
IBM logo, it is said, had been carefully whited out. See {eat
flaming death}.

:crack root: v. To defeat the security system of a UNIX machine and
gain {root} privileges thereby; see {cracking}.

:cracker: n. One who breaks security on a system. Coined ca. 1985
by hackers in defense against journalistic misuse of {hacker}
(q.v., sense 8). An earlier attempt to establish `worm' in this
sense around 1981--82 on USENET was largely a failure.

Both these neologisms reflected a strong revulsion against the
theft and vandalism perpetrated by cracking rings. While it is
expected that any real hacker will have done some playful cracking
and knows many of the basic techniques, anyone past {larval
stage} is expected to have outgrown the desire to do so.

Thus, there is far less overlap between hackerdom and crackerdom
than the {mundane} reader misled by sensationalistic journalism
might expect. Crackers tend to gather in small, tight-knit, very
secretive groups that have little overlap with the huge, open
poly-culture this lexicon describes; though crackers often like to
describe *themselves* as hackers, most true hackers consider
them a separate and lower form of life.

Ethical considerations aside, hackers figure that anyone who can't
imagine a more interesting way to play with their computers than
breaking into someone else's has to be pretty {losing}. Some
other reasons crackers are looked down on are discussed in the
entries on {cracking} and {phreaking}. See also
{samurai}, {dark-side hacker}, and {hacker ethic,
the}.

:cracking: n. The act of breaking into a computer system; what a
{cracker} does. Contrary to widespread myth, this does not
usually involve some mysterious leap of hackerly brilliance, but
rather persistence and the dogged repetition of a handful of fairly
well-known tricks that exploit common weaknesses in the security of
target systems. Accordingly, most crackers are only mediocre
hackers.

:crank: [from automotive slang] vt. Verb used to describe the
performance of a machine, especially sustained performance. "This
box cranks (or, cranks at) about 6 megaflops, with a burst mode
of twice that on vectorized operations."

:crash: 1. n. A sudden, usually drastic failure. Most often said
of the {system} (q.v., sense 1), esp. of magnetic disk drives
(the term originally described what happened when the air gap of a
Winchester disk collapses). "Three {luser}s lost their files
in last night's disk crash." A disk crash that involves the
read/write heads dropping onto the surface of the disks and
scraping off the oxide may also be referred to as a `head crash',
whereas the term `system crash' usually, though not always,
implies that the operating system or other software was at fault.
2. v. To fail suddenly. "Has the system just crashed?"
"Something crashed the OS!" See {down}. Also used
transitively to indicate the cause of the crash (usually a person
or a program, or both). "Those idiots playing {SPACEWAR}
crashed the system." 3. vi. Sometimes said of people hitting the
sack after a long {hacking run}; see {gronk out}.

:crash and burn: vi.,n. A spectacular crash, in the mode of the
conclusion of the car-chase scene in the movie "Bullitt" and
many subsequent imitators (compare {die horribly}). Sun-3
monitors losing the flyback transformer and lightning strikes on
VAX-11/780 backplanes are notable crash and burn generators. The
construction `crash-and-burn machine' is reported for a computer
used exclusively for alpha or {beta} testing, or reproducing
bugs (i.e., not for development). The implication is that it
wouldn't be such a disaster if that machine crashed, since only the
testers would be inconvenienced.

:crawling horror: n. Ancient crufty hardware or software that is
kept obstinately alive by forces beyond the control of the hackers
at a site. Like {dusty deck} or {gonkulator}, but connotes
that the thing described is not just an irritation but an active
menace to health and sanity. "Mostly we code new stuff in C, but
they pay us to maintain one big FORTRAN II application from
nineteen-sixty-X that's a real crawling horror...." Compare
{WOMBAT}.

:cray: /kray/ n. 1. (properly, capitalized) One of the line of
supercomputers designed by Cray Research. 2. Any supercomputer at
all. 3. The {canonical} {number-crunching} machine.

The term is actually the lowercased last name of Seymour Cray, a
noted computer architect and co-founder of the company. Numerous
vivid legends surround him, some true and some admittedly invented
by Cray Research brass to shape their corporate culture and image.

:cray instability: n. A shortcoming of a program or algorithm that
manifests itself only when a large problem is being run on a
powerful machine (see {cray}). Generally more subtle than bugs
that can be detected in smaller problems running on a workstation
or mini.

:crayola: /kray-oh'l*/ n. A super-mini or -micro computer that
provides some reasonable percentage of supercomputer performance
for an unreasonably low price. Might also be a {killer micro}.

:crayon: n. 1. Someone who works on Cray supercomputers. More
specifically, it implies a programmer, probably of the CDC ilk,
probably male, and almost certainly wearing a tie (irrespective of
gender). Systems types who have a UNIX background tend not to be
described as crayons. 2. A {computron} (sense 2) that
participates only in {number-crunching}. 3. A unit of
computational power equal to that of a single Cray-1. There is a
standard joke about this that derives from an old Crayola crayon
promotional gimmick: When you buy 64 crayons you get a free
sharpener.

:creationism: n. The (false) belief that large, innovative software
designs can be completely specified in advance and then painlessly
magicked out of the void by the normal efforts of a team of
normally talented programmers. In fact, experience has shown
repeatedly that good designs arise only from evolutionary,
exploratory interaction between one (or at most a small handful of)
exceptionally able designer(s) and an active user population ---
and that the first try at a big new idea is always wrong.
Unfortunately, because these truths don't fit the planning models
beloved of {management}, they are generally ignored.

:creep: v. To advance, grow, or multiply inexorably. In hackish usage
this verb has overtones of menace and silliness, evoking the
creeping horrors of low-budget monster movies.

:creeping elegance: n. Describes a tendency for parts of a design to
become {elegant} past the point of diminishing return. This
often happens at the expense of the less interesting parts of the
design, the schedule, and other things deemed important in the
{Real World}. See also {creeping featurism}, {second-system
effect}, {tense}.

:creeping featurism: /kree'ping fee'chr-izm/ n. 1. Describes a
systematic tendency to load more {chrome} and {feature}s onto
systems at the expense of whatever elegance they may have possessed
when originally designed. See also {feeping creaturism}. "You
know, the main problem with {BSD} UNIX has always been creeping
featurism." 2. More generally, the tendency for anything
complicated to become even more complicated because people keep
saying "Gee, it would be even better if it had this feature too".
(See {feature}.) The result is usually a patchwork because it
grew one ad-hoc step at a time, rather than being planned.
Planning is a lot of work, but it's easy to add just one extra
little feature to help someone ... and then another ... and
another.... When creeping featurism gets out of hand, it's
like a cancer. Usually this term is used to describe computer
programs, but it could also be said of the federal government, the
IRS 1040 form, and new cars. A similar phenomenon sometimes
afflicts conscious redesigns; see {second-system effect}. See
also {creeping elegance}.

:creeping featuritis: /kree'ping fee'-chr-i:`t*s/ n. Variant of
{creeping featurism}, with its own spoonerization: `feeping
creaturitis'. Some people like to reserve this form for the
disease as it actually manifests in software or hardware, as
opposed to the lurking general tendency in designers' minds.
(After all, -ism means `condition' or `pursuit of', whereas
-itis usually means `inflammation of'.)

:cretin: /kret'n/ or /kree'tn/ n. Congenital {loser}; an obnoxious
person; someone who can't do anything right. It has been observed
that many American hackers tend to favor the British pronunciation
/kre'tn/ over standard American /kree'tn/; it is thought this may
be due to the insidious phonetic influence of Monty Python's Flying
Circus.

:cretinous: /kret'n-*s/ or /kreet'n-*s/ adj. Wrong; stupid;
non-functional; very poorly designed. Also used pejoratively of
people. See {dread high-bit disease} for an example.
Approximate synonyms: {bletcherous}, `bagbiting' (see
{bagbiter}), {losing}, {brain-damaged}.

:crippleware: n. 1. Software that has some important functionality
deliberately removed, so as to entice potential users to pay for a
working version. 2. [Cambridge] {Guiltware} that exhorts you to
donate to some charity (compare {careware}). 3. Hardware
deliberately crippled, which can be upgraded to a more expensive
model by a trivial change (e.g., cutting a jumper).

An excellent example of crippleware (sense 3) is Intel's 486SX
chip, which is a standard 486DX chip with the co-processor
disabled. To upgrade, you buy another 486 chip with everything
*but* the co-processor disabled. When you put them together
you have two crippled chips doing the work of one. Don't you love
Intel?

:critical mass: n. In physics, the minimum amount of fissionable
material required to sustain a chain reaction. Of a software
product, describes a condition of the software such that fixing one
bug introduces one plus {epsilon} bugs. When software achieves
critical mass, it can only be discarded and rewritten.

:crlf: /ker'l*f/, sometimes /kru'l*f/ or /C-R-L-F/ n. (often
capitalized as `CRLF') A carriage return (CR) followed by a line
feed (LF). More loosely, whatever it takes to get you from the
end of one line of text to the beginning of the next line. See
{newline}, {terpri}. Under {{UNIX}} influence this usage
has become less common (UNIX uses a bare line feed as its `CRLF').

:crock: [from the obvious mainstream scatologism] n. 1. An awkward
feature or programming technique that ought to be made cleaner.
Using small integers to represent error codes without the
program interpreting them to the user (as in, for example, UNIX
`make(1)', which returns code 139 for a process that dies due
to {segfault}). 2. A technique that works acceptably, but which
is quite prone to failure if disturbed in the least, for example
depending on the machine opcodes having particular bit patterns so
that you can use instructions as data words too; a tightly woven,
almost completely unmodifiable structure. See {kluge},
{brittle}. Also in the adjectives `crockish' and
`crocky', and the nouns `crockishness' and `crockitude'.

:cross-post: [USENET] vi. To post a single article simultaneously to
several newsgroups. Distinguished from posting the article
repeatedly, once to each newsgroup, which causes people to see it
multiple times (this is very bad form). Gratuitous cross-posting
without a Followup-To line directing responses to a single followup
group is frowned upon, as it tends to cause {followup} articles
to go to inappropriate newsgroups when people respond to only one
part of the original posting.

:crudware: /kruhd'weir/ n. Pejorative term for the hundreds of
megabytes of low-quality {freeware} circulated by user's groups
and BBS systems in the micro-hobbyist world. "Yet *another*
set of disk catalog utilities for {{MS-DOS}}? What crudware!"

:cruft: /kruhft/ [back-formation from {crufty}] 1. n. An
unpleasant substance. The dust that gathers under your bed is
cruft; the TMRC Dictionary correctly noted that attacking it with a
broom only produces more. 2. n. The results of shoddy
construction. 3. vt. [from `hand cruft', pun on `hand craft']
To write assembler code for something normally (and better) done by
a compiler (see {hand-hacking}). 4. n. Excess; superfluous
junk. Esp. used of redundant or superseded code.

This term is one of the oldest in the jargon and no one is sure of
its etymology, but it is suggestive that there is a Cruft Hall at
Harvard University which is part of the old physics building; it's
said to have been the physics department's radar lab during WWII.
To this day (early 1992) the windows appear to be full of random
techno-junk. MIT or Lincoln Labs people may well have coined the
term as a knock on the competition.

:cruft together: vt. (also `cruft up') To throw together
something ugly but temporarily workable. Like vt. {kluge up},
but more pejorative. "There isn't any program now to reverse all
the lines of a file, but I can probably cruft one together in about
10 minutes." See {hack together}, {hack up}, {kluge up},
{crufty}.

:cruftsmanship: /kruhfts'm*n-ship / n. [from {cruft}] The
antithesis of craftsmanship.

:crufty: /kruhf'tee/ [origin unknown; poss. from `crusty' or
`cruddy'] adj. 1. Poorly built, possibly over-complex. The
{canonical} example is "This is standard old crufty DEC
software". In fact, one fanciful theory of the origin of
`crufty' holds that was originally a mutation of `crusty'
applied to DEC software so old that the `s' characters were tall
and skinny, looking more like `f' characters. 2. Unpleasant,
especially to the touch, often with encrusted junk. Like spilled
coffee smeared with peanut butter and catsup. 3. Generally
unpleasant. 4. (sometimes spelled `cruftie') n. A small crufty
object (see {frob}); often one that doesn't fit well into the
scheme of things. "A LISP property list is a good place to store
crufties (or, collectively, {random} cruft)."

:crumb: n. Two binary digits; a {quad}. Larger than a {bit},
smaller than a {nybble}. Considered silly. Syn. {tayste}.

:crunch: 1. vi. To process, usually in a time-consuming or
complicated way. Connotes an essentially trivial operation that is
nonetheless painful to perform. The pain may be due to the
triviality's being embedded in a loop from 1 to 1,000,000,000.
"FORTRAN programs do mostly {number-crunching}." 2. vt. To
reduce the size of a file by a complicated scheme that produces bit
configurations completely unrelated to the original data, such as
by a Huffman code. (The file ends up looking like a paper document
would if somebody crunched the paper into a wad.) Since such
compression usually takes more computations than simpler methods
such as run-length encoding, the term is doubly appropriate. (This
meaning is usually used in the construction `file crunch(ing)' to
distinguish it from {number-crunching}.) See {compress}.
3. n. The character `#'. Used at XEROX and CMU, among other
places. See {{ASCII}}. 4. vt. To squeeze program source into a
minimum-size representation that will still compile or execute.
The term came into being specifically for a famous program on the
BBC micro that crunched BASIC source in order to make it run more
quickly (it was a wholly interpretive BASIC, so the number of
characters mattered). {Obfuscated C Contest} entries are often
crunched; see the first example under that entry.

:cruncha cruncha cruncha: /kruhn'ch* kruhn'ch* kruhn'ch*/ interj.
An encouragement sometimes muttered to a machine bogged down in a
serious {grovel}. Also describes a notional sound made by
groveling hardware. See {wugga wugga}, {grind} (sense 3).

:cryppie: /krip'ee/ n. A cryptographer. One who hacks or implements
cryptographic software or hardware.

:CTSS: /C-T-S-S/ n. Compatible Time-Sharing System. An early
(1963) experiment in the design of interactive time-sharing
operating systems, ancestral to {{Multics}}, {{UNIX}}, and
{{ITS}}. The name {{ITS}} (Incompatible Time-sharing System)
was a hack on CTSS, meant both as a joke and to express some basic
differences in philosophy about the way I/O services should be
presented to user programs.

:CTY: /sit'ee/ or /C-T-Y/ n. [MIT] The terminal physically
associated with a computer's system {{console}}. The term is a
contraction of `Console {tty}', that is, `Console TeleTYpe'.
This {{ITS}}- and {{TOPS-10}}-associated term has become less
common, as most UNIX hackers simply refer to the CTY as `the
console'.

:cube: n. 1. [short for `cubicle'] A module in the open-plan
offices used at many programming shops. "I've got the manuals in
my cube." 2. A NeXT machine (which resembles a matte-black cube).

:cubing: [parallel with `tubing'] vi. 1. Hacking on an IPSC (Intel
Personal SuperComputer) hypercube. "Louella's gone cubing
*again*!!" 2. Hacking Rubik's Cube or related puzzles,
either physically or mathematically. 3. An indescribable form of
self-torture (see sense 1 or 2).

:cursor dipped in X: n. There are a couple of metaphors in English
of the form `pen dipped in X' (perhaps the most common values of X
are `acid', `bile', and `vitriol'). These map over neatly to this
hackish usage (the cursor being what moves, leaving letters behind,
when one is composing on-line). "Talk about a {nastygram}! He
must've had his cursor dipped in acid when he wrote that one!"

:cuspy: /kuhs'pee/ [WPI: from the DEC abbreviation CUSP, for `Commonly
Used System Program', i.e., a utility program used by many people]
adj. 1. (of a program) Well-written. 2. Functionally excellent. A
program that performs well and interfaces well to users is cuspy.
See {rude}. 3. [NYU] Said of an attractive woman, especially one
regarded as available. Implies a certain curvaceousness.

:cut a tape: vi. To write a software or document distribution on
magnetic tape for shipment. Has nothing to do with physically
cutting the medium! Early versions of this lexicon claimed that
one never analogously speaks of `cutting a disk', but this has
since been reported as live usage. Related slang usages are
mainstream business's `cut a check', the recording industry's
`cut a record', and the military's `cut an order'.

All of these usages reflect physical processes in obsolete
recording and duplication technologies. The first stage in
manufacturing an old-style vinyl record involved cutting grooves in
a stamping die with a precision lathe. More mundanely, the
dominant technology for mass duplication of paper documents in
pre-photocopying days involved "cutting a stencil", punching away
portions of the wax overlay on a silk screen. More directly,
paper tape with holes punched in it was an inportant early storage
medium.

:cybercrud: /si:'ber-kruhd/ [coined by Ted Nelson] n. Obfuscatory
tech-talk. Verbiage with a high {MEGO} factor. The computer
equivalent of bureaucratese.

:cyberpunk: /si:'ber-puhnk/ [orig. by SF writer Bruce Bethke
and/or editor Gardner Dozois] n.,adj. A subgenre of SF launched
in 1982 by William Gibson's epoch-making novel `Neuromancer'
(though its roots go back through Vernor Vinge's `True Names'
(see "{True Names ... and Other Dangers}" in
appendix C) to John Brunner's 1975 novel `The Shockwave
Rider'). Gibson's near-total ignorance of computers and the
present-day hacker culture enabled him to speculate about the role
of computers and hackers in the future in ways hackers have since
found both irritatingly na"ive and tremendously stimulating.
Gibson's work was widely imitated, in particular by the short-lived
but innovative "Max Headroom" TV series. See
{cyberspace}, {ice}, {jack in}, {go flatline}.

:cyberspace: /si:'ber-spays/ n. 1. Notional `information-space'
loaded with visual cues and navigable with brain-computer
interfaces called `cyberspace decks'; a characteristic prop of
{cyberpunk} SF. At the time of this writing (mid-1991),
serious efforts to construct {virtual reality} interfaces
modeled explicitly on Gibsonian cyberspace are already under way,
using more conventional devices such as glove sensors and binocular
TV headsets. Few hackers are prepared to deny outright the
possibility of a cyberspace someday evolving out of the network
(see {network, the}). 2. Occasionally, the metaphoric location
of the mind of a person in {hack mode}. Some hackers report
experiencing strong eidetic imagery when in hack mode;
interestingly, independent reports from multiple sources suggest
that there are common features to the experience. In particular,
the dominant colors of this subjective `cyberspace' are often
gray and silver, and the imagery often involves constellations of
marching dots, elaborate shifting patterns of lines and angles, or
moire patterns.

:cycle: 1. n. The basic unit of computation. What every hacker
wants more of (noted hacker Bill Gosper describes himself as a
"cycle junkie"). One can describe an instruction as taking so
many `clock cycles'. Often the computer can access its
memory once on every clock cycle, and so one speaks also of
`memory cycles'. These are technical meanings of {cycle}. The
jargon meaning comes from the observation that there are only so
many cycles per second, and when you are sharing a computer the
cycles get divided up among the users. The more cycles the
computer spends working on your program rather than someone else's,
the faster your program will run. That's why every hacker wants
more cycles: so he can spend less time waiting for the computer to
respond. 2. By extension, a notional unit of *human* thought
power, emphasizing that lots of things compete for the typical
hacker's think time. "I refused to get involved with the Rubik's
Cube back when it was big. Knew I'd burn too many cycles on it if
I let myself." 3. vt. Syn. {bounce}, {120 reset}; from the
phrase `cycle power'. "Cycle the machine again, that serial port's
still hung."

:cycle crunch: n. A situation where the number of people trying to
use the computer simultaneously has reached the point where no one
can get enough cycles because they are spread too thin and the
system has probably begun to {thrash}. This is an inevitable
result of Parkinson's Law applied to timesharing. Usually the only
solution is to buy more computer. Happily, this has rapidly become
easier in recent years, so much so that the very term `cycle
crunch' now has a faintly archaic flavor; most hackers now use
workstations or personal computers as opposed to traditional
timesharing systems.

:cycle drought: n. A scarcity of cycles. It may be due to a {cycle
crunch}, but it could also occur because part of the computer is
temporarily not working, leaving fewer cycles to go around.
"The {high moby} is {down}, so we're running with only
half the usual amount of memory. There will be a cycle drought
until it's fixed."

:cycle of reincarnation: [coined by Ivan Sutherland ca. 1970] n.
Term used to refer to a well-known effect whereby function in a
computing system family is migrated out to special-purpose
peripheral hardware for speed, then the peripheral evolves toward
more computing power as it does its job, then somebody notices that
it is inefficient to support two asymmetrical processors in the
architecture and folds the function back into the main CPU, at
which point the cycle begins again. Several iterations of this
cycle have been observed in graphics-processor design, and at least
one or two in communications and floating-point processors. Also
known as `the Wheel of Life', `the Wheel of Samsara', and other
variations of the basic Hindu/Buddhist theological idea.

:cycle server: n. A powerful machine that exists primarily for
running large {batch} jobs. Implies that interactive tasks such as
editing are done on other machines on the network, such as
workstations.

= D =
=====

:D. C. Power Lab: n. The former site of {{SAIL}}. Hackers thought
this was very funny because the obvious connection to electrical
engineering was nonexistent --- the lab was named for a Donald C.
Power. Compare {Marginal Hacks}.

:daemon: /day'mn/ or /dee'mn/ [from the mythological meaning,
later rationalized as the acronym `Disk And Execution MONitor'] n.
A program that is not invoked explicitly, but lies dormant waiting
for some condition(s) to occur. The idea is that the perpetrator
of the condition need not be aware that a daemon is lurking (though
often a program will commit an action only because it knows that it
will implicitly invoke a daemon). For example, under {{ITS}}
writing a file on the {LPT} spooler's directory would invoke the
spooling daemon, which would then print the file. The advantage is
that programs wanting (in this example) files printed need not
compete for access to the {LPT}. They simply enter their
implicit requests and let the daemon decide what to do with them.
Daemons are usually spawned automatically by the system, and may
either live forever or be regenerated at intervals. Daemon and
{demon} are often used interchangeably, but seem to have
distinct connotations. The term `daemon' was introduced to
computing by {CTSS} people (who pronounced it /dee'mon/) and
used it to refer to what ITS called a {dragon}. Although the
meaning and the pronunciation have drifted, we think this glossary
reflects current (1991) usage.

:dangling pointer: n. A reference that doesn't actually lead
anywhere (in C and some other languages, a pointer that doesn't
actually point at anything valid). Usually this is because it
formerly pointed to something that has moved or disappeared. Used
as jargon in a generalization of its techspeak meaning; for
example, a local phone number for a person who has since moved to
the other coast is a dangling pointer.

:dark-side hacker: n. A criminal or malicious hacker; a
{cracker}. From George Lucas's Darth Vader, "seduced by the
dark side of the Force". The implication that hackers form a
sort of elite of technological Jedi Knights is intended. Oppose
{samurai}.

:Datamation: /day`t*-may'sh*n/ n. A magazine that many hackers
assume all {suit}s read. Used to question an unbelieved quote,
as in "Did you read that in `Datamation?'" It used to
publish something hackishly funny every once in a while, like the
original paper on {COME FROM} in 1973, but it has since become much
more exclusively {suit}-oriented and boring.

:day mode: n. See {phase} (sense 1). Used of people only.

:dd: /dee-dee/ [UNIX: from IBM {JCL}] vt. Equivalent to
{cat} or {BLT}. This was originally the name of a UNIX copy
command with special options suitable for block-oriented devices.
Often used in heavy-handed system maintenance, as in "Let's
`dd' the root partition onto a tape, then use the boot PROM to
load it back on to a new disk". The UNIX `dd(1)' was
designed with a weird, distinctly non-UNIXy keyword option syntax
reminiscent of IBM System/360 JCL (which had an elaborate DD `Data
Definition' specification for I/O devices); though the command
filled a need, the interface design was clearly a prank. The
jargon usage is now very rare outside UNIX sites and now nearly
obsolete even there, as `dd(1)' has been {deprecated} for a
long time (though it has no exact replacement). Replaced by
{BLT} or simple English `copy'.

:DDT: /D-D-T/ n. 1. Generic term for a program that assists in
debugging other programs by showing individual machine instructions
in a readable symbolic form and letting the user change them. In
this sense the term DDT is now archaic, having been widely
displaced by `debugger' or names of individual programs like
`dbx', `adb', `gdb', or `sdb'. 2. [ITS] Under
MIT's fabled {{ITS}} operating system, DDT (running under the alias
HACTRN) was also used as the {shell} or top level command
language used to execute other programs. 3. Any one of several
specific DDTs (sense 1) supported on early DEC hardware. The DEC
PDP-10 Reference Handbook (1969) contained a footnote on the first
page of the documentation for DDT which illuminates the origin of
the term:

Historical footnote: DDT was developed at MIT for the PDP-1
computer in 1961. At that time DDT stood for "DEC Debugging Tape".
Since then, the idea of an on-line debugging program has propagated
throughout the computer industry. DDT programs are now available
for all DEC computers. Since media other than tape are now
frequently used, the more descriptive name "Dynamic Debugging
Technique" has been adopted, retaining the DDT abbreviation.
Confusion between DDT-10 and another well known pesticide,
dichloro-diphenyl-trichloroethane (C14-H9-Cl5) should be minimal
since each attacks a different, and apparently mutually exclusive,
class of bugs.

Sadly, this quotation was removed from later editions of the
handbook after the {suit}s took over and DEC became much more
`businesslike'.

The history above is known to many old-time hackers. But there's
more: Peter Samson, author of the {TMRC} lexicon, reports that
he named `DDT' after a similar tool on the TX-0 computer, the
direct ancestor of the PDP-1 built at MIT's Lincoln Lab in 1957.
The debugger on that ground-breaking machine (the first
transistorized computer) rejoiced in the name FLIT (FLexowriter
Interrogation Tape).

:de-rezz: /dee-rez'/ [from `de-resolve' via the movie "Tron"]
(also `derez') 1. vi. To disappear or dissolve; the image that goes
with it is of an object breaking up into raster lines and static
and then dissolving. Occasionally used of a person who seems to
have suddenly `fuzzed out' mentally rather than physically.
Usage: extremely silly, also rare. This verb was actually invented
as *fictional* hacker jargon, and adopted in a spirit of irony
by real hackers years after the fact. 2. vt. On a Macintosh, many
program structures (including the code itself) are managed in small
segments of the program file known as `resources'. The standard
resource compiler is Rez. The standard resource decompiler is
DeRez. Thus, decompiling a resource is `derezzing'. Usage: very
common.

:dead: adj. 1. Non-functional; {down}; {crash}ed. Especially
used of hardware. 2. At XEROX PARC, software that is working but
not undergoing continued development and support.

:dead code: n. Routines that can never be accessed because all calls
to them have been removed, or code that cannot be reached because
it is guarded by a control structure that provably must always
transfer control somewhere else. The presence of dead code may
reveal either logical errors due to alterations in the program or
significant changes in the assumptions and environment of the
program (see also {software rot}); a good compiler should report
dead code so a maintainer can think about what it means. Syn.
{grunge}.

:DEADBEEF: /ded-beef/ n. The hexadecimal word-fill pattern for
freshly allocated memory (decimal -21524111) under a number of
IBM environments, including the RS/6000. As in "Your program is
DEADBEEF" (meaning gone, aborted, flushed from memory); if you
start from an odd half-word boundary, of course, you have
BEEFDEAD.

:deadlock: n. 1. [techspeak] A situation wherein two or more
processes are unable to proceed because each is waiting for one of
the others to do something. A common example is a program
communicating to a server, which may find itself waiting for output
from the server before sending anything more to it, while the
server is similarly waiting for more input from the controlling
program before outputting anything. (It is reported that this
particular flavor of deadlock is sometimes called a `starvation
deadlock', though the term `starvation' is more properly used for
situations where a program can never run simply because it never
gets high enough priority. Another common flavor is
`constipation', where each process is trying to send stuff to
the other but all buffers are full because nobody is reading
anything.) See {deadly embrace}. 2. Also used of
deadlock-like interactions between humans, as when two people meet
in a narrow corridor, and each tries to be polite by moving aside
to let the other pass, but they end up swaying from side to side
without making any progress because they always both move the same
way at the same time.

:deadly embrace: n. Same as {deadlock}, though usually used only when
exactly 2 processes are involved. This is the more popular term in
Europe, while {deadlock} predominates in the United States.

:death code: n. A routine whose job is to set everything in the
computer --- registers, memory, flags, everything --- to zero,
including that portion of memory where it is running; its last act
is to stomp on its own "store zero" instruction. Death code
isn't very useful, but writing it is an interesting hacking
challenge on architectures where the instruction set makes it
possible, such as the PDP-8 (it has also been done on the DG Nova).
Death code is much less common, and more anti-social, on modern
multi-user machines. It was very impressive on earlier hardware
that provided front panel switches and displays to show register
and memory contents, esp. when these were used to prod the corpse
to see why it died.

Perhaps the ultimate death code is on the TI 990 series, where all
registers are actually in RAM, and the instruction "store immediate
0" has the opcode "0". The PC will immediately wrap around core as
many times as it can until a user hits HALT. Any empty memory
location is death code. Worse, the manufacturer recommended use of
this instruction in startup code (which would be in ROM and
therefore survive).

:Death Star: [from the movie "Star Wars"] 1. The AT&T corporate
logo, which appears on computers sold by AT&T and bears an uncanny
resemblance to the `Death Star' in the movie. This usage is
particularly common among partisans of {BSD} UNIX, who tend to
regard the AT&T versions as inferior and AT&T as a bad guy. Copies
still circulate of a poster printed by Mt. Xinu showing a starscape
with a space fighter labeled 4.2 BSD streaking away from a broken
AT&T logo wreathed in flames. 2. AT&T's internal magazine,
`Focus', uses `death star' for an incorrectly done AT&T logo
in which the inner circle in the top left is dark instead of light
--- a frequent result of dark-on-light logo images.

:DEC Wars: n. A 1983 {USENET} posting by Alan Hastings and Steve
Tarr spoofing the "Star Wars" movies in hackish terms. Some
years later, ESR (disappointed by Hastings and Tarr's failure to
exploit a great premise more thoroughly) posted a 3-times-longer
complete rewrite called "UNIX WARS"; the two are often
confused.

:DEChead: /dek'hed/ n. 1. A DEC {field servoid}. Not flattering.
2. [from `deadhead'] A Grateful Dead fan working at DEC.

:deckle: /dek'l/ [from dec- and {nybble}; the original
spelling seems to have been `decle'] n. Two {nickle}s;
10 bits. Reported among developers for Mattel's GI 1600 (the
Intellivision games processor), a chip with 16-bit-wide RAM but
10-bit-wide ROM.

:deep hack mode: n. See {hack mode}.

:deep magic: [poss. from C. S. Lewis's "Narnia" books] n. An
awesomely arcane technique central to a program or system, esp. one
not generally published and available to hackers at large (compare
{black art}); one that could only have been composed by a true
{wizard}. Compiler optimization techniques and many aspects of
{OS} design used to be {deep magic}; many techniques in
cryptography, signal processing, graphics, and AI still are.
Compare {heavy wizardry}. Esp. found in comments of the form
"Deep magic begins here...". Compare {voodoo programming}.

:deep space: n. 1. Describes the notional location of any program
that has gone {off the trolley}. Esp. used of programs that
just sit there silently grinding long after either failure or some
output is expected. "Uh oh. I should have gotten a prompt ten
seconds ago. The program's in deep space somewhere." Compare
{buzz}, {catatonic}, {hyperspace}. 2. The metaphorical
location of a human so dazed and/or confused or caught up in some
esoteric form of {bogosity} that he or she no longer responds
coherently to normal communication. Compare {page out}.

:defenestration: [from the traditional Czechoslovak method of
assassinating prime ministers, via SF fandom] n. 1. Proper karmic
retribution for an incorrigible punster. "Oh, ghod, that was
*awful*!" "Quick! Defenestrate him!" 2. The act of
exiting a window system in order to get better response time from a
full-screen program. This comes from the dictionary meaning of
`defenestrate', which is to throw something out a window. 3. The
act of discarding something under the assumption that it will
improve matters. "I don't have any disk space left." "Well,
why don't you defenestrate that 100 megs worth of old core dumps?"
4. [proposed] The requirement to support a command-line interface.
"It has to run on a VT100." "Curses! I've been
defenestrated!"

:defined as: adj. In the role of, usually in an organization-chart
sense. "Pete is currently defined as bug prioritizer." Compare
{logical}.

:dehose: /dee-hohz/ vt. To clear a {hosed} condition.

:delint: /dee-lint/ v. To modify code to remove problems detected
when {lint}ing. Confusingly, this is also referred to as
`linting' code.

:delta: n. 1. [techspeak] A quantitative change, especially a small
or incremental one (this use is general in physics and
engineering). "I just doubled the speed of my program!" "What
was the delta on program size?" "About 30 percent." (He
doubled the speed of his program, but increased its size by only 30
percent.) 2. [UNIX] A {diff}, especially a {diff} stored
under the set of version-control tools called SCCS (Source Code
Control System) or RCS (Revision Control System). 3. n. A small
quantity, but not as small as {epsilon}. The jargon usage of
{delta} and {epsilon} stems from the traditional use of these
letters in mathematics for very small numerical quantities,
particularly in `epsilon-delta' proofs in limit theory (as in the
differential calculus). The term {delta} is often used, once
{epsilon} has been mentioned, to mean a quantity that is
slightly bigger than {epsilon} but still very small. "The cost
isn't epsilon, but it's delta" means that the cost isn't totally
negligible, but it is nevertheless very small. Common
constructions include `within delta of ---', `within epsilon of
---': that is, close to and even closer to.

:demented: adj. Yet another term of disgust used to describe a
program. The connotation in this case is that the program works as
designed, but the design is bad. Said, for example, of a program
that generates large numbers of meaningless error messages,
implying that it is on the brink of imminent collapse. Compare
{wonky}, {bozotic}.

:demigod: n. A hacker with years of experience, a national reputation,
and a major role in the development of at least one design, tool,
or game used by or known to more than half of the hacker community.
To qualify as a genuine demigod, the person must recognizably
identify with the hacker community and have helped shape it. Major
demigods include Ken Thompson and Dennis Ritchie (co-inventors of
{{UNIX}} and {C}) and Richard M. Stallman (inventor of
{EMACS}). In their hearts of hearts, most hackers dream of
someday becoming demigods themselves, and more than one major
software project has been driven to completion by the author's
veiled hopes of apotheosis. See also {net.god}, {true-hacker}.

:demo: /de'moh/ [short for `demonstration'] 1. v. To
demonstrate a product or prototype. A far more effective way of
inducing bugs to manifest than any number of {test} runs,
especially when important people are watching. 2. n. The act of
demoing. 3. n. Esp. as `demo version', can refer to either a
special version of a program (frequently with some features
crippled) which is distributed at little or no cost to the user for
demonstration purposes.

:demo mode: [Sun] n. 1. The state of being {heads down} in order
to finish code in time for a {demo}, usually due yesterday.
2. A mode in which video games sit there by themselves running
through a portion of the game, also known as `attract mode'.
Some serious {app}s have a demo mode they use as a screen saver,
or may go through a demo mode on startup (for example, the
Microsoft Windows opening screen --- which lets you impress your
neighbors without actually having to put up with {Microsloth
Windows}).

:demon: n. 1. [MIT] A portion of a program that is not invoked
explicitly, but that lies dormant waiting for some condition(s) to
occur. See {daemon}. The distinction is that demons are
usually processes within a program, while daemons are usually
programs running on an operating system. Demons are particularly
common in AI programs. For example, a knowledge-manipulation
program might implement inference rules as demons. Whenever a new
piece of knowledge was added, various demons would activate (which
demons depends on the particular piece of data) and would create
additional pieces of knowledge by applying their respective
inference rules to the original piece. These new pieces could in
turn activate more demons as the inferences filtered down through
chains of logic. Meanwhile, the main program could continue with
whatever its primary task was. 2. [outside MIT] Often used
equivalently to {daemon} --- especially in the {{UNIX}} world,
where the latter spelling and pronunciation is considered mildly
archaic.

:depeditate: /dee-ped'*-tayt/ [by (faulty) analogy with
`decapitate'] vt. Humorously, to cut off the feet of. When one is
using some computer-aided typesetting tools, careless placement of
text blocks within a page or above a rule can result in chopped-off
letter descenders. Such letters are said to have been depeditated.

:deprecated: adj. Said of a program or feature that is considered
obsolescent and in the process of being phased out, usually in
favor of a specified replacement. Deprecated features can,
unfortunately, linger on for many years. This term appears with
distressing frequency in standards documents when the committees
which write them decide that a sufficient number of users have
written code which depends on specific features which are out of
favor.

:deserves to lose: adj. Said of someone who willfully does the
{Wrong Thing}; humorously, if one uses a feature known to be
{marginal}. What is meant is that one deserves the consequences
of one's {losing} actions. "Boy, anyone who tries to use
{mess-dos} deserves to {lose}!" ({{ITS}} fans used to say this
of {{UNIX}}; many still do.) See also {screw}, {chomp},
{bagbiter}.

:desk check: n.,v. To {grovel} over hardcopy of source code,
mentally simulating the control flow; a method of catching bugs.
No longer common practice in this age of on-screen editing, fast
compiles, and sophisticated debuggers --- though some maintain
stoutly that it ought to be. Compare {eyeball search},
{vdiff}, {vgrep}.

:Devil Book: n. `The Design and Implementation of the 4.3BSD
UNIX Operating System', by Samuel J. Leffler, Marshall Kirk
McKusick, Michael J. Karels, and John S. Quarterman (Addison-Wesley
Publishers, 1989) --- the standard reference book on the internals
of {BSD} UNIX. So called because the cover has a picture
depicting a little devil (a visual play on {daemon}) in
sneakers, holding a pitchfork (referring to one of the
characteristic features of UNIX, the `fork(2)' system call).

:devo: /dee'voh/ [orig. in-house jargon at Symbolics] n. A person in a
development group. See also {doco} and {mango}.

:dickless workstation: n. Extremely pejorative hackerism for
`diskless workstation', a class of botches including the Sun 3/50
and other machines designed exclusively to network with an
expensive central disk server. These combine all the disadvantages
of time-sharing with all the disadvantages of distributed personal
computers; typically, they cannot even {boot} themselves without
help (in the form of some kind of {breath-of-life packet}) from
the server.

:dictionary flame: [USENET] n. An attempt to sidetrack a debate
away from issues by insisting on meanings for key terms that
presuppose a desired conclusion or smuggle in an implicit premise.
A common tactic of people who prefer argument over definitions to
disputes about reality.

:diddle: 1. vt. To work with or modify in a not particularly

Back to Full Books