The Jargon File, Eric S. Raymond [speld decodable readers txt] 📗

NSWC still had the bug, but had unsuccessfully tried to get

the Smithsonian to accept it -- and that the present curator of their

History of American Technology Museum didn't know this and agreed that

it would make a worthwhile exhibit. It was moved to the Smithsonian in

mid-1991, but due to space and money constraints was not actually

exhibited years afterwards. Thus, the process of investigating the

original-computer-bug bug fixed it in an entirely unexpected way, by

making the myth true! --ESR]

Node:bug-compatible, Next:[2087]bug-for-bug compatible,

Previous:[2088]bug, Up:[2089]= B =

bug-compatible adj.

[common] Said of a design or revision that has been badly compromised

by a requirement to be compatible with [2090]fossils or

[2091]misfeatures in other programs or (esp.) previous releases of

itself. "MS-DOS 2.0 used as a path separator to be bug-compatible

with some cretin's choice of / as an option character in 1.0."

Node:bug-for-bug compatible, Next:[2092]bug-of-the-month club,

Previous:[2093]bug-compatible, Up:[2094]= B =

bug-for-bug compatible n.

Same as [2095]bug-compatible, with the additional implication that

much tedious effort went into ensuring that each (known) bug was

replicated.

Node:bug-of-the-month club, Next:[2096]buglix,

Previous:[2097]bug-for-bug compatible, Up:[2098]= B =

bug-of-the-month club n.

[from "book-of-the-month club", a time-honored mail-order-marketing

technique in the U.S.] A mythical club which users of `sendmail(8)'

(the UNIX mail daemon) belong to; this was coined on the Usenet

newsgroup comp.security.unix at a time when sendmail security holes,

which allowed outside [2099]crackers access to the system, were being

uncovered at an alarming rate, forcing sysadmins to update very often.

Also, more completely, `fatal security bug-of-the-month club'. See

also [2100]kernel-of-the-week club.

Node:buglix, Next:[2101]bulletproof, Previous:[2102]bug-of-the-month

club, Up:[2103]= B =

buglix /buhg'liks/ n.

[uncommon] Pejorative term referring to [2104]DEC's ULTRIX operating

system in its earlier severely buggy versions. Still used to describe

ULTRIX, but without nearly so much venom. Compare [2105]AIDX,

[2106]HP-SUX, [2107]Nominal Semidestructor, [2108]Telerat,

[2109]sun-stools.

Node:bulletproof, Next:[2110]bullschildt, Previous:[2111]buglix,

Up:[2112]= B =

bulletproof adj.

Used of an algorithm or implementation considered extremely

[2113]robust; lossage-resistant; capable of correctly recovering from

any imaginable exception condition -- a rare and valued quality.

Implies that the programmer has thought of all possible errors, and

added [2114]code to protect against each one. Thus, in some cases,

this can imply code that is too heavyweight, due to excessive paranoia

on the part of the programmer. Syn. [2115]armor-plated.

Node:bullschildt, Next:[2116]bum, Previous:[2117]bulletproof,

Up:[2118]= B =

bullschildt /bul'shilt/ n.

[comp.lang.c on USENET] A confident, but incorrect, statement about a

programming language. This immortalizes a very bad book about [2119]C,

Herbert Schildt's "C - The Complete Reference". One reviewer commented

"The naive errors in this book would be embarassing even in a

programming assignment turned in by a computer science college

sophomore."

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

bum

vt. To make highly efficient, either in time or space, often at the

expense of clarity. "I managed to bum three more instructions out of

that code." "I spent half the night bumming the interrupt code." In

1996, this term and the practice it describes are semi-obsolete. In

[2123]elder days, John McCarthy (inventor of [2124]LISP) used to

compare some efficiency-obsessed hackers among his students to "ski

bums"; thus, optimization became "program bumming", and eventually

just "bumming". 2. To squeeze out excess; to remove something in order

to improve whatever it was removed from (without changing function;

this distinguishes the process from a [2125]featurectomy). 3. n. A

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

more efficient. "This hardware bum makes the jump instruction faster."

Usage: now uncommon, largely superseded by v. [2126]tune (and n.

[2127]tweak, [2128]hack), though none of these exactly capture sense

All these uses are rare in Commonwealth hackish, because in the

parent dialects of English the noun `bum' is a rude synonym for

buttocks' and the verbbum' for buggery.

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

bump vt.

Synonym for increment. Has the same meaning as C's ++ operator. Used

esp. of counter variables, pointers, and index dummies in for, while,

and do-while loops.

Node:burble, Next:[2132]buried treasure, Previous:[2133]bump,

Up:[2134]= B =

burble v.

[from Lewis Carroll's "Jabberwocky"] Like [2135]flame, but connotes

that the source is truly clueless and ineffectual (mere flamers can be

competent). A term of deep contempt. "There's some guy on the phone

burbling about how he got a DISK FULL error and it's all our comm

software's fault." This is mainstream slang in some parts of England.

Node:buried treasure, Next:[2136]burn-in period,

Previous:[2137]burble, Up:[2138]= B =

buried treasure n.

A surprising piece of code found in some program. While usually not

wrong, it tends to vary from [2139]crufty to [2140]bletcherous, and

has lain undiscovered only because it was functionally correct,

however horrible it is. Used sarcastically, because what is found is

anything but treasure. Buried treasure almost always needs to be dug

up and removed. "I just found that the scheduler sorts its queue using

[2141]bubble sort! Buried treasure!"

Node:burn-in period, Next:[2142]burst page, Previous:[2143]buried

treasure, Up:[2144]= B =

burn-in period n.

A factory test designed to catch systems with [2145]marginal

components before they get out the door; the theory is that burn-in

will protect customers by outwaiting the steepest part of the

[2146]bathtub curve (see [2147]infant mortality). 2. A period of

indeterminate length in which a person using a computer is so

intensely involved in his project that he forgets basic needs such as

food, drink, sleep, etc. Warning: Excessive burn-in can lead to

burn-out. See [2148]hack mode, [2149]larval stage.

Historical note: the origin of "burn-in" (sense 1) is apparently the

practice of setting a new-model airplane's brakes on fire, then

extinguishing the fire, in order to make them hold better. This was

done on the first version of the U.S. spy-plane, the U-2.

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

Up:[2152]= B =

burst page n.

Syn. [2153]banner, sense 1.

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

B =

busy-wait vi.

Used of human behavior, conveys that the subject is busy waiting for

someone or something, intends to move instantly as soon as it shows

up, and thus cannot do anything else at the moment. "Can't talk now,

I'm busy-waiting till Bill gets off the phone."

Technically, `busy-wait' means to wait on an event by [2157]spinning

through a tight or timed-delay loop that polls for the event on each

pass, as opposed to setting up an interrupt handler and continuing

execution on another part of the task. In applications this is a

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

busy-waiting program may [2158]hog the processor. However, it is often

unavoidable in kernel programming. In the Linux world, kernel

busy-waits are usually referred to as `spinlocks'.

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

buzz vi.

Of a program, to run with no indication of progress and perhaps

without guarantee of ever finishing; esp. said of programs thought to

be executing tight loops of code. A program that is buzzing appears to

be [2162]catatonic, but never gets out of catatonia, while a buzzing

loop may eventually end of its own accord. "The program buzzes for

about 10 seconds trying to sort all the names into order." See

[2163]spin; see also [2164]grovel. 2. [ETA Systems] To test a wire or

printed circuit trace for continuity, esp. by applying an AC rather

than DC signal. Some wire faults will pass DC tests but fail an AC

buzz test. 3. To process an array or list in sequence, doing the same

thing to each element. "This loop buzzes through the tz array looking

for a terminator type."

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

BWQ /B-W-Q/ n.

[IBM: abbreviation, `Buzz Word Quotient'] The percentage of buzzwords

in a speech or documents. Usually roughly proportional to

[2168]bogosity. See [2169]TLA.

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

by hand adv.

[common] 1. Said of an operation (especially a repetitive, trivial,

and/or tedious one) that ought to be performed automatically by the

computer, but which a hacker instead has to step tediously through.

"My mailer doesn't have a command to include the text of the message

I'm replying to, so I have to do it by hand." This does not

necessarily mean the speaker has to retype a copy of the message; it

might refer to, say, dropping into a subshell from the mailer, making

a copy of one's mailbox file, reading that into an editor, locating

the top and bottom of the message in question, deleting the rest of

the file, inserting `>' characters on each line, writing the file,

leaving the editor, returning to the mailer, reading the file in, and

later remembering to delete the file. Compare [2173]eyeball search. 2.

By extension, writing code which does something in an explicit or

low-level way for which a presupplied library routine ought to have

been available. "This cretinous B-tree library doesn't supply a decent

iterator, so I'm having to walk the trees by hand."

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

byte /bi:t/ n.

[techspeak] A unit of memory or data equal to the amount used to

represent one character; on modern architectures this is usually 8

bits, but may be 9 on 36-bit machines. Some older architectures used

byte' for quantities of 6 or 7 bits, and the PDP-10 supportedbytes'

that were actually bitfields of 1 to 36 bits! These usages are now

obsolete, and even 9-bit bytes have become rare in the general trend

toward power-of-2 word sizes.

Historical note: The term was coined by Werner Buchholz in 1956 during

the early design phase for the IBM Stretch computer; originally it was

described as 1 to 6 bits (typical I/O equipment of the period used

6-bit chunks of information). The move to an 8-bit byte happened in

late 1956, and this size was later adopted and promulgated as a

standard by the System/360. The word was coined by mutating the word

`bite' so it would not be accidentally misspelled as [2177]bit. See

also [2178]nybble.

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

B =

byte sex n.

[common] The byte sex of hardware is [2182]big-endian or

[2183]little-endian; see those entries.

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

Up:[2186]= B =

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

[rare] Said of hardware, denotes willingness to compute or pass data

in either [2187]big-endian or [2188]little-endian format (depending,

presumably, on a [2189]mode bit somewhere). See also [2190]NUXI

problem.

Node:Bzzzt! Wrong., Next:[2191]C, Previous:[2192]bytesexual,

Up:[2193]= B =

Bzzzt! Wrong. /bzt rong/ excl.

[common; Usenet/Internet; punctuation varies] From a Robin Williams

routine in the movie "Dead Poets Society" spoofing radio or TV quiz

programs, such as Truth or Consequences, where an incorrect answer

earns one a blast from the buzzer and condolences from the

interlocutor. A way of expressing mock-rude disagreement, usually

immediately following an included quote from another poster. The less

abbreviated "Bzzzzt, wrong, but thank you for playing" is also

common; capitalization and emphasis of the buzzer sound varies.

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

Jargon Lexicon

= C =

[2197]C:

[2198]C Programmer's Disease:

[2199]C&C:

[2200]C++:

[2201]calculator:

[2202]Camel Book:

[2203]can:

[2204]can't happen:

[2205]cancelbot:

[2206]Cancelmoose[tm]:

[2207]candygrammar:

[2208]canonical:

[2209]card walloper:

[2210]careware:

[2211]cargo cult programming:

[2212]cascade:

[2213]case and paste:

[2214]casters-up mode:

[2215]casting the runes:

[2216]cat:

[2217]catatonic:

[2218]cathedral:

[2219]cd tilde:

[2220]CDA:

[2221]cdr:

[2222]chad:

[2223]chad box:

[2224]chain:

[2225]channel:

[2226]channel hopping:

[2227]channel op:

[2228]chanop:

[2229]char:

[2230]charityware:

[2231]chase pointers:

[2232]chawmp:

[2233]check:

[2234]cheerfully:

[2235]chemist:

[2236]Chernobyl chicken:

[2237]Chernobyl packet:

[2238]chicken head:

[2239]chiclet keyboard:

[2240]Chinese Army technique:

[2241]choad:

[2242]choke:

[2243]chomp:

[2244]chomper:

[2245]CHOP:

[2246]Christmas tree:

[2247]Christmas tree packet:

[2248]chrome:

[2249]chug:

[2250]Church of the SubGenius:

[2251]Cinderella Book:

[2252]CI$:

[2253]Classic C:

[2254]clean:

[2255]CLM:

[2256]clobber:

[2257]clock:

[2258]clocks:

[2259]clone:

[2260]clone-and-hack coding:

[2261]clover key:

[2262]clue-by-four:

[2263]clustergeeking:

[2264]co-lo:

[2265]code:

[2266]coaster: