:bit twiddling: n. 1. (pejorative) An ex_The Jargon File, Version 2.9.10, 01 Jul 1992

{tune}) in which incredible amounts of time and effort go to

produce little noticeable improvement, often with the result that

the code has become incomprehensible. 2. Aimless small

modification to a program, esp. for some pointless goal.

3. Approx. syn. for {bit bashing}; esp. used for the act of

frobbing the device control register of a peripheral in an attempt

to get it back to a known state.

:bit-paired keyboard: n. obs. (alt. `bit-shift keyboard') A

non-standard keyboard layout that seems to have originated with the

Teletype ASR-33 and remained common for several years on early

computer equipment. The ASR-33 was a mechanical device (see

{EOU}), so the only way to generate the character codes from

keystrokes was by some physical linkage. The design of the ASR-33

assigned each character key a basic pattern that could be modified

by flipping bits if the SHIFT or the CTRL key was pressed. In

order to avoid making the thing more of a Rube Goldberg kluge than

it already was, the design had to group characters that shared the

same basic bit pattern on one key.

Looking at the ASCII chart, we find:

high low bits

bits 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001

010 ! " # $ % & ' ( )

011 0 1 2 3 4 5 6 7 8 9

This is why the characters !"#$%&'() appear where they do on a

Teletype (thankfully, they didn't use shift-0 for space). This was

*not* the weirdest variant of the {QWERTY} layout widely

seen, by the way; that prize should probably go to one of several

(differing) arrangements on IBM's even clunkier 026 and 029 card

punches.

When electronic terminals became popular, in the early 1970s, there

was no agreement in the industry over how the keyboards should be

laid out. Some vendors opted to emulate the Teletype keyboard,

while others used the flexibility of electronic circuitry to make

their product look like an office typewriter. These alternatives

became known as `bit-paired' and `typewriter-paired' keyboards. To

a hacker, the bit-paired keyboard seemed far more logical --- and

because most hackers in those days had never learned to touch-type,

there was little pressure from the pioneering users to adapt

keyboards to the typewriter standard.

The doom of the bit-paired keyboard was the large-scale

introduction of the computer terminal into the normal office

environment, where out-and-out technophobes were expected to use

the equipment. The `typewriter-paired' standard became universal,

`bit-paired' hardware was quickly junked or relegated to dusty

corners, and both terms passed into disuse.

:bitblt: /bit'blit/ n. [from {BLT}, q.v.] 1. Any of a family

of closely related algorithms for moving and copying rectangles of

bits between main and display memory on a bit-mapped device, or

between two areas of either main or display memory (the requirement

to do the {Right Thing} in the case of overlapping source and

destination rectangles is what makes BitBlt tricky). 2. Synonym

for {blit} or {BLT}. Both uses are borderline techspeak.

:BITNET: /bit'net/ [acronym: Because It's Time NETwork] n.

Everybody's least favorite piece of the network (see {network,

the}). The BITNET hosts are a collection of IBM dinosaurs and

VAXen (the latter with lobotomized comm hardware) that communicate

using 80-character {{EBCDIC}} card images (see {eighty-column

mind}); thus, they tend to mangle the headers and text of

third-party traffic from the rest of the ASCII/RFC-822 world with

annoying regularity. BITNET is also notorious as the apparent home

of {BIFF}.

:bits: n.pl. 1. Information. Examples: "I need some bits about file

formats." ("I need to know about file formats.") Compare {core

dump}, sense 4. 2. Machine-readable representation of a document,

specifically as contrasted with paper: "I have only a photocopy

of the Jargon File; does anyone know where I can get the bits?".

See {softcopy}, {source of all good bits} See also {bit}.

:bitty box: /bit'ee boks/ n. 1. A computer sufficiently small,

primitive, or incapable as to cause a hacker acute claustrophobia

at the thought of developing software on or for it. Especially

used of small, obsolescent, single-tasking-only personal machines

such as the Atari 800, Osborne, Sinclair, VIC-20, TRS-80, or

IBM PC. 2. [Pejorative] More generally, the opposite of `real

computer' (see {Get a real computer!}). See also {mess-dos},

{toaster}, and {toy}.

:bixie: /bik'see/ n. Variant {emoticon}s used on BIX (the Byte

Information eXchange). The {smiley} bixie is <@_@>, apparently

intending to represent two cartoon eyes and a mouth. A few others

have been reported.

:black art: n. A collection of arcane, unpublished, and (by

implication) mostly ad-hoc techniques developed for a particular

application or systems area (compare {black magic}). VLSI design

and compiler code optimization were (in their beginnings)

considered classic examples of black art; as theory developed they

became {deep magic}, and once standard textbooks had been written,

became merely {heavy wizardry}. The huge proliferation of formal

and informal channels for spreading around new computer-related

technologies during the last twenty years has made both the term

`black art' and what it describes less common than formerly. See

also {voodoo programming}.

:black hole: n. When a piece of email or netnews disappears

mysteriously between its origin and destination sites (that is,

without returning a {bounce message}) it is commonly said to have

`fallen into a black hole'. "I think there's a black hole at

foovax!" conveys suspicion that site foovax has been dropping

a lot of stuff on the floor lately (see {drop on the floor}).

The implied metaphor of email as interstellar travel is interesting

in itself. Compare {bit bucket}.

:black magic: n. A technique that works, though nobody really

understands why. More obscure than {voodoo programming}, which

may be done by cookbook. Compare also {black art}, {deep

magic}, and {magic number} (sense 2).

:blargh: /blarg/ [MIT] n. The opposite of {ping}, sense 5; an

exclamation indicating that one has absorbed or is emitting a

quantum of unhappiness. Less common than {ping}.

:blast: 1. vt.,n. Synonym for {BLT}, used esp. for large data

sends over a network or comm line. Opposite of {snarf}. Usage:

uncommon. The variant `blat' has been reported. 2. vt.

[HP/Apollo] Synonymous with {nuke} (sense 3). Sometimes the

message `Unable to kill all processes. Blast them (y/n)?' would

appear in the command window upon logout.

:blat: n. 1. Syn. {blast}, sense 1. 2. See {thud}.

:bletch: /blech/ [from Yiddish/German `brechen', to vomit, poss.

via comic-strip exclamation `blech'] interj. Term of disgust.

Often used in "Ugh, bletch". Compare {barf}.

:bletcherous: /blech'*-r*s/ adj. Disgusting in design or function;

esthetically unappealing. This word is seldom used of people.

"This keyboard is bletcherous!" (Perhaps the keys don't work very

well, or are misplaced.) See {losing}, {cretinous},

{bagbiter}, {bogus}, and {random}. The term {bletcherous}

applies to the esthetics of the thing so described; similarly for

{cretinous}. By contrast, something that is `losing' or

`bagbiting' may be failing to meet objective criteria. See also

{bogus} and {random}, which have richer and wider shades of

meaning than any of the above.

:blinkenlights: /blink'*n-li:tz/ n. Front-panel diagnostic lights

on a computer, esp. a {dinosaur}. Derives from the last word

of the famous blackletter-Gothic sign in mangled pseudo-German that

once graced about half the computer rooms in the English-speaking

world. One version ran in its entirety as follows:

ACHTUNG! ALLES LOOKENSPEEPERS! Das

computermachine ist nicht fuer gefingerpoken und mittengrabben.

Ist easy schnappen der springenwerk, blowenfusen und poppencorken

mit spitzensparken. Ist nicht fuer gewerken bei das dumpkopfen.

Das rubbernecken sichtseeren keepen das cotten-pickenen hans in das

pockets muss; relaxen und watchen das blinkenlichten.

This silliness dates back at least as far as 1959 at Stanford

University and had already gone international by the early 1960s,

when it was reported at London University's ATLAS computing site.

There are several variants of it in circulation, some of which

actually do end with the word `blinkenlights'.

In an amusing example of turnabout-is-fair-play, German hackers

have developed their own versions of the blinkenlights poster in

fractured English, one of which is reproduced here:

ATTENTION

This room is fullfilled mit special electronische equippment.

Fingergrabbing and pressing the cnoeppkes from the computers is

allowed for die experts only! So all the "lefthanders" stay away

and do not disturben the brainstorming von here working

intelligencies. Otherwise you will be out thrown and kicked

anderswhere! Also: please keep still and only watchen astaunished

the blinkenlights.

See also {dickless workstation}.

:breedle: n. See {feep}.

:bring X to its knees: v. To present a machine, operating system,

piece of software, or algorithm with a load so extreme or

{pathological} that it grinds to a halt. "To bring a MicroVAX

to its knees, try twenty users running {vi} --- or four running

{EMACS}." Compare {hog}.

:brittle: adj. Said of software that is functional but easily broken

by changes in operating environment or configuration, or by any

minor tweak to the software itself. Also, any system that

responds inappropriately and disastrously to expected external

stimuli; e.g., a file system that is usually totally scrambled by a

power failure is said to be brittle. This term is often used to

describe the results of a research effort that were never intended

to be robust, but it can be applied to commercially developed

software, which displays the quality far more often than it ought

to. Oppose {robust}.

:broadcast storm: n. An incorrect packet broadcast on a network that

causes most hosts to respond all at once, typically with wrong

answers that start the process over again. See {network

meltdown}.

:broken: adj. 1. Not working properly (of programs). 2. Behaving

strangely; especially (when used of people) exhibiting extreme

depression.

:broken arrow: [IBM] n. The error code displayed on line 25 of a

3270 terminal (or a PC emulating a 3270) for various kinds of

protocol violations and "unexpected" error conditions (including

connection to a {down} computer). On a PC, simulated with

`->/_', with the two center characters overstruck. In true

{luser} fashion, the original documentation of these codes

(visible on every 3270 terminal, and necessary for debugging

network problems) was confined to an IBM customer engineering

manual.

Note: to appreciate this term fully, it helps to know that `broken

arrow' is also military jargon for an accident involving nuclear

weapons....

:broket: /broh'k*t/ or /broh'ket`/ [by analogy with `bracket': a

`broken bracket'] n. Either of the characters `<' and `>',

when used as paired enclosing delimiters. This word

originated as a contraction of the phrase `broken bracket', that

is, a bracket that is bent in the middle. (At MIT, and apparently

in the {Real World} as well, these are usually called {angle

brackets}.)

:Brooks's Law: prov. "Adding manpower to a late software project

makes it later" --- a result of the fact that the advantage from

splitting work among N programmers is O(N) (that is,

proportional to N), but the complexity and communications

cost associated with coordinating and then merging their work

is O(N^2) (that is, proportional to the square of N).

The quote is from Fred Brooks, a manager of IBM's OS/360 project

and author of `The Mythical Man-Month' (Addison-Wesley, 1975,

ISBN 0-201-00650-2), an excellent early book on software

engineering. The myth in question has been most tersely expressed

as "Programmer time is fungible" and Brooks established

conclusively that it is not. Hackers have never forgotten his

advice; too often, {management} does. See also

{creationism}, {second-system effect}.

:BRS: /B-R-S/ n. Syn. {Big Red Switch}. This abbreviation is

fairly common on-line.

:brute force: adj. Describes a primitive programming style, one in

which the programmer relies on the computer's processing power

instead of using his or her own intelligence to simplify the

problem, often ignoring problems of scale and applying na"ive

methods suited to small problems directly to large ones.

The {canonical} example of a brute-force algorithm is associated

with the `traveling salesman problem' (TSP), a classical {NP-}hard

problem: Suppose a person is in, say, Boston, and wishes to drive

to N other cities. In what order should he or she visit

them in order to minimize the distance travelled? The brute-force

method is to simply generate all possible routes and compare the

distances; while guaranteed to work and simple to implement, this

algorithm is clearly very stupid in that it considers even

obviously absurd routes (like going from Boston to Houston via San

Francisco and New York, in that order). For very small N it

works well, but it rapidly becomes absurdly inefficient when

N increases (for N = 15, there are already

1,307,674,368,000 possible routes to consider, and for

N = 1000 --- well, see {bignum}). See

also {NP-}.

A more simple-minded example of brute-force programming is finding

the smallest number in a large list by first using an existing

program to sort the list in ascending order, and then picking the

first number off the front.

Whether brute-force programming should be considered stupid or not

depends on the context; if the problem isn't too big, the extra CPU

time spent on a brute-force solution may cost less than the

programmer time it would take to develop a more `intelligent'

algorithm. Additionally, a more intelligent algorithm may imply

more long-term complexity cost and bug-chasing than are justified

by the speed improvement.

Ken Thompson, co-inventor of UNIX, is reported to have uttered the

epigram "When in doubt, use brute force". He probably intended

this as a {ha ha only serious}, but the original UNIX kernel's

preference for simple, robust, and portable algorithms over

{brittle} `smart' ones does seem to have been a significant

factor in the success of that OS. Like so many other tradeoffs in

software design, the choice between brute force and complex,

finely-tuned cleverness is often a difficult one that requires both

engineering savvy and delicate esthetic judgment.

:brute force and ignorance: n. A popular design technique at many

software houses --- {brute force} coding unrelieved by any

knowledge of how problems have been previously solved in elegant

ways. Dogmatic adherence to design methodologies tends to

encourage it. Characteristic of early {larval stage}

programming; unfortunately, many never outgrow it. Often

abbreviated BFI: "Gak, they used a bubble sort! That's strictly

from BFI." Compare {bogosity}.

:BSD: /B-S-D/ n. [abbreviation for `Berkeley System Distribution'] a

family of {{UNIX}} versions for the DEC {VAX} and PDP-11

developed by Bill Joy and others at {Berzerkeley} starting

around 1980, incorporating paged virtual memory, TCP/IP networking

enhancements, and many other features. The BSD versions (4.1, 4.2,

and 4.3) and the commercial versions derived from them (SunOS,

ULTRIX, and Mt. Xinu) held the technical lead in the UNIX world

until AT&T's successful standardization efforts after about 1986,

and are still widely popular. See {{UNIX}}, {USG UNIX}.

:BUAF: // [abbreviation, from the alt.fan.warlord] n. Big

Ugly ASCII Font --- a special form of {ASCII art}. Various

programs exist for rendering text strings into block, bloob, and

pseudo-script fonts in cells between four and six character cells

on a side; this is smaller than the letters generated by older

{banner} (sense 2) programs. These are sometimes used to render

one's name in a {sig block}, and are critically referred to as

`BUAF's. See {warlording}.

:BUAG: // [abbreviation, from the alt.fan.warlord] n. Big

Ugly ASCII Graphic. Pejorative term for ugly {ASCII ART},

especially as found in {sig block}s. For some reason, mutations

of the head of Bart Simpson are particularly common in the least

imaginative {sig block}s. See {warlording}.

:bubble sort: n. Techspeak for a particular sorting technique in

which pairs of adjacent values in the list to be sorted are

compared and interchanged if they are out of order; thus, list

entries `bubble upward' in the list until they bump into one with a

lower sort value. Because it is not very good relative to other

methods and is the one typically stumbled on by {na"ive} and

untutored programmers, hackers consider it the {canonical}

example of a na"ive algorithm. The canonical example of a really

*bad* algorithm is {bogo-sort}. A bubble sort might be used

out of ignorance, but any use of bogo-sort could issue only from

brain damage or willful perversity.

:bucky bits: /buh'kee bits/ n. 1. obs. The bits produced by the

CONTROL and META shift keys on a SAIL keyboard (octal 200 and 400

respectively), resulting in a 9-bit keyboard character set. The

MIT AI TV (Knight) keyboards extended this with TOP and separate

left and right CONTROL and META keys, resulting in a 12-bit

character set; later, LISP Machines added such keys as SUPER,

HYPER, and GREEK (see {space-cadet keyboard}). 2. By extension,

bits associated with `extra' shift keys on any keyboard, e.g.,

the ALT on an IBM PC or command and option keys on a Macintosh.

It is rumored that `bucky bits' were named for Buckminster Fuller

during a period when he was consulting at Stanford. Actually,

`Bucky' was Niklaus Wirth's nickname when *he* was at

Stanford; he first suggested the idea of an EDIT key to set the

8th bit of an otherwise 7-bit ASCII character. This was used in a

number of editors written at Stanford or in its environs (TV-EDIT

and NLS being the best-known). The term spread to MIT and CMU

early and is now in general use. See {double bucky},

{quadruple bucky}.

:buffer overflow: n. What happens when you try to stuff more data

into a buffer (holding area) than it can handle. This may be due

to a mismatch in the processing rates of the producing and

consuming processes (see {overrun} and {firehose syndrome}),

or because the buffer is simply too small to hold all the data that

must accumulate before a piece of it can be processed. For example,

in a text-processing tool that {crunch}es a line at a time, a

short line buffer can result in {lossage} as input from a long

line overflows the buffer and trashes data beyond it. Good

defensive programming would check for overflow on each character

and stop accepting data when the buffer is full up. The term is

used of and by humans in a metaphorical sense. "What time did I

agree to meet you? My buffer must have overflowed." Or "If I

answer that phone my buffer is going to overflow." See also

{spam}, {overrun screw}.

:bug: n. An unwanted and unintended property of a program or piece

of hardware, esp. one that causes it to malfunction. Antonym of

{feature}. Examples: "There's a bug in the editor: it writes

things out backwards." "The system crashed because of a hardware

bug." "Fred is a winner, but he has a few bugs" (i.e., Fred is

a good guy, but he has a few personality problems).

Historical note: Some have said this term came from telephone

company usage, in which "bugs in a telephone cable" were blamed

for noisy lines, but this appears to be an incorrect folk

etymology. Admiral Grace Hopper (an early computing pioneer better

known for inventing {COBOL}) liked to tell a story in which a

technician solved a persistent {glitch} in the Harvard Mark II

machine by pulling an actual insect out from between the contacts

of one of its relays, and she subsequently promulgated {bug} in

its hackish sense as a joke about the incident (though, as she was

careful to admit, she was not there when it happened). For many

years the logbook associated with the incident and the actual bug

in question (a moth) sat in a display case at the Naval Surface

Warfare Center. The entire story, with a picture of the logbook

and the moth taped into it, is recorded in the `Annals of the

History of Computing', Vol. 3, No. 3 (July 1981), pp. 285--286.

The text of the log entry (from September 9, 1945), reads "1545

Relay #70 Panel F (moth) in relay. First actual case of bug being

found". This wording seems to establish that the term was already

in use at the time in its current specific sense --- and Hopper

herself reports that the term `bug' was regularly applied to

problems in radar electronics during WWII. Indeed, the use of

`bug' to mean an industrial defect was already established in

Thomas Edison's time, and `bug' in the sense of an disruptive

event goes back to Shakespeare! In the first edition of Samuel

Johnson's dictionary one meaning of `bug' is "A frightful

object; a walking spectre"; this is traced to `bugbear', a Welsh

term for a variety of mythological monster which (to complete the

circle) has recently been reintroduced into the popular lexicon

through fantasy role-playing games.

In any case, in jargon the word almost never refers to insects.

Here is a plausible conversation that never actually happened:

"There is a bug in this ant farm!"

"What do you mean? I don't see any ants in it."

"That's the bug."

[There has been a widespread myth that the original bug was moved

to the Smithsonian, and an earlier version of this entry so

asserted. A correspondent who thought to check discovered that the

bug was not there. While investigating this in late 1990, your

editor discovered that the NSWC still had the bug, but had

unsuccessfully tried to get the Smithsonian to accept it --- and

that the present curator of their History of American Technology

Museum didn't know this and agreed that it would make a worthwhile

exhibit. It was moved to the Smithsonian in mid-1991. Thus, the

process of investigating the original-computer-bug bug fixed it in

an entirely unexpected way, by making the myth true! --- ESR]

[1992 update: the plot thickens! A usually reliable source reports

having seen The Bug at the Smithsonian in 1978. I am unable to

reconcile the conflicting histories I have been offered, and merely

report this fact here. --- ESR.]

:bug-compatible: adj. Said of a design or revision that has been

badly compromised by a requirement to be compatible with

{fossil}s or {misfeature}s in other programs or (esp.)

previous releases of itself. "MS-DOS 2.0 used \ as a path

separator to be bug-compatible with some cretin's choice of / as an

option character in 1.0."

:bug-for-bug compatible: n. Same as {bug-compatible}, with the

additional implication that much tedious effort went into ensuring

that each (known) bug was replicated.

:buglix: /buhg'liks/ n. Pejorative term referring to DEC's ULTRIX

operating system in its earlier *severely* buggy versions.

Still used to describe ULTRIX, but without venom. Compare

{AIDX}, {HP-SUX}, {Nominal Semidestructor}, {Telerat},

{sun-stools}.

:bulletproof: adj. Used of an algorithm or implementation considered

extremely {robust}; lossage-resistant; capable of correctly

recovering from any imaginable exception condition. This is a rare

and valued quality. Syn. {armor-plated}.

:bum: 1. vt. To make highly efficient, either in time or space,

often at the expense of clarity. "I managed to bum three more

instructions out of that code." "I spent half the night bumming

the interrupt code." In {elder days}, John McCarthy (inventor

of {LISP}) used to compare some efficiency-obsessed hackers

among his students to "ski bums"; thus, optimization became

"program bumming", and eventually just "bumming". 2. To

squeeze out excess; to remove something in order to improve

whatever it was removed from (without changing function; this

distinguishes the process from a {featurectomy}). 3. n. A small

change to an algorithm, program, or hardware device to make it more

efficient. "This hardware bum makes the jump instruction

faster." Usage: now uncommon, largely superseded by v. {tune}

(and n. {tweak}, {hack}), though none of these exactly

capture sense 2. All these uses are rare in Commonwealth hackish,

because in the parent dialects of English `bum' is a rude synonym

for `buttocks'.

:bump: vt. Synonym for increment. Has the same meaning as

C's ++ operator. Used esp. of counter variables, pointers, and

index dummies in `for', `while', and `do-while'

loops.

:burble: [from Lewis Carroll's "Jabberwocky"] v. Like {flame},

but connotes that the source is truly clueless and ineffectual

(mere flamers can be competent). A term of deep contempt.

"There's some guy on the phone burbling about how he got a DISK

FULL error and it's all our comm software's fault."

:buried treasure: n. A surprising piece of code found in some

program. While usually not wrong, it tends to vary from {crufty}

to {bletcherous}, and has lain undiscovered only because it was

functionally correct, however horrible it is. Used sarcastically,

because what is found is anything *but* treasure. Buried

treasure almost always needs to be dug up and removed. "I just

found that the scheduler sorts its queue using {bubble sort}!

Buried treasure!"

:burn-in period: n. 1. A factory test designed to catch systems

with {marginal} components before they get out the door; the

theory is that burn-in will protect customers by outwaiting the

steepest part of the {bathtub curve} (see {infant

mortality}). 2. A period of indeterminate length in which a person

using a computer is so intensely involved in his project that he

forgets basic needs such as food, drink, sleep, etc. Warning:

Excessive burn-in can lead to burn-out. See {hack mode},

{larval stage}.

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

:busy-wait: vi. Used of human behavior, conveys that the subject is

busy waiting for someone or something, intends to move instantly as

soon as it shows up, and thus cannot do anything else at the

moment. "Can't talk now, I'm busy-waiting till Bill gets off the

phone."

Technically, `busy-wait' means to wait on an event by

{spin}ning through a tight or timed-delay loop that polls for

the event on each pass, as opposed to setting up an interrupt

handler and continuing execution on another part of the task. This

is a wasteful technique, best avoided on time-sharing systems where

a busy-waiting program may {hog} the processor.

:buzz: vi. 1. Of a program, to run with no indication of progress

and perhaps without guarantee of ever finishing; esp. said of

programs thought to be executing tight loops of code. A program

that is buzzing appears to be {catatonic}, but you never get out

of catatonia, while a buzzing loop may eventually end of its own

accord. "The program buzzes for about 10 seconds trying to sort

all the names into order." See {spin}; see also {grovel}.

2. [ETA Systems] To test a wire or printed circuit trace for

continuity by applying an AC rather than DC signal. Some wire

faults will pass DC tests but fail a buzz test. 3. To process an

array or list in sequence, doing the same thing to each element.

"This loop buzzes through the tz array looking for a terminator

type."

:BWQ: /B-W-Q/ [IBM: abbreviation, `Buzz Word Quotient'] The

percentage of buzzwords in a speech or documents. Usually roughly

proportional to {bogosity}. See {TLA}.

:by hand: adv. Said of an operation (especially a repetitive,

trivial, and/or tedious one) that ought to be performed

automatically by the computer, but which a hacker instead has to

step tediously through. "My mailer doesn't have a command to

include the text of the message I'm replying to, so I have to do it

by hand." This does not necessarily mean the speaker has to

retype a copy of the message; it might refer to, say, dropping into

a {subshell} from the mailer, making a copy of one's mailbox file,

reading that into an editor, locating the top and bottom of the

message in question, deleting the rest of the file, inserting `>'

characters on each line, writing the file, leaving the editor,

returning to the mailer, reading the file in, and later remembering

to delete the file. Compare {eyeball search}.

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

:bit twiddling: n. 1. (pejorative) An exercise in tuning (see