The New Hacker's Dictionary by Eric S. Raymond (each kindness read aloud TXT) 📖

installed by Field Engineers to work around problems

discovered during testing or debugging. These are called `purple

wires' even when (as is frequently the case) their actual physical

color is yellow.... Compare [10753]blue wire, [10754]yellow wire, and

[10755]red wire.

Node:push, Next:[10756]Python, Previous:[10757]purple wire,

Up:[10758]= P =

push

[from the operation that puts the current information on a stack, and

the fact that procedure return addresses are saved on a stack] (Also

PUSH /push/ or PUSHJ /push'J/, the latter based on the PDP-10

procedure call instruction.) 1. To put something onto a [10759]stack

or [10760]PDL. If one says that something has been pushed onto one's

stack, it means that the Damoclean list of things hanging over ones's

head has grown longer and heavier yet. This may also imply that one

will deal with it before other pending items; otherwise one might say

that the thing was `added to my queue'. 2. vi. To enter upon a

digression, to save the current discussion for later. Antonym of

[10761]pop; see also [10762]stack, [10763]PDL.

Node:Python, Next:[10764]quad, Previous:[10765]push, Up:[10766]= P =

Python /pi:'thon/

In the words of its author, "the other scripting language" (other than

[10767]Perl, that is). Python's design is notably clean, elegant, and

well thought through; it tends to attract the sort of programmers who

find Perl grubby and exiguous. Python's relationship with Perl is

rather like the [10768]BSD community's relationship to [10769]Linux -

it's the smaller party in a (usually friendly) rivalry, but the

average quality of its developers is generally conceded to be rather

higher than in the larger community it competes with. There's a Python

resource page at [10770]http://www.python.org. See also [10771]Guido.

Node:= Q =, Next:[10772]= R =, Previous:[10773]= P =, Up:[10774]The

Jargon Lexicon

= Q =

[10775]quad:

[10776]quadruple bucky:

[10777]quantifiers:

[10778]quantum bogodynamics:

[10779]quarter:

[10780]ques:

[10781]quick-and-dirty:

[10782]quine:

[10783]quote chapter and verse:

[10784]quotient:

[10785]quux:

[10786]qux:

[10787]QWERTY:

Node:quad, Next:[10788]quadruple bucky, Previous:[10789]Python,

Up:[10790]= Q =

quad n.

Two bits; syn. for [10791]quarter, [10792]crumb, [10793]tayste. 2.

A four-pack of anything (compare [10794]hex, sense 2). 3. The

rectangle or box glyph used in the APL language for various arcane

purposes mostly related to I/O. Former Ivy-Leaguers and Oxford types

are said to associate it with nostalgic memories of dear old

University.

Node:quadruple bucky, Next:[10795]quantifiers, Previous:[10796]quad,

Up:[10797]= Q =

quadruple bucky n. obs.

On an MIT [10798]space-cadet keyboard, use of all four of the

shifting keys (control, meta, hyper, and super) while typing a

character key. 2. On a Stanford or MIT keyboard in [10799]raw mode,

use of four shift keys while typing a fifth character, where the four

shift keys are the control and meta keys on both sides of the

keyboard. This was very difficult to do! One accepted technique was to

press the left-control and left-meta keys with your left hand, the

right-control and right-meta keys with your right hand, and the fifth

key with your nose.

Quadruple-bucky combinations were very seldom used in practice,

because when one invented a new command one usually assigned it to

some character that was easier to type. If you want to imply that a

program has ridiculously many commands or features, you can say

something like: "Oh, the command that makes it spin the tapes while

whistling Beethoven's Fifth Symphony is quadruple-bucky-cokebottle."

See [10800]double bucky, [10801]bucky bits, [10802]cokebottle.

Node:quantifiers, Next:[10803]quantum bogodynamics,

Previous:[10804]quadruple bucky, Up:[10805]= Q =

quantifiers

In techspeak and jargon, the standard metric prefixes used in the SI

(Syst�me International) conventions for scientific measurement have

dual uses. With units of time or things that come in powers of 10,

such as money, they retain their usual meanings of multiplication by

powers of 1000 = 10^3. But when used with bytes or other things that

naturally come in powers of 2, they usually denote multiplication by

powers of 1024 = 2^(10).

Here are the SI magnifying prefixes, along with the corresponding

binary interpretations in common use:

prefix decimal binary

kilo- 1000^1 1024^1 = 2^10 = 1,024

mega- 1000^2 1024^2 = 2^20 = 1,048,576

giga- 1000^3 1024^3 = 2^30 = 1,073,741,824

tera- 1000^4 1024^4 = 2^40 = 1,099,511,627,776

peta- 1000^5 1024^5 = 2^50 = 1,125,899,906,842,624

exa- 1000^6 1024^6 = 2^60 = 1,152,921,504,606,846,976

zetta- 1000^7 1024^7 = 2^70 = 1,180,591,620,717,411,303,424

yotta- 1000^8 1024^8 = 2^80 = 1,208,925,819,614,629,174,706,176

Here are the SI fractional prefixes:

prefix decimal jargon usage

milli- 1000^-1 (seldom used in jargon)

micro- 1000^-2 small or human-scale (see [10806]micro-)

nano- 1000^-3 even smaller (see [10807]nano-)

pico- 1000^-4 even smaller yet (see [10808]pico-)

femto- 1000^-5 (not used in jargon---yet)

atto- 1000^-6 (not used in jargon---yet)

zepto- 1000^-7 (not used in jargon---yet)

yocto- 1000^-8 (not used in jargon---yet)

The prefixes zetta-, yotta-, zepto-, and yocto- have been included in

these tables purely for completeness and giggle value; they were

adopted in 1990 by the `19th Conference Generale des Poids et

Mesures'. The binary peta- and exa- loadings, though well established,

are not in jargon use either -- yet. The prefix milli-, denoting

multiplication by 1/1000, has always been rare in jargon (there is,

however, a standard joke about the `millihelen' -- notionally, the

amount of beauty required to launch one ship). See the entries on

[10809]micro-, [10810]pico-, and [10811]nano- for more information on

connotative jargon use of these terms. Femto' andatto' (which,

interestingly, derive not from Greek but from Danish) have not yet

acquired jargon loadings, though it is easy to predict what those will

be once computing technology enters the required realms of magnitude

(however, see [10812]attoparsec).

There are, of course, some standard unit prefixes for powers of 10. In

the following table, the `prefix' column is the international standard

suffix for the appropriate power of ten; the `binary' column lists

jargon abbreviations and words for the corresponding power of 2. The

B-suffixed forms are commonly used for byte quantities; the words

meg' andgig' are nouns that may (but do not always) pluralize with

`s'.

prefix decimal binary pronunciation

kilo- k K, KB, /kay/

mega- M M, MB, meg /meg/

giga- G G, GB, gig /gig/,/jig/

Confusingly, hackers often use K or M as though they were suffix or

numeric multipliers rather than a prefix; thus "2K dollars", "2M of

disk space". This is also true (though less commonly) of G.

Note that the formal SI metric prefix for 1000 is `k'; some use this

strictly, reserving `K' for multiplication by 1024 (KB is thus

`kilobytes').

K, M, and G used alone refer to quantities of bytes; thus, 64G is 64

gigabytes and a K' is a kilobyte (compare mainstream use ofa G' as

short for a grand', that is, $1000). Whether one pronouncesgig'

with hard or soft `g' depends on what one thinks the proper

pronunciation of `giga-' is.

Confusing 1000 and 1024 (or other powers of 2 and 10 close in

magnitude) -- for example, describing a memory in units of 500K or

524K instead of 512K -- is a sure sign of the [10813]marketroid. One

example of this: it is common to refer to the capacity of 3.5"

[10814]microfloppies as `1.44 MB' In fact, this is a completely

[10815]bogus number. The correct size is 1440 KB, that is, 1440 * 1024

= 1474560 bytes. So the mega' in1.44 MB' is compounded of two

`kilos', one of which is 1024 and the other of which is 1000. The

correct number of megabytes would of course be 1440 / 1024 = 1.40625.

Alas, this fine point is probably lost on the world forever.

[1993 update: hacker Morgan Burke has proposed, to general approval on

Usenet, the following additional prefixes:

groucho

10^(-30)

harpo

10^(-27)

harpi

10^(27)

grouchi

10^(30)

We observe that this would leave the prefixes zeppo-, gummo-, and

chico- available for future expansion. Sadly, there is little

immediate prospect that Mr. Burke's eminently sensible proposal will

be ratified.]

[1999 upate: there is an [10816]IEC proposal for binary multipliers,

but no evidence that any of its proposals are in live use.]

Node:quantum bogodynamics, Next:[10817]quarter,

Previous:[10818]quantifiers, Up:[10819]= Q =

quantum bogodynamics /kwon'tm boh`goh-di:-nam'iks/ n.

A theory that characterizes the universe in terms of bogon sources

(such as politicians, used-car salesmen, TV evangelists, and

[10820]suits in general), bogon sinks (such as taxpayers and

computers), and bogosity potential fields. Bogon absorption, of

course, causes human beings to behave mindlessly and machines to fail

(and may also cause both to emit secondary bogons); however, the

precise mechanics of the bogon-computron interaction are not yet

understood and remain to be elucidated. Quantum bogodynamics is most

often invoked to explain the sharp increase in hardware and software

failures in the presence of suits; the latter emit bogons, which the

former absorb. See [10821]bogon, [10822]computron, [10823]suit,

[10824]psyton.

Node:quarter, Next:[10825]ques, Previous:[10826]quantum bogodynamics,

Up:[10827]= Q =

quarter n.

Two bits. This in turn comes from the `pieces of eight' famed in

pirate movies -- Spanish silver crowns that could be broken into eight

pie-slice-shaped `bits' to make change. Early in American history the

Spanish coin was considered equal to a dollar, so each of these `bits'

was considered worth 12.5 cents. Syn. [10828]tayste, [10829]crumb,

[10830]quad. Usage: rare. General discussion of such terms is under

[10831]nybble.

Node:ques, Next:[10832]quick-and-dirty, Previous:[10833]quarter,

Up:[10834]= Q =

ques /kwes/

n. The question mark character (?, ASCII 0111111). 2. interj. What?

Also frequently verb-doubled as "Ques ques?" See [10835]wall.

Node:quick-and-dirty, Next:[10836]quine, Previous:[10837]ques,

Up:[10838]= Q =

quick-and-dirty adj.

[common] Describes a [10839]crock put together under time or user

pressure. Used esp. when you want to convey that you think the fast

way might lead to trouble further down the road. "I can have a

quick-and-dirty fix in place tonight, but I'll have to rewrite the

whole module to solve the underlying design problem." See also

[10840]kluge.

Node:quine, Next:[10841]quote chapter and verse,

Previous:[10842]quick-and-dirty, Up:[10843]= Q =

quine /kwi:n/ n.

[from the name of the logician Willard van Orman Quine, via Douglas

Hofstadter] A program that generates a copy of its own source text as

its complete output. Devising the shortest possible quine in some

given programming language is a common hackish amusement. (We ignore

some variants of BASIC in which a program consisting of a single empty

string literal reproduces itself trivially.) Here is one classic

quine:

((lambda (x)

(list x (list (quote quote) x)))

(quote

(lambda (x)

(list x (list (quote quote) x)))))

This one works in LISP or Scheme. It's relatively easy to write quines

in other languages such as Postscript which readily handle programs as

data; much harder (and thus more challenging!) in languages like C

which do not. Here is a classic C quine for ASCII machines:

charf="charf=%c%s%c;main()

{printf(f,34,f,34,10);}%c";

main(){printf(f,34,f,34,10);}

For excruciatingly exact quinishness, remove the interior line breaks.

Here is another elegant quine in ANSI C:

define q(k)main(){return!puts(#k"nq("#k")");}

q(#define q(k)main(){return!puts(#k"nq("#k")");})

Some infamous [10844]Obfuscated C Contest entries have been quines

that reproduced in exotic ways. There is an amusing [10845]Quine Home

Page.

Node:quote chapter and verse, Next:[10846]quotient,

Previous:[10847]quine, Up:[10848]= Q =

quote chapter and verse v.

[by analogy with the mainstream phrase] To cite a relevant excerpt

from an appropriate [10849]bible. "I don't care if rn gets it wrong;

`Followup-To: