Jargon file v2.1.5 28 NOV 1990 -- part 1 of 6

Eric S. Raymond eric at snark.thyrsus.com
Thu Nov 29 04:56:59 AEST 1990


========= THIS IS THE JARGON FILE, VERSION 2.1.5 28 NOV 1990  =================
  
INTRODUCTION
   This `jargon file' is a collection of slang terms used by various
subcultures of computer hackers. 

   The original `jargon file' was a collection of hacker slang from
technical cultures including 1) the MIT AI Lab, 2) the Stanford
AI lab, 3) the old ARPANET AI/LISP/PDP-10 communities, 3) Carnegie-
Mellon University, 4) Worcester Polytechnic Institute. Some entries
dated back to the early 1970s. This version was published as _The_
Hacker's_Dictionary_ in 1983.

   This new version casts a wider net than the old jargon file;
its aim is to cover not just AI but all the technical computing
cultures wherein the true hacker-nature is manifested. More than
half of the entries now derive from USENET and the C and UNIX
communities.

    The present maintainers of the jargon file are Guy L. Steele
(gls at think.com) and Eric S. Raymond (eric at snark.thyrsus.com). Send
all additions, corrections and correspondence relating to the
jargon file to jargon at think.com.


CREDITS
   The original jargon file was compiled by Guy L. Steele Jr., Raphael
Finkel, Don Woods, and Mark Crispin, with assistance from the MIT and
Stanford AI communities and Worcester Polytechnic Institute.
Some contributions were submitted via the ARPAnet from miscellaneous
sites. The `old' jargon file was last revised in 1983; its revisions
are all un-numbered and may be collectively considered `Version 1'.

   Version 2.1: the jargon file reorganization and massive additions
were by Eric S. Raymond, approved by Guy Steele. Many items of UNIX,
C, USENET and microcomputer-based slang were added at that time (as
well as Appendix A, The Untimely Demise of Mabel The Monkey). Some
obsolescent usages (mostly PDP-10 derived) were moved to appendix B.
The bibliography (Appendix C) was also consed on.

   Our thanks to all the USENETters who contributed entries and
encouragement. Special thanks to our Scandinavian correspondent Per
Lindberg (per at front.se), author of the remarkable Swedish language
'zine _Hackerbladet_, for bring FOO! comics to our attention and
smuggling the IBM hacker underground's own baby jargon file out to
us. Also, much gratitude to ace hacker/linguist Joe Keane
(jkg at osc.osc.com) for helping us improve the pronunciation guides; and
to Maarten Litmath for generously allowing the inclusion of the
ASCII prononunciation guide he maintains. 

FORMAT FOR NEW ENTRIES
   Try to conform to the format already being used -- 70 character
lines, 3-character indentations, pronunciations in parentheses,
etymologies in brackets, single-space after def'n numbers and word
classes, etc. Stick to the standard ASCII character set.

   We are looking to expand the file's range of technical specialties
covered. There are doubtless rich veins of jargon yet untapped in the
scientific computing, graphics, and networking hacker communities;
also in numerical analysis, computer architectures and VLSI design,
language design, and many other related fields. Send us your slang!

   We are *not* interested in straight technical terms explained by
textbooks or technical dictionaries unless an entry illuminates
``underground'' meanings or aspects not covered by official histories.
We are also not interested in ``joke'' entries -- there is a lot of
humor in the file but it must flow naturally out of the explanations
of what hackers do and how they think.

   It is OK to submit items of slang you have originated if they
have spread to the point of being used by people who are not
personally acquainted with you. We prefer items to be attested by
independent submission from two different sites.

   The slang file will be regularly maintained and re-posted from
now on and will include a version number. Read it, pass it around,
contribute -- this is *your* monument!

NOTES ON JARGON CONSTRUCTION
   There are some standard methods of jargonification which became
established quite early (i.e before 1970), spreading from such sources
as the MIT Model Railroad Club, the PDP-1 SPACEWAR hackers and John
McCarthy's original crew of LISPers. These include:

Verb doubling: a standard construction is to double a verb and use it
   as a comment on what the implied subject does.  Often used to
   terminate a conversation.  Typical examples involve WIN, LOSE,
   HACK, FLAME, BARF, CHOMP:
	``The disk heads just crashed.''  ``Lose, lose.''
	``Mostly he just talked about his @#!!$% crock.  Flame, flame.''
	``Boy, what a bagbiter!  Chomp, chomp!''

Soundalike slang: similar to Cockney rhyming slang.  Often made up on
   the spur of the moment.  Standard examples:
	Boston Globe => Boston Glob
	Herald American => Horrid (Harried) American
	New York Times => New York Slime
	Prime Time => Slime Time
	government property - do not duplicate (seen on keys)
		=> government duplicity - do not propagate
   Often the substitution will be made in such a way as to slip in
   a standard jargon word:
	Dr. Dobb's Journal => Dr. Frob's Journal
	Margaret Jacks Hall => Marginal Hacks Hall
	Data General => Dirty Genitals

The -P convention: turning a word into a question by appending the
   syllable ``P''; from the LISP convention of appending the letter ``P''
   to denote a predicate (a Boolean-valued function).  The question
   should expect a yes/no answer, though it needn't.  (See T and NIL.)
     At dinnertime: ``Foodp?''  ``Yeah, I'm pretty hungry.'' or ``T!''
     ``State-of-the-world-P?''  (Straight) ``I'm about to go home.''
			      (Humorous) ``Yes, the world has a state.''
   [One of the best of these is a Gosperism (i.e., due to Bill
   Gosper).  When we were at a Chinese restaurant, he wanted to know
   whether someone would like to share with him a two-person-sized
   bowl of soup.  His inquiry was: ``Split-p soup?'' --GLS]

Peculiar nouns: MIT AI hackers love to take various words and add the
   wrong endings to them to make nouns and verbs, often by extending a
   standard rule to nonuniform cases.  Examples:
		porous => porosity
		generous => generosity
	Ergo:	mysterious => mysteriosity
		ferrous => ferrocity

	Other examples: winnitude, disgustitude, hackification. 
   
   Also, note that all nouns can be verbed.  eg: ``All nouns can be
   verbed'', ``I'll mouse it up'', ``Hang on while I clipboard it over'',
   ``I'm grepping the files''. English as a whole is already heading in
   this direction (towards pure-positional grammar like Chinese);
   hackers are simply a bit ahead of the curve.

Spoken inarticulations: Words such as ``mumble'', ``sigh'', and ``groan''
   are spoken in places where their referent might more naturally be
   used.  It has been suggested that this usage derives from the
   impossibility of representing such noises in a com link.  Another
   expression sometimes heard is ``complain!'', meaning ``I have a
   complaint!''

Hacker speech style: Features extremely precise diction, careful
   word choice, a relatively large working vocabulary, and relatively
   little use of contractions or ``street slang''. Dry humor, irony,
   puns, and a mildly flippant attitude are highly valued -- but an
   underlying seriousness and intelligence is essential. One should
   use just enough jargon to communicate precisely and identify
   oneself as ``in the culture''; overuse and a breathless, excessively
   gung-ho attitude are considered tacky and the mark of a loser.

This speech style (a variety of the precisionist English normally
spoken by scientists, design engineers, and academics in technical
fields) is fairly constant everywhere. Of the five listed
constructions, verb doubling,  peculiar noun formations, and
(especially!) spoken inarticulations  have become quite general; but
rhyming slang is still largely confined to MIT and other large
universities, and the P convention is found only where LISPers
flourish.

   One final note. Many words in hacker jargon have to be understood as
members of sets of comparatives. This is especially true of the adjectives
and nouns used to describe the beauty and functional quality of code. Here
is an approximately correct spectrum:

	MONSTROSITY BRAIN-DAMAGE  BUG  SCREW  LOSE  MISFEATURE
	CROCK  KLUGE  HACK  WIN  FEATURE  ELEGANCE PERFECTION

The last is never actually attained.

PRONUNCIATION GUIDE

   Pronunciation keys are provided in the jargon listing for all
entries which are neither dictionary words pronounced as in standard
English nor obvious compounds of same. These guides use the following
simple system:

   1) Syllables are hyphen-separated, except that an apostrophe
      or back-apostrophe follows each accented syllable (the
      back apostrophe marks a secondary accent in some words of
      four or more syllables).

   2) Consonants are pronounced as in American English. The letter
      ``g'' is always hard (as in ``got'' rather than ``giant'');
      ``ch'' is soft ("church'' rather than ``chemist"). The letter
      ``j'' is the sound that occurs twice in ``judge''. The letter
      ``s'' is always as in ``pass'', never a z sound (but it is
      sometimes doubled at the end of syllables to emphasize this).
      The digraph `dh' is the th of `these clothes', not of `thick'.

    3) Vowels are represented as follows:

	a	back, that
	ah	father, palm
	ar	far, mark
	aw	flaw, caught
	ay	bake, rain
	e	less, men
	ee	easy, ski
	eir	their, software
	i	trip, hit
	ie	life, sky
	o	cot, top
	oh	flow, sew
	oo	loot, through
	or	more, door
	ow	out, how
	oy	boy, coin
	uh	but, some
	u	put, foot
	y	yet
	yoo	few
	[y]oo	oo with optional fronting as in `news' (noos or nyoos)

An at-sign is used for the ``schwa'' sound of unstressed or occluded
vowels (the one that is often written with an upside-down ``e"). The
schwa vowel is omitted in syllables containing vocalic r, l, m or n;
that is, ``kitten'' and ``color'' would be rendered ``kit'n'' and
``kul'r''.

UNIX CONVENTIONS
   References such as `malloc(3)' and `patch(1)' are to UNIX
facilities (some of which, such as patch(1), are actually freeware
distributed over USENET). The UNIX manuals use `foo(n)' to refer to
item foo in section n) of the manual, where n=1 is utilities, n=2 is
system calls, n=3 is C library routines, n=4 is file formats, n=5 is
a miscellany, n=6 is games, n=7 is device drivers, and n=8 is system
administration tools.

THE JARGON ITSELF

		       =   =

@BEGIN [primarily CMU] with @End, used humorously in writing to
   indicate a context or to remark on the surrounded text.  From the
   SCRIBE command of the same name.  For example:
	@Begin(Flame)
	Predicate logic is the only good programming language.
	Anyone who would use anything else is an idiot.  Also,
	computers should be tredecimal instead of binary.
	@End(Flame)
   On USENET, this construct would more frequently be rendered as
   <FLAME ON> and <FLAME OFF>.

/DEV/NULL [from the UNIX null device, used as a data sink] n. A
   notional `black hole' in any information space being discussed,
   used or referred to. A controversial posting, for example, might
   end ``Kudos to rasputin at kremlin.org, flames to /dev/null/''. See
   BIT BUCKET.

			= A =

ABEND (ab'end) n. Abnormal termination (of software); crash; lossage.
   Derives from an error message on the IBM 360, but has passed into
   more general use, esp. at mainframe shops.

ACK (ak) interj. 1. [from the ASCII mnemonic for 000110] Acknowledge.
   Used to register one's presence (compare mainstream ``Yo!''). An
   appropriate response to PING. 2. [prob. from _Bloom_County_] An
   exclamation of surprised disgust, esp. in ``Oop ack!''.
   Semi-humorous. Also in the form ACK? meaning ``Are you there?'',
   often used in email when earlier mail has produced no reply, or
   during a lull in TALK MODE to see if the person has gone away (the
   standard humorous response is of course NAK, i.e. ``I'm not
   here'').

ADGER (adj'r) [UCLA] v. To make a bonehead move that could have been
   foreseen with a slight amount of mental effort. E.g., ``He started
   removing files and promptly adgered the whole project.''

AD-HOCKERY (ad-hok'@r-ee) [Purdue] n. Gratuitous assumptions made
   inside certain programs, esp. expert systems, which lead to the
   appearance of semi-intelligent behavior, but are in fact entirely
   arbitrary.

ADVENT (ad'vent) n. The prototypical computer adventure game, first
   implemented on the PDP-10 by Will Crowther as an attempt at
   computer-refereed fantasy gaming, and expanded into a
   puzzle-oriented game by Don Woods. Now better known as Adventure,
   but the TOPS-10 operating system only permitted 6-letter filenames.
   This game defined the terse, dryly humorous style now expected in
   text adventure games, and popularized several tag lines that have
   become fixtures of hacker-speak. ``A huge green fierce snake bars
   the way!''  ``I see no X here.'' (for X some noun). ``You are in a
   maze of twisty little passages, all alike''. The ``magic words''
   XYZZY and PLUGH also derive from this game. Crowther, by the way,
   participated in the exploration of the Mammoth/Flint Ridge cave
   system; it actually *has* a `Colossal Cave' and a `Bedquilt' as in
   the game, and the `Y2' that also turns up is cavers' jargon for a
   map reference to a secondary entrance.

ALIASING BUG [C programmers] n. A class of subtle programming errors
   which can arise in code that does dynamic allocation via malloc(3).
   If more than one pointer addresses (`aliases for') a given hunk of
   storage, it may happen that the storage is freed through one alias
   and then referenced through another, leading to subtle (and
   possibly intermittent) lossage depending on the state and the
   allocation history of the malloc ARENA. Avoidable by use of
   allocation strategies that never alias allocated core. Also called
   a STALE POINTER BUG. See also PRECEDENCE LOSSAGE, SMASH THE STACK,
   FANDANGO ON CORE, MEMORY LEAK, OVERRUN SCREW.

ALT BIT (ahlt bit) [from alternate?] adj. See META BIT.

ANGLE BRACKETS [primarily MIT] n. Either of the characters ``<'' and
   ``>''.  See BROKET.

APP (ap) n. Short for `application program', as opposed to a systems
   program. What systems vendors are forever chasing developers to do
   for their environments so they can sell more boxes. Hackers tend
   not to think of the things they themselves run as apps; thus, in
   hacker parlance the term excludes compilers, program editors,
   games, and messaging systems, though a user would consider all
   those apps. Oppose TOOL, OPERATING SYSTEM.

ARENA [UNIX] n. The area of memory attached to a process by brk(2) and
   sbrk(2) and used by malloc(3) as dynamic storage. So named from a
   semi-mythical ``malloc: corrupt arena'' message supposedly emitted
   when some early versions became terminally confused. See OVERRUN
   SCREW, ALIASING BUG, MEMORY LEAK, SMASH THE STACK.

ARG (arg) n. Abbreviation for ``argument'' (to a function), used so
   often as to have become a new word (like ``piano'' from
   ``pianoforte'').  ``The sine function takes one arg, but the
   arc-tangent function can take either one or two args''.  Compare
   PARAM, VAR.

ASBESTOS LONGJOHNS, UNDIES (uhn'dees), or OVERCOAT n. Metaphoric
   garments often donned by USENET posters just before emitting a
   remark they expect will elicit FLAMAGE.

ASCII (as'kee) Common slang names for ASCII characters are collected
   here. See individual entries for BANG, CLOSE, EXCL, OPEN, QUES,
   SEMI, SHRIEK, SPLAT, TWIDDLE, WHAT, WOW, and YIU-SHIANG WHOLE FISH.
   This list derives from revision 2.2 of the USENET ASCII
   pronunciation guide. Single characters are listed in ASCII order,
   character pairs are sorted in by first member. For each character,
   ``official'' names appear first, then others in order of popularity
   (more or less).

    !   exclamation point, exclamation, bang, factorial, excl, ball-bat,
        smash, shriek, cuss, wow, hey
    "   double quote, quote, dirk, literal mark, rabbit ears
    #   pound sign, number sign, sharp, crunch, mesh, hex, hash,
        flash, grid, pig-pen, tictactoe, scratchmark, octothorp (from
        Bell System)
    $   dollar sign, currency symbol, buck, cash, string (from BASIC),
        escape (from TOPS-10), ding, big-money
    %   percent sign, percent, mod, double-oh-seven
    &   ampersand, amper, and, address (from C), andpersand
    '   apostrophe, single quote, quote, prime, tick, irk, pop, spark
    ()  open/close parenthesis, left/right parenthesis, paren/thesis,
        lparen/rparen, parenthisey, unparenthisey, open/close round
        bracket, ears, so/already, wax/wane
    *   asterisk, star, splat, wildcard, gear, dingle, mult
    +   plus sign, plus, add, cross, intersection
    ,   comma, tail
    -   hyphen, dash, minus sign, worm
    .   period, dot, decimal point, radix point, point, full stop, spot
    /   virgule, slash, stroke, slant, diagonal, solidus, over, slat
    :   colon, two-spot
    ;   semicolon, semi, hybrid
    <>  angle brackets, brokets, left/right angle, less/greater than,
        read from/write to, from/into, from/toward, in/out, comesfrom/
        gozinta (all from UNIX), funnel, crunch/zap, suck/blow
    =   equal sign, equals, quadrathorp, gets, half-mesh
    ?   question mark, whatmark, what, wildchar, ques, huh, quark
    @   at sign, at, each, vortex, whorl, whirlpool, cyclone, snail,
        ape, cat
    V   vee, book
    []  square brackets, left/right bracket, bracket/unbracket, bra/ket,
        square/unsquare, U turns
    \   reversed virgule, backslash, bash, backslant, backwhack, backslat,
        escape (from UNIX)
    ^   circumflex, caret, uparrow, hat, chevron, sharkfin, to ("to
        the power of"), fang
    _   underscore, underline, underbar, under, score, backarrow, flatworm
    `   grave accent, grave, backquote, left quote, open quote, backprime,
        unapostrophe, backspark, birk, blugle, back tick, push
    {}  open/close brace, left/right brace, brace/unbrace, curly bracket,
        curly/uncurly, leftit/rytit, embrace/bracelet
    |   vertical bar, bar, or, v-bar, spike, pipe, gozinta, thru,
        pipesinta (last four from UNIX)
    ~   tilde, squiggle, approx, wiggle, twiddle, swung dash, enyay

ASSEMBLER 1. A program translator that allows human beings to generate
   machine code using mnemonics and symbolic names for memory
   locations rather than raw binary; distinguished from an HLL (q.v.)
   by the fact that a single assembler step generally maps to a single
   machine instruction (see also LANGUAGES OF CHOICE). 2.  A NANOBOT
   which is a physical REPLICATOR (This is the ``official'' term,
   coined by Eric Drexler; see NANOTECHNOLOGY).

AUTOMAGICALLY (aw-toh-maj'i-klee, aw-toh-maj'i-kl-ee) adv.
   Automatically, but in a way which, for some reason (typically
   because it is too complicated, or too ugly, or perhaps even too
   trivial), the speaker doesn't feel like explaining to you.  See
   MAGIC.  Example: The C-INTERCAL compiler generates C, then
   automagically invokes cc to produce an executable.

			= B =

BACKBONE CABAL n. Semi-mythical group of large-site administrators who
   pushed through the GREAT RENAMING and reined in the chaos of USENET
   during most of the 1980s. The cabal mailing list disbanded in late
   1988 after a bitter internal catfight, but the net hardly noticed.

BACK DOOR n. A hole in the security of a system deliberately left in
   place by designers or maintainers. The motivation for this is not
   always sinister; some operating systems, for example, come out of
   the box with privileged accounts intended for use by field service
   or the vendor's maintenance programmers. Historically, back doors
   have often lurked in systems longer than anyone expected or
   planned, and a few have become widely known. The famous RTM worm of
   late 1988, for example, used a back door in the BSD UNIX
   sendmail(1) utility. See also IRON BOX, CRACKER, WORM, LOGIC BOMB.

BACKGROUND v.,adj. A task running in background is detached from the
   terminal where it was started and running at a lower priority
   (oppose FOREGROUND). Nowadays this term is primarily associated
   with UNIX, but it was appears first to have been used in this sense
   on OS/360. By extension, to do a task ``in background'' is to do it
   whenever FOREGROUND matters are not claiming your undivided
   attention, and ``to background'' something means to relegate it to
   a lower priority. Compare SLOPSUCKER.

BAD THING n. Something which can't possibly result in improvement of
   the subject.  This term is always capitalized, as in ``Replacing
   all of the 9600 baud modems with bicycle couriers would be a Bad
   Thing.'' Oppose GOOD THING. One correspondent suggests that BAD
   THING and GOOD THING (and prob. therefore RIGHT THING and WRONG
   THING) come from the book ``1066 and All That'', which discusses
   rulers who were Good Kings, but Bad Things.

BAGBITER (bag'biet- at r) n.  1. Something, such as a program or a
   computer, that fails to work, or works in a remarkably clumsy
   manner.  Example: ``This text editor won't let me make a file with
   a line longer than 80 characters!  What a bagbiter!''  2. A person
   who has caused you some trouble, inadvertently or otherwise,
   typically by failing to program the computer properly. Synonyms:
   LOSER, CRETIN, CHOMPER. 3. Also in the form BAGBITING adj.  Having
   the quality of a bagbiter.  `This bagbiting system won't let me
   compute the factorial of a negative number.' Compare LOSING,
   CRETINOUS, BLETCHEROUS, BARFUCIOUS and CHOMPING; and BITE THE BAG
   v.  To fail in some manner. ``The computer keeps crashing every
   five minutes.''  ``Yes, the disk controller is really biting the
   bag.'' The original loading of these terms was almost undoubtedly
   obscene, probably referring to the scrotum, but in their current
   usage they have become almost completely sanitized.

BAMF (bamf) [from comix] interj. Notional sound made by a person or
   object teleporting in or out of the hearer's vicinity. Often used
   in VIRTUAL REALITY (q.v.) electronic fora when a character wishes
   to make a dramatic entrance or exit.

BANG 1. n. Common spoken name for `!' (ASCII 33), especially when used
   in pronouncing a BANG PATH (q.v.) in spoken hackish. In elder days
   this was considered a CMUish usage, with MIT and Stanford hackers
   preferring EXCL or SHRIEK; but the spread of UNIX has carried BANG
   with it and it is now certainly the most common spoken name for
   `!'. Note that it is used exclusively for non-emphatic written `!';
   one would not say ``Congratulationa bang.'', but if one wanted to
   specify the exact characters ``FOO!'', one would speak ``Eff oh oh
   bang''. See SHRIEK, ASCII. 2.  interj. An exclamation signifying
   roughly ``I have achieved enlightenment!'' or ``The dynamite has
   cleared out my brain!''.  Often used to acknowledge that one has
   perpetrated a THINKO immediately after one has been called on it.

BANG PATH n. An old-style UUCP electronic-mail address specifying hops
   to get from some assumed-reachable location to the addressee, so
   called because each hop is signified by a BANG sign.  Thus the path
   ``...!bigsite!foovax!barbox!me'' directs correspondents to route
   their mail to machine bigsite (presumably a well-known location
   accessible to everybody) and from there through the machine
   ``foovax'' to the account of user ``me'' on ``barbox''.  See
   INTERNET ADDRESS and NETWORK.

BAR (bar) 1. The second metasyntactic variable, after FOO and before
   BAZ.  ``Suppose we have two functions FOO and BAR.  FOO calls
   BAR...''  2. Often appended to FOO to produce FOOBAR.

BARF (barf) [from mainstream slang meaning ``vomit''] 1. interj. Term
   of disgust.  See BLETCH.  2. To say ``Barf!'' or emit some similar
   expression of disgust. 3. v. To fail to work because of
   unacceptable input.  May mean to give an error message.  Examples:
   ``The division operation barfs if you try to divide by zero.''
   (that is, division by zero fails in some unspecified spectacular
   way) ``The text editor barfs if you try to read in a new file
   before writing out the old one.''  4. Also BARFULOUS, BARFUCIOUS:
   adj. Said of something which would make anyone barf, if only for
   aesthetic reasons. See CHOKE, GAG.

BAUD BARF (bawd barf) n. The garbage one gets on the monitor when
   using a modem connection with some protocol setting (esp. line
   speed) incorrect, or when someone picks up a voice extension on the
   same line, or when really bad line noise disrupts the connection.

BAZ (baz) 1. The third metasyntactic variable, after FOO and BAR and
   before QUX.  ``Suppose we have three functions FOO, BAR, and BAZ.
   FOO calls BAR, which calls BAZ...'' 2. interj. Term of mild
   annoyance.  In this usage the term is often drawn out for two or
   three seconds, producing an effect not unlike the bleating of a
   sheep; ``Baaaaaaz!''  3. Occasionally appended to FOO to produce
   FOOBAZ.

BEAM [from ``Beam me up, Scotty!''] v. To transfer SOFTCOPY of
   a file electronically; most often in combining forms such as ``beam
   me a copy'' or ``beam that over to his site''. Compare BLAST,
   SNARF, BLT.

BELLS AND WHISTLES [by analogy with locomotives] n. Features added to
   a program or system to make it more FLAVORFUL from a hacker's point
   of view, without necessarily adding to its utility for its primary
   function. Distinguished from CHROME which is intended to attract
   users.

BENCHMARK n. An inaccurate measure of computer performance.  ``In the
   computer industry, there are three kinds of lies: lies, damn lies,
   and benchmarks.'' See also MIPS.

BERKLIX (ber'kliks) n.,adj. Contraction of Berkeley UNIX. See BSD. Not
   used at Berkeley itself. [This one, in my experience, is more
   common among suit-wearers attempting to sound ``hip'' than hackers
   -- ESR]

BERZERKELY (b at r-zer'klee) [from the name of a now-deceased record
   label] n. Humorous, often-used distortion of ``Berkeley'' used esp.
   to refer to the practices or products of the BSD UNIX hackers.

BIG-ENDIAN [From Swift's ``Gulliver's Travels'' via a famous 1980
   paper by Danny Cohen] adj. Describes a computer architecture in
   which, within a given 16- or 32-bit word, lower byte addresses have
   higher significance (the word is stored `big-end-first'). Most
   processors including the IBM 370 family and the PDP-10 and Motorola
   microprocessor families and most of the various RISC designs
   current in 1990 are big-endian. See LITTLE-ENDIAN, MIDDLE-ENDIAN.

BIG IRON n. Large, expensive, ultra-fast computers.  Used
   generally of number crunching supercomputers such as Crays, but can
   include more conventional big commercial IBMish mainframes.  Term
   of approval, oppose DINOSAUR.

BIGNUM (big'num) n.  A multiple-precision computer representation for
   very large integers.  More generally, any very large number.
   ``Have you ever looked at the United States Budget?  There's
   bignums for you!'' When playing backgammon, large numbers on the
   dice, especially a roll of double fives or double sixes.  Most
   computer languages provide a kind of data called ``integer'', but
   such computer integers are usually very limited in size; usually
   they must be smaller than 2 ^ 31 (2147483648) or (on losing BITTY
   BOXES) 2 ^ 16 (32767).  If you want to work with numbers larger
   than that, you have to use floating-point numbers, which are
   usually only accurate to six or seven decimal places. Computer
   languages that provide bignums can perform exact calculations on
   very large numbers, such as 1000! (the factorial of 1000, which is
   1000 times 999 times 998 times ... times 2 times 1) exactly.  For
   example, this value for 1000! was computed by the MACLISP system
   using bignums:
   4023872600770937735437024339230039857193748642107146325437999104
   2993851239862902059204420848696940480047998861019719605863166687
   2994808558901323829669944590997424504087073759918823627727188732
   5197795059509952761208749754624970436014182780946464962910563938
   8743788648733711918104582578364784997701247663288983595573543251
   3185323958463075557409114262417474349347553428646576611667797396
   6688202912073791438537195882498081268678383745597317461360853795
   3452422158659320192809087829730843139284440328123155861103697680
   1357304216168747609675871348312025478589320767169132448426236131
   4125087802080002616831510273418279777047846358681701643650241536
   9139828126481021309276124489635992870511496497541990934222156683
   2572080821333186116811553615836546984046708975602900950537616475
   8477284218896796462449451607653534081989013854424879849599533191
   0172335555660213945039973628075013783761530712776192684903435262
   5200015888535147331611702103968175921510907788019393178114194545
   2572238655414610628921879602238389714760885062768629671466746975
   6291123408243920816015378088989396451826324367161676217916890977
   9911903754031274622289988005195444414282012187361745992642956581
   7466283029555702990243241531816172104658320367869061172601587835
   2075151628422554026517048330422614397428693306169089796848259012
   5458327168226458066526769958652682272807075781391858178889652208
   1643483448259932660433676601769996128318607883861502794659551311
   5655203609398818061213855860030143569452722420634463179746059468
   2573103790084024432438465657245014402821885252470935190620929023
   1364932734975655139587205596542287497740114133469627154228458623
   7738753823048386568897646192738381490014076731044664025989949022
   2221765904339901886018566526485061799702356193897017860040811889
   7299183110211712298459016419210688843871218556461249607987229085
   1929681937238864261483965738229112312502418664935314397013742853
   1926649875337218940694281434118520158014123344828015051399694290
   1534830776445690990731524332782882698646027898643211390835062170
   9500259738986355427719674282224875758676575234422020757363056949
   8825087968928162753848863396909959826280956121450994871701244516
   4612603790293091208890869420285106401821543994571568059418727489
   9809425474217358240106367740459574178516082923013535808184009699
   6372524230560855903700624271243416909004153690105933983835777939
   4109700277534720000000000000000000000000000000000000000000000000
   0000000000000000000000000000000000000000000000000000000000000000
   0000000000000000000000000000000000000000000000000000000000000000
   0000000000000000000000000000000000000000000000000000000000000000
   00000000. The MACLISP language was not the first computer system to
   calculate very large integers, but it was @c[MACLISP] that provided
   the name ``bignum''.]

BIG RED SWITCH [IBM] n. The power switch on a computer, esp. on an
   IBM-PC where it really is large and red.  ``This !@%$% BITTY BOX is
   hung again, time to hit the big red switch.'' Sources at IBM report
   that, in tune with the company's passion for TLAs (q.v.) this is
   often acronymized as ``BRS''.

BIGNUMS [from Macsyma] n. 1. In backgammon, large numbers on the dice.
   2. Multiple-precision (sometimes infinitely extendable) integers
   and, through analogy, any very large numbers.  3. EL CAMINO BIGNUM:
   El Camino Real, a street through the San Francisco peninsula that
   originally extended (and still appears in places) all the way to
   Mexico City.  It was termed ``El Camino Double Precision'' when
   someone noted it was a very long street, and then ``El Camino
   Bignum'' when it was pointed out that it was hundreds of miles
   long.

BINARY n. The object code for a program.

BIT [from the unit of information] n. A mental flag: a reminder that
   something should be done eventually. Example: ``I have a bit set
   for you.'' (I haven't seen you for a while, and I'm supposed to
   tell or ask you something.)

BIT BANG n. Transmission of data on a serial line accomplished by
   rapidly tweaking a single output bit at the appropriate times
   (popular on certain early models of PRIME computers, presumably
   when UARTs were too expensive; and on archaic Z-80 micros with a
   Zilog PIO but no SIO). The technique is a simple loop with eight
   OUT, SHIFT, OUT etc for each byte.  Input is more interesting. And
   full duplex (doing input and output at the same time) is one way to
   separate the real hackers from the wannabees.

BIT BUCKET n. The great data sink in the sky. Data that is discarded
   is said to ``go to the bit bucket''. On UNIX, often used for
   /DEV/NULL (q.v.). Sometimes amplified as THE GREAT BIT BUCKET IN
   THE SKY.

BIT DECAY n. See SOFTWARE ROT. People with a physics background tend
   to prefer this one for the analogy with particle decay.

BIT ROT n. See SOFTWARE ROT.

BITBLT (bit'blit, bit'belt) n. [from BLT, q.v.] 1. One of a closely
   related family of 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. An early
   experimental bit-mapped terminal at Bell Labs, later commercialized
   as the AT&T 5620.

BITS n. Machine-readable representation of a document, specifically as
   contrasted with paper.  ``I only have a photocopy of the Jargon
   File; does anyone know where I can get the bits?''.  See SOFTCOPY.

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 for it. Especially used of small,
   obsolescent, single-tasking-only personal machines like the Atari
   800X, Osborne, Sinclair, VIC-20, or TRS-80. 2. More generally, the
   opposite of `real computer' (see GET A REAL COMPUTER). Pejorative.
   See also MESS-DOS, TOASTER, and TOY.

BIXIE (biks'ee) n. Synonym for EMOTICON used on BIX (the Byte
   Information Exchange); BIXers believe (probably incorrectly) the
   emoticon was invented there.

BLAST v.,n. Synonym for BLT (q.v.), used esp. for large data sends
   over a network or comm line. Opposite of SNARF. Usage: uncommon.

BLAZER n. Nickname for the Telebit Trailblazer, an expensive but
   extremely reliable and effective high-speed modem, popular at UNIX
   sites that pass large volumes of EMAIL and USENET news.

BLETCH (blech) [from Yiddish/German ``brechen'', to vomit] 1. interj.
   Term of disgust.  2. BLETCHEROUS: adj. Disgusting in design or
   function.  ``This keyboard is bletcherous!''  Usage: slightly
   comic.

BLINKENLIGHTS (blink'@n-lietz) n. Front-panel diagnostic lights on a
   mainframe CPU.  Derives from the last word of the famous
   blackletter-Gothic ``ACHTUNG! ALLES LOOKENSPEEPERS!'' notice in
   mangled pseudo-German that once graced about half the computer
   rooms in the English-speaking world. The following text ran: ``Das
   computermachine ist nicht fur gefingerpoken und mittengrabben.  Ist
   easy schnappen der springenwerk, blowenfusen und poppencorken mit
   spitzensparken. Ist nicht fur gewerken bei das dumpkopfen. Das
   rubbernecken sichtseeren keepen hans in das pockets muss; relaxen
   und watch das blinkenlichten.'' This silliness dates back at least
   as far as the London University ATLAS site in the 1960s, but
   (judging by the idioms) was probably composed by an American at
   some still-earlier date.

BLIT (blit) v. To transfer a large contiguous package of information
   from one place to another.  This usage has outlasted the PDP-10
   BLock Transfer instruction for which it derives.  See BITBLT, BLT,
   DD, CAT, BLAST, SNARF, Appendix B.

BLOCK [From computer science usage] 1. vi. To delay while waiting for
   something.  ``We're blocking until everyone gets here.''  2. in
   BLOCK ON vt. To block, waiting for (something).  ``Lunch is blocked
   on Phil's arrival.''

BLOCK TRANSFER COMPUTATIONS n.  From the Dr. Who television series: in
   the show, it referred to computations so fiendishly subtle and
   complex that they could not be performed by machines.  Used to
   refer to any task that should be expressible as an algorithm in
   theory, but isn't.

BLOW AWAY v. To remove files and directories from permanant storage
   with extreme prejudice, generally by accident.  Oppose NUKE.

BLOW OUT v. Of software, to fail spectacularly; almost as serious as
   CRASH AND BURN. See BLOW PAST.

BLOW PAST v. To BLOW OUT despite a safeguard.  ``The server blew past
   the 5K reserve buffer.''

BLT (bee ell tee, [rarely] belt) n.,v. Synonym for BLIT. This form is
   older but now less common.

BLUE BOOK n. Informal name for one of the three standard references on
   PostScript; the others are known as the GREEN BOOK and RED BOOK.

BLUE GLUE [IBM] n. IBM's SNA (Systems Network Architecture) an
   incredibly losing and bletcherous protocol suite widely favored at
   commercial shops that don't know any better.  See FEAR AND
   LOATHING.

BLUE GOO n. Term for ``police'' NANOBOTS intended to prevent GRAY GOO
   (q.v.), denature hazardous waste, destroy pollution, put ozone back
   into the stratosphere, prevent halitosis, and to promote truth,
   justice, and the American way, etc., etc. See NANOTECHNOLOGY.

BNF (bee-en-ef) n. Hacker acronym for `Backus-Naur Form', a
   metasyntactic notation used to specify the syntax of programming
   languages, command sets and the like. Widely used for language
   descriptions but seldom documented anywhere, so that it must
   usually be learned by osmosis from other hackers. Consider this BNF
   for a postal address:

   <postal-address> ::= <name-part> <street-address> <zip-part>

   <name-part> ::= <first-name> [<middle-part>] <last-name>

   <middle-part> ::= <middle-name>
                  |  <middle-initial> "."

   <street-address> ::= [<apt>] <street-number> <street-name>

   <zip-part> ::= <town-name> "," <state-code> <zip-code>

   This translates into English as: A postal-address consists of a
   name-part, followed by a street-address part, followed by a
   zip-code part. A name-part consists of a first-name followed by an
   optional middle-part followed by a last-name. A middle-part
   consists of either a middle name or a middle initial followed by a
   dot. A street address consists of an optional apartment specifier
   followed by a street number, followed by a street name.  A zip-part
   consts of a town-name, followed by a state code, followed by a zip
   code. Note that many things such as the format of a first-name,
   apartment specifier or zip-code are left unspecified. These are
   presumed to be obvious from context or detailed in another part of
   the specification the BNF is part of.

BOA [IBM] n. Any one of the fat cables that lurk under the floor in
   DINOSAUR PENS. It is rumored within IBM that 370 channel cables are
   limited to 200 feet because beyond that length the boas get
   dangerous...

BOAT ANCHOR n. Like DOORSTOP (q.v.) but more severe, implies that the
   offending hardware is irreversibly dead or useless.

BOGOMETER (boh-goh'm at -tr) n. An instrument to measure BOGOSITY,
   generally a conversational device, as in ``my bogometer is reading
   in the red on that idea'' or ``I think you just bent the needle on
   my bogometer''.

BOGON (bo'gon) [by analogy with proton/electron/neutron, but doubtless
   reinforced after 1980 by the similarity to ``Vogon''] n. 1. The
   elementary particle of bogosity (see QUANTUM BOGODYNAMICS).  For
   instance, ``the ethernet is emitting bogons again,'' meaning that
   it is broken or acting in an erratic or bogus fashion. 2. A query
   packet sent from a TCP/IP domain resolver to a root server, having
   the reply bit set instead of the query bit.  3. Any bogus or
   incorrectly formed packet sent on a network.  4. By extension, used
   to refer metasyntactically to any bogus thing, as in ``I'd like to
   go to lunch with you but I've got to go to the weekly staff
   bogon.''

BOGON FILTER (bo'gon fil'tr) n.  Any device, software or hardware,
   which limits or suppresses the flow and/or emission of bogons.
   Example: ``Engineering hacked a bogon filter between the Cray and
   the VAXen and now we're getting fewer dropped packets.''

BOGOSITY (boh-gos- at -tee) n. 1. The degree to which something is BOGUS
   (q.v.).  At CMU, bogosity is measured with a BOGOMETER; typical
   use: in a seminar, when a speaker says something bogus, a listener
   might raise his hand and say, ``My bogometer just triggered.''  The
   agreed-upon unit of bogosity is the microLenat (uL). 2. The
   potential field generated by a bogon flux; see QUANTUM
   BOGODYNAMICS.

BOGUS [WPI, Yale, Stanford] adj. 1. Non-functional.  ``Your patches
   are bogus.''  2. Useless.  ``OPCON is a bogus program.''  3.
   False.  ``Your arguments are bogus.''  4. Incorrect.  ``That
   algorithm is bogus.''  5. Silly.  ``Stop writing those bogus
   sagas.''  (This word seems to have some, but not all, of the
   connotations of RANDOM.)  [Etymological note from Lehman/Reid at
   CMU: ``Bogus'' was originally used (in this sense) at Princeton, in
   the late 60s.  It was used not particularly in the CS department,
   but all over campus.  It came to Yale, where one of us (Lehman) was
   an undergraduate, and (we assume) elsewhere through the efforts of
   Princeton alumni who brought the word with them from their alma
   mater.  In the Yale case, the alumnus is Michael Shamos, who was a
   graduate student at Yale and is now a faculty member here.  A
   glossary of bogus words was compiled at Yale when the word was
   first popularized (e.g., autobogophobia: the fear of becoming
   bogotified).]

BOHR BUG (bor buhg) [from quantum physics] n. A repeatable BUG; one
   which manifests reliably under a possibly unknown but well-defined
   set of conditions. Antonym of HEISENBUG.

BOINK (boynk) [USENET] 1. To have sex with; compare BOUNCE, sense #3.
   2. After the original Peter Korn ``Boinkcon'' USENET parties, used
   for almost any net social gathering, e.g.  Miniboink, a small boink
   held by Nancy Gillett in 1988; Minniboink, a Boinkcon in Minnesota
   in 1989; Humpdayboinks, Wednesday get-togethers held in the San
   Francisco Bay Area.

BONDAGE-AND-DISCIPLINE LANGUAGE A language such as Pascal, APL, or
   Prolog that, though ostensibly general-purpose, is designed so as
   to enforce an author's theory of ``right programming'' even though
   said theory is demonstrably inadequate for systems or even vanilla
   general-purpose programming.  See LANGUAGES OF CHOICE.

BOOT [from ``by one's bootstraps''] v.,n. To load and initialize the
   operating system on a machine. This usage is no longer slang
   (having become jargon in the strict sense), but it is sometimes
   used of human thought processes, as in the following exchange:
   ``You've lost me.'' ``O.K., reboot. Here's the theory...''. Also
   found in the variants COLD BOOT (from power-off condition) and WARM
   BOOT (with the CPU and all devices already powered up, as after a
   hardware reset or software crash).

BOTTLENECKED adj. 1. Used by hackers specifically to describe hardware
   under which performance is usually limited by contention for one
   particular resource (such as disk, memory or processor CLOCKS); see
   BALANCED. 2. Less often, applied to the software analogue of sense
   #1, a slow code section or algorithm through which all computation
   must pass (see also HOT SPOT).

BOUNCE v. 1. [UNIX] An electronic mail message which is undeliverable
   and returns an error notification to the sender is said to
   `bounce'. See also BOUNCE MESSAGE. 2. [Stanford] To play
   volleyball. ``Bounce, bounce! Stop wasting time on the computer and
   get out to the court!'' 3. To engage in sexual intercourse; prob.
   fr.  the expression ``bouncing the mattress'', but influenced by
   Piglet's psychosexually-loaded ``Bounce on me too, Tigger!'' from
   the Winnie the Pooh books.

BOUNCE MESSAGE [UNIX] n. Notification message returned to sender by a
   site unable to relay EMAIL to the intended INTERNET ADDRESS
   recipient or the next link in a BANG PATH (see BOUNCE).  Reasons
   might include a nonexistent or misspelled username or a down relay
   site.  Bounce messages can themselves fail, with occasionally ugly
   results; see SORCERER'S APPRENTICE MODE.

BOXEN (bok'sn) pl n. [back-formation from VAXEN] Fanciful plural of
   `box' often encountered in the phrase `UNIX boxen', used to
   describe commodity UNIX hardware. The implication is that any two
   UNIX boxen are interchangeable.

BRAIN-DAMAGED [generalization of ``Honeywell Brain Damage'' (HBD), a
   theoretical disease invented to explain certain utter cretinisms in
   MULTICS] adj. Obviously wrong; CRETINOUS; DEMENTED.  There is an
   implication that the person responsible must have suffered brain
   damage, because he should have known better.  Calling something
   brain-damaged is really bad; it also implies it is unusable.

BRANCH TO FISHKILL [IBM, from the location of one of their facilities]
   n. Any unexpected jump in a program that produces catastrophic or
   just plain weird results. See HYPERSPACE.

BREAK v. 1. To cause to be broken (in any sense).  ``Your latest patch
   to the system broke the TELNET server.''  2. (of a program) To stop
   temporarily, so that it may be examined for debugging purposes.
   The place where it stops is a BREAKPOINT.

BREAKAGE [IBM] n. The extra people that must be added to an
   organization because its master plan has changed; used esp. of
   software and hardware development teams.

BRITTLE adj. Said of software that's functional but easily broken by
   changes in operating environment or configuration.  Often describes
   the results of a research effort that were never intended to be
   robust, but can be applied to commercially developed software.

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.  Also called NETWORK
   MELTDOWN. See also CHERNOBYL PACKET.

BROKEN adj. 1. Not working properly (of programs).  2.  Behaving
   strangely; especially (of people), exhibiting extreme depression.

BROKET (broh'k at t, broh'ket) [by analogy with ``bracket": a ``broken
   bracket"] (primarily Stanford) n. Either of the characters ``<''
   and ``>''.  (At MIT, and apparently in THE REAL WORLD (q.v.) as
   well, these are usually called ANGLE BRACKETS.)

BRUTE FORCE AND IGNORANCE n. A popular design technique at many
   software houses. Dogmatic adherence to design methodologies tends
   to encourage it. Characteristic of early LARVAL STAGE programming;
   unfortunately, many never outgrow it.  Often abbreviated BFI, as
   in: ``Gak, they used a bubble sort!  That's strictly from BFI.''
   Compare BOGOSITY.

BSD (bee-ess-dee) n. [acronym for Berkeley System Distribution] a
   family of UNIX versions for the DEC VAX developed by Bill Joy and
   others at UC Berkeley starting around 1980, incorporating TCP/IP
   networking enhancements and many other features. The BSD versions
   (4.1, 4.2, and 4.3) and commercial versions derived from them
   (SunOS 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.

BUCKY BITS (buh'kee bits) [primarily Stanford] n. The bits produced by
   the CTRL and META shift keys on a Stanford (or Knight) keyboard. It
   is rumored that these were in fact named for Buckminster Fuller
   during a period when he was consulting at Stanford. Unfortunately,
   legend also has it that ``Bucky'' was Niklaus Wirth's nickname when
   *he* was consulting at Stanford and that he first suggested the
   idea of the meta key, so its bit was named after him. DOUBLE BUCKY:
   adj. Using both the CTRL and META keys.  ``The command to burn all
   LEDs is double bucky F.'' See also META BIT, COKEBOTTLE.

BUFFER OVERFLOW n. What typically happens when an OS or application is
   fed data faster than it can buffer and process it. Used
   metaphorically of human mental processes. ``Sorry, I got four phone
   calls in three minutes last night and lost your message to a buffer
   overflow.''

BUG [from telephone terminology, ``bugs in a telephone cable'', blamed
   for noisy lines] n. An unwanted and unintended property of a
   program, esp. one which causes it to malfunction. See FEATURE.

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.

BUM 1. v. To make highly efficient, either in time or space, often at
   the expense of clarity.  ``I managed to bum three more
   instructions.''  2. n. A small change to an algorithm to make it
   more efficient.  Usage: somewhat rare. See TUNE.

BUMP v. Synonym for increment.  Has the same meaning as C's ++
   operator. Used esp. of counter variables, pointers (see POINTER
   ARITHMETIC) and index dummies in for, while, and do-until loops.

BURBLE v. Like FLAME, but connotes that the source is truly clueless
   and ineffectual (mere flamers can be competent). A term of deep
   contempt.

BUSY-WAIT v. To wait on an event by 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. A wasteful technique, best avoided on
   time-sharing systems where a busy-waiting program may hog the
   processor.

BUZZ v. 1. To run in a very tight loop, perhaps without guarantee of
   getting out. See SPIN. 2. [ETA Systems] To test a wire or PCB trace
   for continuity by applying an AC signal as opposed to applying a DC
   signal.  Some wire faults will pass DC tests but fail a BUZZ test.

BWQ [bee duhb'l-yoo kyoo) [IBM] n. Buzz Word Quotient. Usually roughly
   proportional to BOGOSITY. See TLA.

BYTESEXUAL (biet-seks'u- at 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).



More information about the Comp.unix.internals mailing list