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

[Eric S. Raymond]

			= P =

PAGE IN [MIT] v. To become aware of one's surroundings again after
   having paged out (see PAGE OUT).  Usually confined to the sarcastic
   comment, ``So-and-so pages in. Film at 11.'' See FILM AT 11.

PAGE OUT [MIT] v. To become unaware of one's surroundings temporarily,
   due to daydreaming or preoccupation.  ``Can you repeat that?  I
   paged out for a minute.''  See PAGE IN.

PANIC [UNIX] v. An action taken by a process or the entire operating
   system when an unrecoverable error is discovered.  The action
   usually consists of: (1) displaying localized information on the
   controlling terminal, (2) saving, or preparing for saving, a memory
   image of the process or operating system, and (3) terminating the
   process or rebooting the system.

PARAM (p at -ram') n. Speeech-only shorthand for ``parameter''. Compare
   ARG, VAR. The plural `params' is often further compressed to
   `parms'.

PARITY ERRORS pl.n. Those little lapses of attention or (in more
   severe cases) consciousness, usually brought on by having spent all
   night and most of the next day hacking.  ``I need to go home and
   crash; I'm starting to get a lot of parity errors.''

PARSE [from linguistic terminology] v. 1. To determine the syntactic
   structure of a sentence or other utterance (close to the standard
   English meaning).  Example: ``That was the one I saw you.''  ``I
   can't parse that.''  2. More generally, to understand or
   comprehend.  ``It's very simple; you just kretch the glims and then
   aos the zotz.''  ``I can't parse that.''  3. Of fish, to have to
   remove the bones yourself (usually at a Chinese restaurant).  ``I
   object to parsing fish'' means ``I don't want to get a whole fish,
   but a sliced one is okay.''  A ``parsed fish'' has been deboned.
   There is some controversy over whether ``unparsed'' should mean
   ``bony'', or also mean ``deboned''.

PATCH 1. n. A temporary addition to a piece of code, usually as a
   quick-and-dirty remedy to an existing bug or misfeature.  A patch
   may or may not work, and may or may not eventually be incorporated
   permanently into the program.  2. v. To insert a patch into a piece
   of code. 3. [in the UNIX world] n. a set of differences between two
   versions of source code, generated with diff(1) and intended to be
   mechanically applied using patch(1); often used as a way of
   distributing permanent C code upgrades and fixes over USENET.

PD (pee-dee) adj. Common abbreviation for ``public domain'', applied
   to software distributed over USENET and from Internet archive
   sites.  Much of this software is not in fact ``public domain'' in
   the legal sense but travels under various copyrights granting
   reproduction and use rights to anyone who can SNARF a copy. See
   COPYLEFT.

PDL (pid'l or pud'l) [acronym for Push Down List] n. 1. A LIFO queue
   (stack); more loosely, any priority queue; even more loosely, any
   queue.  A person's pdl is the set of things he has to do in the
   future.  One speaks of the next project to be attacked as having
   risen to the top of the pdl.  ``I'm afraid I've got real work to
   do, so this'll have to be pushed way down on my pdl.'' All these
   usages are also frequently found with STACK (q.v) itself as the
   subject noun.  See PUSH and POP.  2. Dave Lebling (PDL at DM).

PDP-10 [Programmable Digital Processor model 10] n. The machine that
   made timesharing real. Looms large in hacker folklore due to early
   adoption in the mid-70s by many university computing facilities and
   research labs including the MIT AI lab, Stanford and CMU. Some
   aspects of the instruction set (most notably the bit-field
   instructions) are still considered unsurpassed. The '10 was
   eventually eclipsed by the PDP-11 and VAX machines and dropped from
   DEC's line in the early '80s, and in 1990 to have cut one's teeth
   on one is considered something of a badge of honorable
   old-timerhood among hackers. See TOPS-10, ITS, Appendix B.

PERCENT-S (per-sent' es) [From ``%s'', the formatting sequence in C's
   printf() library function used to indicate that an arbitrary string
   may be inserted] n. An unspecified person or object.  ``I was just
   talking to some percent-s in administration.'' Compare RANDOM.

PERF (perf) n. See CHAD (sense #1).

PESSIMAL (pes'i-ml) [Latin-based antonym for ``optimal''] adj.
   Maximally bad.  ``This is a pessimal situation.''

PESSIMIZING COMPILER (pes'i-miez-ing kuhm-pie'lr) [antonym of
   `optimizing compiler'] n. A compiler that produces object code that
   is worse than the straightforward or obvious translation.

PHASE 1. n. The phase of one's waking-sleeping schedule with respect
   to the standard 24-hour cycle.  This is a useful concept among
   people who often work at night according to no fixed schedule.  It
   is not uncommon to change one's phase by as much as six hours/day
   on a regular basis.  ``What's your phase?''  ``I've been getting in
   about 8 PM lately, but I'm going to work around to the day schedule
   by Friday.''  A person who is roughly 12 hours out of phase is
   sometimes said to be in ``night mode''.  (The term ``day mode'' is
   also used, but less frequently.)  2. CHANGE PHASE THE HARD WAY: To
   stay awake for a very long time in order to get into a different
   phase.  3. CHANGE PHASE THE EASY WAY: To stay asleep etc.

PHASE OF THE MOON n. Used humorously as a random parameter on which
   something is said to depend.  Sometimes implies unreliability of
   whatever is dependent, or that reliability seems to be dependent on
   conditions nobody has been able to determine.  ``This feature
   depends on having the channel open in mumble mode, having the foo
   switch set, and on the phase of the moon.''

PIG, RUN LIKE A adj. To run very slowly on given hardware, said of
   software. Distinct from HOG, q.v.

PING (ping) [from TCP/IP terminology] n.,v. 1. Slang term for a small
   network message (ICMP ECHO) sent by a computer to check for the
   presence and aliveness of another.  Occasionally used as a phone
   greeting. See ACK. 2.  To verify the presence of.  3. To get the
   attention of.  From the Unix command by the same name (an acronym
   of ``Packet INternet Groper) that sends an ICMP ECHO packet to
   another host. This was probably contrived to match WWII-era
   ``ping'' (sonar ranging pulse).

PINK SHIRT BOOK ``The Peter Norton Programmer's Guide to the IBM PC''.
   The original cover featured a picture of Peter Norton with a silly
   smirk on his face, wearing a pink shirt. Perhaps in recognition of
   this usage, the current edition has a different picture of Norton
   wearing a pink shirt.

PIPELINE [UNIX, orig. by Doug McIlroy; now also used under MS-DOS and
   elsewhere] n. A chain of FILTER programs connected
   ``head-to-tail'', so that the output of one becomes the input of
   the next.  Under UNIX, user utilities can often be implemented or
   at least prototyped by a suitable collection of pipelines and
   temp-file grinding encapsulated in a shell script; this is much
   less effort than writing C every time, and the capability is
   considered one of UNIX's major WINNING features.

PIZZA, ANSI STANDARD (pee'tz@, an'see stan'd at rd) [CMU] Pepperoni and
   mushroom pizza.  Coined allegedly because most pizzas ordered by
   CMU hackers during some period leading up to mid-1990 were of that
   flavor. [Myself, I have observed a high frequency of pepperoni,
   mushroom and sausage. -- ESR] See also ROTARY DEBUGGER.

PLAYPEN [IBM] n. A room where programmers work. Compare SALT MINES.

PLUGH (ploogh) [from the ADVENT game] v. See XYZZY.

PM (pee em) 1. [from ``preventive maintenence''] v. to bring down a
   machine for inspection or test purposes. 2. n. Abbrev. for
   ``Presentation Manager'', an ELEPHANTINE OS/2 GUI.

P.O.D. (pee-oh-dee) Acronym for `Piece Of Data' (as opposed to a code
   section). Usage: pedantic and rare.

POINTER ARITHMETIC [C programmers] n. The use of increment and
   decrement operations on address pointers to traverse arrays or
   structure fields. See also BUMP.

POLL v.,n. 1. The action of checking the status of an input line,
   sensor, or memory location to see if a particular external event
   has been registered. 2. To ask.  ``I'll poll everyone and see where
   they want to go for lunch.''

POLYGON PUSHER n. A chip designer who spends most of his/her time at
   the physical layout level (which requires drawing *lots* of
   multi-colored polygons).

POM (pee-oh-em) n. Phase of the moon (q.v.).  Usage: usually used in
   the phrase ``POM dependent'' which means FLAKEY (q.v.).

POP also POPJ (pop-jay) [based on the stack operation that removes the
   top of a stack, and the fact that procedure return addresses are
   saved on the stack] v. To return from a digression (the J-form
   derives from a PDP-10 assembler instruction).  By verb doubling,
   ``Popj, popj'' means roughly, ``Now let's see, where were we?''
   See RTI.

PRECEDENCE LOSSAGE (pre's at -dens los'j) [C programmers] n. Coding error
   in an expression due to unexpected grouping of arithmetic or
   logical operators by the compiler. Used esp. of certain common
   coding errors in C due to the nonintuitively low precedence levels
   of &, | and ^. Can always be avoided by suitable use of
   parentheses. See ALIASING BUG, MEMORY LEAK, SMASH THE STACK,
   FANDANGO ON CORE, OVERRUN SCREW.

PRETTY PRINT or PRETTYPRINT v. 1. To generate `pretty' human-readable
   output from a hairy internal representation; esp. used for the
   process of GRINDing (sense #2) LISP code. 2. To format in some
   particularly slick and nontrivial way.

PRIME TIME [from TV programming] n. Normal high-usage hours on a
   timesharing system, the `day shift'. Avoidance of prime time is a
   major reason for NIGHT MODE hacking.

PRIORITY INTERRUPT [from the hardware term] n. Describes any stimulus
   compelling enough to yank one right out of HACK MODE.  Classically
   used to describe being dragged away by an SO for immediate sex, but
   may also refer to more mundane interruptions such as a fire alarm
   going off in the near vicinity.

PROPELLER HEAD n. Used by hackers, this is syn. with COMPUTER GEEK.
   Non-hackers sometimes use it to describe all techies.

PROTOCOL n. See DO PROTOCOL.

PROWLER [UNIX] n. A DEMON that is run periodically (typically once a
   week) to seek out and erase core files, truncate administrative
   logfiles, nuke lost+found directories, and otherwise clean up the
   cruft that tends to pile up in the corners of a file system. See
   also GFR.

PSEUDOPRIME n. A backgammon prime (six consecutive occupied points)
   with one point missing.

PUNT [from the punch line of an old joke: ``Drop back 15 yards and
   punt''] v. To give up, typically without any intention of retrying.

PURPLE BOOK, THE n. The System V Interface Definition.  The covers of
   the first editions were an amazingly nauseating shade of
   off-lavender. See WHITE BOOK, SILVER BOOK, ORANGE BOOK, GREEN BOOK.

PUSH [based on the stack operation that puts the current information
   on a stack, and the fact that procedure call addresses are saved on
   the stack] dialect: PUSHJ (push-jay), based on the PDP-10 procedure
   call instruction.  v. To enter upon a digression, to save the
   current discussion for later.

			= Q =

QUANTUM BOGODYNAMICS (kwahn'tm boh`goh-die-nam'iks) n. Theory
   promulgated by ESR which characterizes the universe in terms of
   bogon sources (such as politicians, used-car salesmen, TV
   evangelists, and 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 cause them to emit secondary bogons as well);
   however, the precise mechanics of the bogon-computron interaction
   are not yet understood and remain to be elucidated.  Quantum
   bogodynamics is most frequently 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 BOGON,
   COMPUTRON, SUIT.

QUES (kwess) 1. n. The question mark character (``?'').  2. interj.
   What?  Also QUES QUES?  See WALL.

QUX (kwuhx) The fourth of the standard metasyntactic variables, after
   BAZ and before the QUU*X series. See FOO, BAR, BAZ, QUUX.

QUUX (kwooks) [invented by Steele] Mythically, from the Latin
   semi-deponent verb QUUXO, QUUXARE, QUUXANDUM IRI; noun form
   variously QUUX (plural QUUCES, Anglicized to QUUXES) and QUUXU
   (genitive plural is QUUXUUM, four U's in seven letters).] 1.
   Originally, a meta-word like FOO and FOOBAR.  Invented by Guy
   Steele for precisely this purpose when he was young and naive and
   not yet interacting with the real computing community.  Many people
   invent such words; this one seems simply to have been lucky enough
   to have spread a little.  2. interj. See FOO; however, denotes very
   little disgust, and is uttered mostly for the sake of the sound of
   it.  3. n.  Refers to one of three people who went to Boston Latin
   School and eventually to MIT:
	THE GREAT QUUX:  Guy L. Steele Jr.
	THE LESSER QUUX:  David J. Littleboy
	THE MEDIOCRE QUUX:  Alan P. Swide
   (This taxonomy is said to be similarly applied to three Frankston
   brothers at MIT.)  QUUX, without qualification, usually refers to
   The Great Quux, who is somewhat infamous for light verse and for
   the ``Crunchly'' cartoons.  4. QUUXY: adj. Of or pertaining to a
   QUUX.  5. n. The Micro Quux (Sam Lewis).

			= R =

RANDOM adj. 1. Unpredictable (closest to mathematical definition);
   weird.  ``The system's been behaving pretty randomly.''  2.
   Assorted; undistinguished.  ``Who was at the conference?''  ``Just
   a bunch of random business types.''  3.  Frivolous; unproductive;
   undirected (pejorative).  ``He's just a random loser.''  4.
   Incoherent or inelegant; not well organized.  ``The program has a
   random set of misfeatures.''  ``That's a random name for that
   function.''  ``Well, all the names were chosen pretty randomly.''
   5.  Gratuitously wrong, i.e., poorly done and for no good apparent
   reason.  For example, a program that handles file name defaulting
   in a particularly useless way, or an assembler routine that could
   easily have been coded using only three ac's, but randomly uses
   seven for assorted non-overlapping purposes, so that no one else
   can invoke it without first saving four extra registers's.  6. In
   no particular order, though deterministic.  ``The I/O channels are
   in a pool, and when a file is opened one is chosen randomly.''  n.
   7. A random hacker; used particularly of high school students who
   soak up computer time and generally get in the way.  8. (occasional
   MIT usage) One who lives at Random Hall.  J. RANDOM is often
   prefixed to a noun to make a ``name'' out of it (by comparison to
   common names such as ``J. Fred Muggs'').  The most common uses are
   ``J. RANDOM HACKER, ``J. Random Loser'' and ``J.  Random Nerd''
   ("Should J. Random Loser be allowed to gun down other people?"),
   but it can be used just as an elaborate version of RANDOM in any
   sense.  See also SOME RANDOM X.

RANDOM NUMBERS n. When one wishes to specify a large but random number
   of things, and the context is inappropriate for `N' (q.v.), certain
   numbers are preferred by hacker tradition (that is, easily
   recognized as placeholders). These include

   17  Long described at MIT as ``the least random number'', see 23.
   23  Sacred number of Eris, Goddess of Discord (along with 17 & 5).
   42  The Answer to the Question of Life, the Universe and Everything.
   69  From the sexual act. This one was favored in MIT's ITS culture.
   666 The Number of the Beast.

   For further enlightenment, consult the _Principia_Discordia_,
   _The_Hitchhiker's_Guide_To_The_Galaxy_, any porn movie, and the
   Christian Bible's _Book_Of_Revelations_. See also DISCORDIANISM.

RANDOMNESS n. An unexplainable misfeature; gratuitous inelegance.
   Also, a HACK or CROCK which depends on a complex combination of
   coincidences (or rather, the combination upon which the crock
   depends).  ``This hack can output characters 40-57 by putting the
   character in the accumulator field of an XCT and then extracting 6
   bits -- the low two bits of the XCT opcode are the right thing.''
   ``What randomness!''

RAPE v. To (metaphorically) screw someone or something, violently.
   Usage: often used in describing file-system damage.  ``So-and-so
   was running a program that did absolute disk I/O and ended up
   raping the master directory.''

RARE [UNIX] adj. CBREAK mode (character-by-character with interrupts
   enabled). Distinguished from `raw' and `cooked', but unlike them
   this term is strictly a creature of folklore, not found in the
   manuals. Usage: rare.

RASTER BURN n. Eyestrain brought on by too many hours of looking at
   low-res, poorly tuned or glare-ridden monitors, esp.  graphics
   monitors. See TERMINAL ILLNESS.

RAVE [WPI] v. 1. To persist in discussing a specific subject.  2. To
   speak authoritatively on a subject about which one knows very
   little.  3. To complain to a person who is not in a position to
   correct the difficulty.  4. To purposely annoy another person
   verbally.  5. To evangelize.  See FLAME.  Also used to describe a
   less negative form of blather, such as friendly bullshitting.

RAVE ON! imp. Sarcastic invitation to continue a RAVE, often by
   someone who wishes the raver would get a clue but realizes this is
   unlikely.

READ-ONLY USER n. Describes a LUSER who uses computers almost
   exclusively for reading USENET, bulletin boards and email, as
   opposed to writing code or purveying useful information. See TWINK.

REAL SOON NOW [orig. from SF's fanzine community. popularized by Jerry
   Pournelle's BYTE column] adj.  1. Supposed to be available (or
   fixed, or cheap, or whatever) real soon now according to somebody,
   but the speaker is quite skeptical.  2. When the gods/fates/other
   time commitments permit the speaker to get to it.  Often
   abbreviated RSN.

REAL TIME adv. Doing something while people are watching or waiting.
   ``I asked her how to find the calling procedure's program counter
   on the stack and she came up with an algorithm in real time.''

REAL USER n. 1. A commercial user.  One who is paying ``real'' money
   for his computer usage.  2. A non-hacker.  Someone using the system
   for an explicit purpose (research project, course, etc.).  See
   USER.

REAL WORLD, THE n. 1. In programming, those institutions at which
   programming may be used in the same sentence as FORTRAN, COBOL,
   RPG, IBM, etc.  2. To programmers, the location of non-programmers
   and activities not related to programming.  3. A universe in which
   the standard dress is shirt and tie and in which a person's working
   hours are defined as 9 to 5.  4. The location of the status quo.
   5. Anywhere outside a university.  ``Poor fellow, he's left MIT and
   gone into the real world.''  Used pejoratively by those not in
   residence there.  In conversation, talking of someone who has
   entered the real world is not unlike talking about a deceased
   person. See also FEAR AND LOATHING and UNINTERESTING.

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

REGEXP (reg'exp) [UNIX] n. Common written and spoken abbreviation for
   `regular expression', one of the wildcard patterns used, e.g., by
   UNIX utilities such as grep(1), sed(1) and awk(1). These use
   conventions similar to but more elaborate than those described
   under GLOB.

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

RELIGIOUS ISSUES n. Questions which seemingly cannot be raised without
   touching off a FLAME WAR, such as ``What is the best
   editor/language/operating system/architecture''. See also THEOLOGY.

RELIGIOUS WAR from USENET, but may predate it] n.  FLAME WARS over
   RELIGIOUS ISSUES.

REPLICATOR n. Any construct that acts to produce copies of itself;
   this could be a living organism, an idea (see MEME), a program (see
   WORM, WABBIT and VIRUS), or a robot.

RETROCOMPUTING (ret'-roh-k at m-pyoo'ting) n. Refers to emulations of
   way-behind-the state-of-the-art hardware or software, or
   implementations of never-was-state-of-the-art; esp. if such
   implementations are elaborate practical jokes and/or parodies of
   more `serious' designs. Perhaps the most widely distributed
   retrocomputing utility was the pnch(6) program on V7 and other
   early UNIX versions, which would accept up to 80 characters of text
   argument and display the corresponding pattern in Hollerith card
   code. Other well-known retrocomputing hacks have included the
   language INTERCAL, a jcl-emulating shell for UNIX, and the
   card-punch-emulating editor named 029.

RFC (ahr ef see) n. Request For Comment. One of a long-established
   series of numbered Internet standards widely followed by commercial
   and PD software in the Internet and UNIX communities. Perhaps the
   single most influential one has been RFC-822 (the Internet
   mail-format standard). The RFCs are unusual in that they are
   floated by technical experts acting on their own initiative and
   reviewed by the Internet at large, rather than formally promulgated
   through an institution such as ANSI.

RICE BOX [from ham radio slang] n. Any Asian-made commodity computer,
   esp. an 8086, 80286, 80386 or 80486-based machine built to IBM
   PC-compatible ISA or EISA-bus standards.

RIGHT THING, THE n. That which is ``obviously'' the correct or
   appropriate thing to use, do, say, etc.  Use of this term often
   implies that in fact reasonable people may disagree.  ``Never let
   your conscience keep you from doing the right thing!''  ``What's
   the right thing for LISP to do when it reads `(.)'?''  Antonym: THE
   WRONG THING (q.v.).

ROACH [Bell Labs] v. To destroy, esp. of a data structure.  Hardware
   gets TOASTed, software gets roached.

ROBUST adj. Said of a system which has demonstrated an ability to
   recover gracefully from the whole range of exception conditions in
   a given environment. One step below BULLETPROOF.  Compare SMART,
   oppose BRITTLE.

ROGUE [UNIX] n. Graphic Dungeons-And-Dragons-like game written under
   BSD UNIX and subsequently ported to other UNIX systems. The
   original BSD curses(3) screen-handling package was hacked together
   by Ken Arnold to support ROGUE, and has since become one of UNIX's
   most important and heavily used application libraries. See HACK.

ROOM-TEMPERATURE IQ [IBM] 80 or below.  Used in describing the
   expected intelligence range of the LUSER. As in ``Well, but how's
   this interface gonna play with the room-temperature IQ crowd?'' See
   DROOL-PROOF PAPER.

RTFM (ahr-tee-ef-em) [UNIX] Abbrev. for ``Read The Fucking Manual''.
   Used by GURUs to brush off questions they consider trivial or
   annoying. Compare DON'T DO THAT, THEN.

RTI (ahr-tee-ie) interj. The mnemonic for the `return from interrupt'
   instruction on Intel microprocessors. Equivalent to ``Now, where
   was I?'' or used to end a conversational digression. See POP, POPJ.

RUDE [WPI] adj. 1. (of a program) Badly written.  2.  Functionally
   poor, e.g. a program which is very difficult to use because of
   gratuitously poor (random?) design decisions.  See CUSPY.

			= S =

SACRED adj. Reserved for the exclusive use of something (a
   metaphorical extension of the standard meaning).  ``Accumulator 7
   is sacred to the UUO handler.''  Often means that anyone may look
   at the sacred object, but clobbering it will screw whatever it is
   sacred to.

SADISTICS (s@'dis'tiks) n. University slang for statistics and
   probability theory, often used by hackers.

SAGA [WPI] n. A cuspy but bogus raving story dealing with N random
   broken people.

SAIL n. Stanford University Artificial Intelligence Lab. An important
   site in the early development of LISP (with the MIT AI LAB, CMU and
   the UNIX community) one of the major founts of hacker culture
   traditions. The SAIL machines were shut down in late May 1990,
   scant weeks after the MIT AI lab's ITS cluster went down for the
   last time.

SALT MINES n. Dense quarters housing large numbers of programmers
   working long hours on grungy projects, with some hope of seeing the
   end of the tunnel in N years.  Noted for their absence of sunshine.
   Compare PLAYPEN.

SANDBENDER [IBM] n. A person involved with silicon lithography and the
   physical design of chips. Compare IRONMONGER, POLYGON PUSHER.

SCIENCE-FICTION FANDOM n. Another voluntary subculture having a very
   heavy overlap with hackerdom; most hackers read SF and/or fantasy
   fiction avidly, and many go to ``cons'' (SF conventions) or are
   involved in fandom-connected activities like the Society for
   Creative Anachronism. Some hacker slang originated in SF fandom;
   see DEFENESTRATION, GREAT-WALL, CYBERPUNK, H INFIX, HA HA ONLY
   SERIOUS, IMHO, MUNDANE, NEEP-NEEP, REAL SOON NOW.  Additionally,
   the jargon terms CYBERSPACE, GO FLATLINE, ICE, VIRUS, and WORM
   originated in SF itself.

SCRATCH [from ``scratchpad''] 1. adj. A device or recording medium
   attached to a machine for testing purposes; one which can be
   SCRIBBLED on without loss. Usually in the combining forms SCRATCH
   MEMORY, SCRATCH DISK, SCRATCH TAPE, SCRATCH VOLUME. See SCRATCH
   MONKEY. 2. [primarily IBM] v. To delete (as in a file).

SCRATCH MONKEY n. As in, ``Before testing or reconfiguring, always
   mount a''. A proverb used to advise caution when dealing with
   irreplacable data or devices. Used in memory of Mabel, the Swimming
   Wonder Monkey who expired when a computer vendor PM'd a machine
   which was regulating the gas mixture that the monkey was breathing
   at the time. See Appendix A.  See SCRATCH.

SCREW [MIT] n. A LOSE, usually in software. Especially used for
   user-visible misbehavior caused by a bug or misfeature.

SCREWAGE (scroo'@j) n. Like LOSSAGE (q.v.) but connotes that the
   failure is due to a designed-in misfeature rather than a simple
   inadequacy or mere bug.

SCROG (skrog) [Bell Labs] v. To damage, trash or corrupt a data
   structure.  ``The cblock got scrogged.''  Also reported as SKROG,
   and ascribed to ``The Wizard of Id'' comix. Equivalent to SCRIBBLE
   or MANGLE (q.v.)

SCROZZLE (skroh'zl) v. Used when a self-modifying code segment runs
   incorrectly and corrupts the running program, or vital data.  ``The
   damn compiler scrozzled itself again!''

SCRIBBLE n. To modify a data structure in a random and unintentionally
   destructive way. ``Bletch! Somebody's disk-compactor program went
   berserk and scribbled on the i-node table.'' ``It was working fine
   until one of the allocation routines scribbled on low core.''
   Synonymous with TRASH; compare MUNG, which conveys a bit more
   intention, and MANGLE, which is more violent and final.

SEARCH-AND-DESTROY MODE n. Hackerism for the search-and-replace
   facility in an editor, so called because an incautiously chosen
   match pattern can cause INFINITE damage.

SECOND-SYSTEM SYNDROME n. When designing the successor to a relatively
   small, elegant and successful system, there is a tendency to become
   grandiose in one's success and perpetrate an ELEPHANTINE
   feature-laden monstrosity. The term `second-system syndrome' was
   first used for this affliction in describing how the success of
   CTSS led to the debacle that was MULTICS.

SEGGIE (seg'ee) [UNIX] n. Reported from Britain as a shorthand for
   `segment violation', an attempted access to a protected memory area
   usually resulting in a CORE DUMP.

SELF-REFERENCE n. See SELF-REFERENCE.

SELVAGE (selv'@j) n. See CHAD (sense #1).

SEMI (se'mee) 1. n. Abbreviation for ``semicolon'', when speaking.
   ``Commands to GRIND are prefixed by semi-semi-star'' means that the
   prefix is ``;;*'', not 1/4 of a star.  2. Prefix with words such as
   ``immediately'', as a qualifier.  ``When is the system coming up?''
   ``Semi-immediately.''

SERVER n. A kind of DAEMON which performs a service for the requester,
   which often runs on a computer other than the one on which the
   server runs. A particularly common term on the Internet, which is
   rife with ``name servers'' ``domain servers'' ``news servers''
   ``finger servers'' and the like.

SEX [Sun User's Group & elsewhere] n. 1.  Software EXchange. A
   technique invented by the blue-green algae hundereds of millions of
   years ago to speed up their evolution, which had been terribly slow
   up until then. Today, SEX parties are popular among hackers and
   others. 2. The rather Freudian mnemonic often used for Sign Extend,
   a machine instruction found in many architectures.

SHAREWARE n. FREEWARE for which the author requests some payment,
   usually in the accompanying documentation files or in an
   announcement made by the software itself. Such payment may or may
   not buy additional support or functionality. See GUILTWARE,
   CRIPPLEWARE.

SHELFWARE n. Software purchased on a whim (by an individual user) or
   in accordance with policy (by a corporation or government) but not
   actually required for any particular use.  Therefore, it often ends
   up on some shelf.

SHELL [from UNIX, now used elsewhere] n. 1. The command interpreter
   used to pass commands to an operating system.  2. More generally,
   any interface program which mediates access to a special resource
   or SERVER for convenience, efficiency or security reasons; for this
   meaning, the usage is usually A SHELL AROUND whatever.

SHELL OUT [UNIX] n. To spawn an interactive subshell from within a
   program such as a mailer or editor.  ``BANG FOO runs FOO in a
   SUBSHELL, while BANG alone shells out.''

SHIFT LEFT (or RIGHT) LOGICAL [from any of various machines'
   instruction sets] 1. v. To move oneself to the left (right).  To
   move out of the way.  2. imper. Get out of that (my) seat!  Usage:
   often used without the ``logical'', or as ``left shift'' instead of
   ``shift left''.  Sometimes heard as LSH (lish), from the PDP-10
   instruction set.

SHRIEK See EXCL.  Occasional CMU usage, also in common use among
   mathematicians, especially category theorists.

SIG (sig) or SIG BLOCK (sig blahk) [UNIX; often written ``.sig''
   there] n. Short for ``signature'', used specifically to refer to
   the electronic signature block which most UNIX mail- and
   news-posting software will allow you to automatically append to
   outgoing mail and news. The composition of one's sig can be quite
   an art form, including an ASCII logo or one's choice of witty
   sayings; but many consider large sigs a waste of bandwidth, and it
   has been observed that the size of one's sig block is usually
   inversely proportional to one's longevity and level of prestige on
   THE NETWORK.

SILICON n. Hardware, esp. ICs or microprocessor-based computer systems
   (compare IRON). Contrasted with software.

SILLY WALK [from Monty Python] v. A ridiculous procedure required to
   accomplish a task. Like GROVEL, but more RANDOM and humorous. ``I
   had to silly-walk through half the /usr directories to find the
   maps file.''

SILO n. The FIFO input-character buffer in an RS-232 line card. So
   called from DEC terminology used on DH and DZ line cards for the
   VAX and PDP-11.

SILVER BOOK, THE n. Jensen & Wirth's infamous ``Pascal User Manual and
   Report'', so called because of the silver cover of the
   widely-distributed Springer-Verlag second edition of 1978. See
   WHITE BOOK, PURPLE BOOK, ORANGE BOOK.

ROTARY DEBUGGER [Commodore] n.  Essential equipment for those late
   night or early morning debugging sessions.  Mainly used as
   sustenance for the hacker.  Comes in many decorator colors such as
   Sausage, Pepperoni, and Garbage. See ANSI-STANDARD PIZZA.

SLEEP [from the UNIX sleep(3)] On a timesharing system, a process
   which relinquishes its claim on the scheduler until some given
   event occurs or a specified time delay elapses is said to `go to
   sleep'.

SLOP n. 1. A one-sided fudge factor (q.v.).  Often introduced to avoid
   the possibility of a fencepost error (q.v.).  2. (used by compiler
   freaks) The ratio of code generated by a compiler to hand-compiled
   code, minus 1; i.e., the space (or maybe time) you lose because you
   didn't do it yourself.

SLOPSUCKER n. A lowest-priority task that must wait around until
   everything else has ``had its fill'' of machine resources.  Only
   when the machine would otherwise be idle is the task allowed to
   ``suck up the slop.'' Also called a HUNGRY PUPPY.  One common
   variety of slopsucker hunts for large prime numbers.  Compare
   BACKGROUND.

SLUGGY (sluh'gee) adj. Hackish variant of `sluggish'. Used only of
   people, esp.  someone just waking up after a long GRONK-OUT.

SLURP v. To read a large data file entirely into core before working
   on it.  ``This program slurps in a 1K-by-1K matrix and does an
   FFT.''

SMART adj. Said of a program that does the RIGHT THING (q.v.)  in a
   wide variety of complicated circumstances.  There is a difference
   between calling a program smart and calling it intelligent; in
   particular, there do not exist any intelligent programs (yet).
   Compare ROBUST (smart programs can be BRITTLE).

SMASH THE STACK [C programming] n. On many C implementations it is
   possible to corrupt the execution stack by writing past the end of
   an array declared auto in a routine. Code that does this is said to
   `smash the stack', and can cause return from the routine to jump to
   a random text address. This can produce some of the most insidious
   data-dependent bugs known to mankind.  Variants include `trash the
   stack', `SCRIBBLE ON the stack', `MANGLE the stack'; `MUNG the
   stack' is not used as this is never done intentionally.  See
   ALIASING BUG, FANDANGO ON CORE, MEMORY LEAK, PRECEDENCE LOSSAGE,
   OVERRUN SCREW.

SMILEY n. See EMOTICON.

SMOKE TEST n. 1. A rudimentary form of testing applied to electronic
   equipment following repair or reconfiguration in which AC power is
   applied and during which the tester checks for sparks, smoke, or
   other dramatic signs of fundamental failure. 2. By extension, the
   first run of a piece of software after construction or a critical
   change. See MAGIC SMOKE.

SMOKING CLOVER n. A DISPLAY HACK originally due to Bill Gosper.  Many
   convergent lines are drawn on a color monitor in AOS mode (so that
   every pixel struck has its color incremented).  The color map is
   then rotated.  The lines all have one endpoint in the middle of the
   screen; the other endpoints are spaced one pixel apart around the
   perimeter of a large square.  This results in a striking,
   rainbow-hued, shimmering four-leaf clover.  Gosper joked about
   keeping it hidden from the FDA lest it be banned.

SMOP (smop) [Simple (or Small) Matter of Programming] n. A piece of
   code, not yet written, whose anticipated length is significantly
   greater than its complexity.  Usage: used to refer to a program
   that could obviously be written, but is not worth the trouble.

SNAIL-MAIL n. Paper mail, as opposed to electronic. See EMAIL.

SNARF (snarf) v. 1. To grab, esp. a large document or file for the
   purpose of using it either with or without the author's permission.
   See BLT.  Variant: SNARF (IT) DOWN.  (At MIT on ITS, DDT has a
   command called :SNARF which grabs a job from another (inferior)
   DDT.) 2. [in the UNIX community] to fetch a file or set of files
   across a network.  See also BLAST.

SNARF & BARF (snarf-n-barf) n. The act of grabbing a region of text
   using a WIMP (q.v.) environment (Window, Icon, Mouse, Pointer) and
   then ``stuffing'' the contents of that region into another region
   or into the same region, to avoid re-typing a command line.

SNEAKERNET n. Term used (generally with ironic intent) for transfer of
   electronic information by physically carrying tape, disks, or some
   other media from one machine to another.  ``Never underestimate the
   bandwidth of a station wagon filled with magtape, or a 747 filled
   with CD-ROMs.'' Also called ``Tennis-Net'', ``Armpit-Net''.

SNIFF v.,n. Synonym for POLL.

S.O. (ess-oh) n. Acronym for Significant Other, almost invariably
   written abbreviated and pronounced ``ess-oh'' by hackers. In fact
   the form without periods ``SO'' is most common. Used to refer to
   one's primary relationship, esp. a live-in to whom one is not
   married.  See MOTAS, MOTOS, MOTSS.

SOFTCOPY n. [back-formation from `hardcopy'] A machine readable form
   of corresponding hardcopy. See BITS.

SOFTWARE ROT n. Hypothetical disease the existence of which has been
   deduced from the observation that unused programs or features will
   stop working after sufficient time has passed, even if ``nothing
   has changed''.  Also known as BIT DECAY, BIT ROT.  Occasionally
   this turns out to be a real problem due to media failure.

SOFTWARILY (soft-weir'i-lee) adv. In a way pertaining to software.
   ``The system is softwarily unreliable.''  The adjective
   ``softwary'' is NOT used.  See HARDWARILY.

SOME RANDOM X adj. Used to indicate a member of class X, with the
   implication that the particular X is interchangeable with most
   other Xs in whatever context was being discussed. ``I think some
   random cracker tripped over the guest timeout last night.''

SORCEROR'S APPRENTICE MODE n. A bug in a protocol where, under some
   circumstances, the receipt of a message causes more than one
   message to be sent, each of which, when received, triggers the same
   bug. Used esp. of such behavior caused by BOUNCE MESSAGE loops in
   EMAIL software. Compare BROADCAST STORM.

SPACEWAR n. A space-combat simulation game first implemented on the
   PDP-1 at MIT in 1960-61. SPACEWAR aficionados formed the core of
   the early hacker culture at MIT. Ten years later a descendant of
   the game motivated Ken Thompson to invent UNIX (q.v.). Ten years
   after that, SPACEWAR was commercialized as one of the first video
   games; descendants are still feeping in video arcades everywhere.

SPAGHETTI CODE n. Describes code with a complex and tangled control
   structure, esp. one using many GOTOs, exceptions or other
   `unstructured' branching constructs. Pejorative.

SPAGHETTI INHERITANCE n. [Encountered among users of object-oriented
   languages that use inheritance, such as Smalltalk] A convoluted
   class-subclass graph, often resulting from carelessly deriving
   subclasses from other classes just for the sake of reusing their
   code.  Coined in a (successful) attempt to discourage such
   practice, through guilt by association with SPAGHETTI CODE.

SPIFFY (spi'fee) adj. 1. Said of programs having a pretty, clever or
   exceptionally well-designed interface. ``Have you seen the spiffy X
   version of EMPIRE yet?'' 2. Said sarcastically of programs which
   are perceived to have little more than a flashy interface going for
   them. Which meaning should be drawn depends delicately on tone of
   voice and context.

SPIN v. Equivalent to BUZZ (q.v.). More common among C and UNIX
   programmers.

SPLAT n. 1. Name used in many places (DEC, IBM, and others) for the
   ASCII star (``*'') character.  2. [MIT] Name used by some people
   for the ASCII pound-sign (``#'') character.  3. [Stanford] Name
   used by some people for the Stanford/ITS extended ASCII circle-x
   character.  (This character is also called ``circle-x'',
   ``blobby'', and ``frob'', among other names.)  4. [Stanford] Name
   for the semi-mythical extended ASCII circle-plus character.  5.
   Canonical name for an output routine that outputs whatever the the
   local interpretation of splat is.  Usage: nobody really agrees what
   character ``splat'' is, but the term is common.

SPOOGE (spooj) 1. n. Inexplicable or arcane code, or random and
   probably incorrect output from a computer program 2. v. To generate
   code or output as in definition 1.

SPOOL v. To send files to some device or program (a `spooler') that
   queues them up and does something useful with them later. The
   spooler usually understood is the `print spooler' controlling
   output of jobs to a printer, but the term has been used in
   connection with other peripherals (especially plotters and graphics
   devices).

STACK n. See PDL. The STACK usage is probably more common outside
   universities.

STACK PUKE n. Some micros are said to ``puke their guts onto the
   stack'' to save their internal state during exception processing.
   On a pipelined machine this can take a while (up to 92 bytes for a
   bus fault on the 68020, for example).

STALE POINTER BUG n. Synonym for ALIASING BUG used esp. aming
   microcomputer hackers.

STATE n. Condition, situation.  ``What's the state of NEWIO?''  ``It's
   winning away.''  ``What's your state?''  ``I'm about to gronk
   out.''  As a special case, ``What's the state of the world?''  (or,
   more silly, ``State-of-world-P?'') means ``What's new?'' or
   ``What's going on?''

STIR-FRIED RANDOM alt. STIR-FRIED MUMBLE (ster-fried mum'bl) n. Term
   used for frequent best dish of those hackers who can cook. Consists
   of random fresh veggies and meat wokked with random spices. Tasty
   and economical.  See RANDOM, GREAT-WALL, CHINESE RAVS, ORIENTAL
   FOOD.

STOMP ON v.  To inadvertently overwrite something important, usually
   automatically.  Example: ``All the work I did this weekend got
   stomped on last night by the nightly-server script.'' Compare
   SCRIBBLE, MANGLE, TRASH, SCROG, ROACH.

STOPPAGE (sto'p at j) n. Extreme lossage (see LOSSAGE) resulting in
   something (usually vital) becoming completely unusable.

STUNNING adj. Mind-bogglingly stupid. Usually used in sarcasm. ``You
   want to code *what* in ADA? That's...a stunning idea!'' See also
   NON-OPTIMAL SOLUTION.

SUBSHELL [UNIX, MS-DOS] n. An OS command interpreter (see SHELL)
   spawned from within a program, such that exit from the command
   interpreter returns one to the parent program in a state that
   allows it to continue execution. Oppose CHAIN.

SUIT n. 1. Ugly and uncomfortable `business clothing' often worn by
   non-hackers. Invariably worn with a `tie', a strangulation device
   which partially cuts off the blood supply to the brain. It is
   thought that this explains much about the behavior of suit-
   wearers. 2. A person who habitually wears suits, as distinct from a
   techie or hacker. See LOSER, BURBLE and BRAIN-DAMAGED.

SUNSPOTS n. Notional cause of an odd error. ``Why did the program
   suddenly turn the screen blue?'' ``Sunspots, I guess''.  Also cause
   of bitrot, from the genuine, honest-to-god fact that sunspots will
   increase cosmic radiation which can flip single bits in memory.
   Needless to say, although real sunspot errors happen, they are
   extremely rare. See PHASE OF THE MOON.

SUN-STOOLS n. Unflattering hackerism for SunTools, a pre-X windowing
   environment notorious in its day for size, slowness and
   misfeatures.

SUPERPROGRAMMER n. See WIZARD, HACKER, GURU.  Usage: rare.  (Becoming
   more common among IBM and Yourdon types.)

SUZIE COBOL (soo'zee koh'bol) 1. [IBM, prob. fr. Frank Zappa's
   ``little Suzy Creamcheese''] n. A coder straight out of training
   school who knows everything except the benefits of comments in
   plain English.  Also (fashionable among personkind wishing to avoid
   accusations of sexism) `Sammy Cobol' 2. [generalization proposed by
   ESR] Meta-name for any CODE GRINDER, analogous to J. RANDOM HACKER.

SWAB [From the PDP-11 ``byte swap'' instruction] 1. v. to solve the
   NUXI PROBLEM by swapping bytes in a file. 2. Also, the program in
   V7 UNIX used to perform this action. See also BIG-ENDIAN,
   LITTLE-ENDIAN, BYTESEXUAL.

SWAPPED adj. From the use of secondary storage devices to implement
   virtual memory in computer systems.  Something which is SWAPPED IN
   is available for immediate use in main memory, and otherwise is
   SWAPPED OUT.  Often used metaphorically to refer to people's
   memories (``I read TECO ORDER every few months to keep the
   information swapped in.'') or to their own availability (``I'll
   swap you in as soon as I finish looking at this other problem.'').
   Compare PAGE IN, PAGE OUT.

SWIZZLE v. To convert external names or references within a data
   structure into direct pointers when the data structure is brought
   into main memory from external storage; also called POINTER
   SWIZZLING; the converse operation is sometimes termed UNSWIZZLING.

SYNC (sink) [from UNIX] n.,v. 1. To force all pending I/O to the disk.
   2. More generally, to force a number of competing processes or
   agents to a state that would be `safe' if the system were to crash;
   thus, to checkpoint. See FLUSH.

SYNTACTIC SUGAR n. Features added to a language or formalism to make
   it `sweeter' for humans, that do not affect the expressiveness of
   the formalism (compare CHROME). Used esp.  when there is an obvious
   and trivial translation of the `sugar' feature into other
   constructs already present in the notation.  Example: the \n, \t,
   \r, and \b escapes in C strings, which could be expressed as octal
   escapes. Coined by Peter Landin. ``Syntactic sugar causes cancer of
   the semicolon.'' - Alan Perlis.

SYS-FROG [the PLATO system] n. Playful hackish variant of ``sysprog''
   which is in turn short for ``systems-programmer''.

SYSTEM n. 1. The supervisor program on the computer.  2. Any
   large-scale program.  3. Any method or algorithm.  4. The way
   things are usually done.  Usage: a fairly ambiguous word.  ``You
   can't beat the system.''  SYSTEM HACKER: one who hacks the system
   (in sense 1 only; for sense 2 one mentions the particular program:
   e.g., LISP HACKER)