@heading(Introduction by Guy Steele) I was a teen-age hacker. When I was about twelve or so, a lab secretary at @mit who knew I was ``interested in science'' (it might be more accurate to say ``a latent nerd'') arranged for one of the computer hackers there to give me an informal tour. I remember stumbling around racks full of circuit boards and wires, a screeching cabinet that printed a full page every six seconds, and rows of blinking lights; the computer room was crammed full of equipment with no obvious organization. One set of gray cabinets had some trophies and plaques sitting on it; this was the PDP-6 computer that, running a program called MacHack, won prizes playing against human players in chess tournaments. The PDP-6 also had two speakers and a stereo amplifier sitting on top of it. The hacker typed a couple of commands on a keyboard, and the PDP-6 played Bach's Brandenburg concerto (number 6, as I recall). One part of that tour stands out most clearly in my mind. I was told to sit down in front of a large, round glass screen, and given a box that had some button and a stick on the top. The hacker typed another command on the keyboard, and suddenly two spaceships appeared on the screen! One was green and one was purple, and soon the purple one was shooting little red dots at the green one, which soon burst into a multicolored shower of sparkles. The green ship was ``mine'', and the hacker had expertly shot it down. Years later I learned that this had been a color version of Space War, one of the very first video games. Remember that this was years before ``Apple'' and ``TRS-80'' had become household words. Back then computers were still rather mysterious, hidden away in giant corporations and university laboratories. Playing Space War was fun, but I learned nothing of programming then. I had the true fascination of computers revealed to me in November, 1968, when a chum slipped me the news that our school (Boston Latin School, of Boston, Massachusetts) had an IBM computer locked up in the basement. I was dubious. Recently I had narrowly avoided buying from a senior a ticket to the fourth-floor swimming pool (Boston Latin has only three stories, and no swimming pool at all), and assumed this was another scam. So of course I laughed in his face. When he persisted, I checked it out. Sure enough, in a locked basement room was an IBM 1130 computer. If you want all the specs: 4096 words of memory, 16 bits per word, a 15-character-per-second Selectric (``golfball'') printer, and a card reader (model 1442) that could read 300 cards per minute. Yes, this was back in the days of punched cards. Personal computers were completely unheard of then. Nominally the computer was for the training of juniors and seniors, but I cajoled a math teacher into lending me a computer manual and spent all of Thanksgiving vacation reading it. I was hooked. No doubt about it. I was born to be a hacker. Fortunately, I didn't let my studies suffer (as many young hackers do), but evrry spare moment I thought about the computer. It was spellbinding. I wanted to know all about it: what it could and couldn't do, how its programs worked, what its circuits looked like. During study halls, lunch, and after school, I could be found in the computer room, punching programs onto cards and running them through the computer. I was not the only one. Very soon there was a small community of IBM 1130 hackers. In return for helping to maintain the computer and to tutor our less fanatical fellow students in the ways of computing, we hackers were given fairly free rein in the computer room. Soon after that I rediscovered @mit, just across the Charles River. I developed into one of the unauthorized but tolerated ``random people'' hanging around the @mit Artificial Intelligence Laboratory. Such a random hacker is to a computer laboratory much as a groupie is to a rock band: not really doing useful work, but emotionally involved and contributing to the ambience, if nothing else. After a while I was haunting the computer rooms at off-hours, talking to people but more often looking for chances to run programs. Sometimes ``high school randoms'' such as I were quite helpful, operating the computers for no pay and giving advice to college students who were having trouble. Sometimes, however, we were quite a nuisance. Once I was ejected from the Artificial Intelligence Laboratory by none other than Richard Greenblatt, a very famous hacker indeed, who wrote the MacHack program with which the PDP-6 had won its chess trophies. He threw me out because I was monopolizing the one terminal that produced letter-quality copy (I was using the computer as word processor to print customized form letters to various computer manufacturers, asking them to send me computer manuals). I deserved it, and gave him no argument. But when you're hooked, you're hooked, and I was undaunted; within a week or two I was back again. Although I wanted to go to @mit as a legitimate college student, for various personal reasons I wound up going to Harvard. While I got a fine education there, I was disappointed: people don't hack at Harvard. Harvard had some computers, all right, but for some reason the hacker culture hadn't flourished there. I did get a part-time job, though, at @mit@;'s Project MAC (another computer laboratory). Now an authorized computer user, I became a full-fledged member of the @mit hacker community. I stayed with this part-time job all through college, and then went on to @mit for graduate school. In all, I hung out at @mit from 1969 to 1980, as a high school random, then staff programmer, then graduate student, except for a stint as a programmer at the Artificial Intelligence Laboratory at Stanford University. By the way, I was never a lone hacker, but one of many. Despite stories you may have read about anti-social nerds glued permanently to display screens, totally addicted to the computer, hackers have (human) friends too. Through timesharing (where many people use one computer) and networking (where many computers are connected together), the computer makes possible a new form of human communication, better than the telephone and the postal system put together. You can send a message by electronic mail and get a reply within two minutes, or you can just link two terminals together and have a conversation. @mit had no monopoly on hackers. In the 1960's and 1970's hackers congregated around any computer center that made computer time available for ``play''. (Some of this play turned out to be very important work, but hacking is done mostly for fun, for its own sake, for the pure joy of it.) Because universities tend to be more flexible than corporations in this regard, most hackers' dens arose in university laboratories. While some of these hackers were unauthorized ``random people'' like me, many hackers were paid employees who chose to stay after hours and work on their own projects, or even continue their usual work, purely for pleasure. The hacker community became larger and more close-knit in the early 1970's when the government funded a project to see whether it would be useful and practical to let the computers at dozens of universities and other sites ``talk'' to each other. The project succeeded and produced the famous ARPANET, a network that now links hundreds of computers across the country. Through the ARPANET researchers can share programs, trade research results, and send electronic mail, both to individuals and to massive mailing lists. And it first allowed once isolated hackers to talk to each other, via computer. The result is a national hackers' community, a decade old. In some ways the community serves as a geographically dispersed think tank. I have many friends that I have never met face-to-face or talked to on the telephone. I feel I know them quite well, though, because I've had extended conversations with them through the computer. (I had one friend through the computer who worked in the same building that I did, but I never knew he was deaf until I chanced to meet him face-to-face several months later!) When you walk up to the terminal of a time-shared computer, the first thing you do is to ``log in'', that is, tell the computer who you are. To do this you type in your ``computer id'' or ``login name''. Different computers have different ideas of what a login name should be. Some use numbers or other codes (see the entry for the word @wd[PPN]), some use your last name, some use your initials. For technical reasons the PDP-10 encourages the use of login names that are limited to either three or six characters, so full names or last names can't be used in general. As a result everyone acquires an extra name, their login name. You need to know that name to communicate with another hacker via computer. A login name serves in much the same way as a CB ``handle''. I have friends that I know @i[only] by login name; I have no idea what their real names are. (Once, at a wedding, I ran into a hacker friend who was also a guest; I recalled his login name instantly, but was embarrassed that I couldn't immediately remember his real name in order to introduce him to a third person. It was @wd[SWAPPED OUT].) Login names are often used as nicknames, pronounced if possible and spelled if necessary. My wife and I met at @mit, and she still calls me ``Gliss'', because my login name was GLS; ``Guy'' sounds very weird to her. Some hackers (including Richard Stallman) actually prefer to be called by their login name. In these and other ways, the working and social life of the hacker revolves primarily around the computer. @Newpage @heading[Hacker Grammar] For the most part, hackerese fits within the framework of ordinary English grammar. There are a few rules, however, that are unusual in everyday English but are very commonly used in hacker speech. (These extra rules reflect the fact that hackers enjoy playing with language. Most are quite aware of when they are breaking the rules of standard English.) @subheading[Verb doubling] A standard construction in English is to double a verb and use it as an exclamation, such as ``bang, bang!'' or ``quack, quack!''. Most of these are names for noises. Hackers also double verbs as a concise, sometimes sarcastic comment on what the implied subject does. Also, a doubled verb is often used to terminate a conversation, in the process remarking on the current state of affairs or what the speaker intends to do next. Verbs frequently doubled include @wd[WIN], @wd[LOSE], @wd[HACK], @wd[FLAME], @wd[BARF], and @wd[CHOMP]. Typical examples of usage: @Begin[Itemize] ``The disk heads just crashed.'' ``Lose, lose.'' ``Mostly he just talked about his latest crock. Flame, flame.'' ``I think I'll go fix that bug now. Hack, hack!'' @End[Itemize] Standard doublings with subtle connotations are listed individually in the lexicon. @subheading[Soundalike slang] In the manner of Cockney rhyming slang, hackers will often make rhymes or puns in order to convert an ordinary word or phrase into something more interesting. It is particularly @wd[FLAVORFUL] if the phrase is bent so as to include some other slang word; thus the computer hoobyist magazine ``Dr. Dobb's Journal'' is almost always referred to among hackers as ``Dr. Frob's Journal''. Terms of this kind in fairly wide use include names for newspapers: @Begin[Itemize] ``Boston Herald American'' becomes ``Horrid (or Harried) American'' ``Boston Globe'' becomes ``Boston Glob'' ``San Francisco Chronicle'' becomes ``the Crocknicle'' ``New York Times'' becomes ``New York Slime'' @End[Itemize] Other standard terms include: @Begin[Itemize] ``for historical reasons'' becomes ``for hysterical raisins'' ``Margaret Jacks Hall'' (a building at @stanford) becomes ``Marginal Hacks Hall'' ``government property--do not duplicate'' (seen on keys at @mit) is usually quoted as ``government duplicity--do not propagate'' @End[Itemize] @subheading[The -P convention] This rule is unique, used by no one but hackers. A word or phrase is turned into a yes/no question by appending the letter ``P'', which is pronounced as a separate syllable when spoken. This rule is derived from a convention of the @c[LISP] programming language, where the letter ``P'' at the end of a name denotes a ``predicate'', that is, a function that returns true or false as its result. For example, the question ``Foodp?'' (pronounced (food'pee), with the voice rising as for any question) means ``Do you want to eat now?'' The question ``Colleen's-p?'' is more specific: ``Do you want to go eat at Colleen's Chinese Cuisine (a favorite resturant near @mit).'' ``Lose-p?'' means ``Are you @wd[LOSING]?'' or ``Is it @wd[LOSING]?'', and so on. As a special case, the question ``State-of-the-world-p?'' means ``What's going on?'' or ``What are you doing (or about to do)?'' The -P convention is used for this even though it isn't a yes/no question. A typical answer might be ``The @wd[SYSTEM] just @wd[CRASHED]'' or ``I'm about to @wd[GRONK OUT].'' If the responder is feeling silly or obstinate, however, he will insist on interpreting it as a yes/no question after all, and respond, ``Yes, the world has a state.'' The -P convention is often applied to new words at the spur of the moment. The best of these is a @wd[GOSPERISM] (that is, invented by R. William 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?'' and everyone instantly knew what he meant (after all, split pea soup was not on the menu). @subheading[Overgeneralization] Hackers love to take advantage of the inconsistencies of English by extending a general rule to cases where it doesn't apply. @Begin[Format] @tabdivide(2) @>``generous'' @\becomes ``generosity'' @>``porous'' @\becomes ``porosity'' @>``curious'' @\becomes ``curiosity'' Therefore: @>``mysterious'' @\becomes ``mysteriosity'' @>``obvious'' @\becomes ``obviosity'' @>``dubious'' @\becomes ``dubiosity'' Less clearly, @>``bogus'' @\becomes ``bogosity'' and, perhaps, @>``ferrous'' @\becomes ``ferocity''! @End[Format] Other examples: winnitude, disgustitude, hackitude, hackification. @subheading[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 conversation by computer (see @wd[COM MODE]); one gets so used to typing ``Sigh!'' to indicate a sigh that one soon develops the oral habit of saying the word instead of actually sighing. Another expression sometimes heard is ``complain!'' (meaning not ``you, complain!'' but ``I have a complaint!''). @newpage @begin[CRUFT] @Wordentry[ANGLE BRACKET] @noun Either of the characters ``@f[<]'' and ``@f[>]'', when used as bracketing characters rather than to mean ``less than'' and ``greater than''. Individually they are called @wd[LEFT ANGLE BRACKET] and @wd[RIGHT ANGLE BRACKET], or @wd[OPEN ANGLE BRACKET] and @wd[CLOSE ANGLE BRACKET]. Synonym: @wd[BROKET]. See @wd[CHARACTERS]. [In mathematics, the ``less than'' and ``greater than'' signs are very sharp and pointy, while angle brackets are very shallow. Computer printers, however, usually provide only one pair of characters, not two, that are about halfway between the two kinds mathematicians use.] [The term @wd[ANGLE BRACKET] is more popular at @mit, while @wd[BROKET] is more popular at @Stanford. Sometimes the word @wd[BRACKET] is omitted for brevity.] @Wordentry[AOS] (owss (East coast), ay'ahss (West coast)) @verb @Begin[Defns] To add one to a number. Example: ``Every time the computer finds a bad file it aoses the bad-file counter.'' More generally, to increase the amount of something. Example: ``Aos the campfire.'' [``Add more wood to the campfire.''] @silly @End[Defns] Antonym: @wd[SOS]. @Wordentry[ARG] (ahrg) @noun An argument, in the mathematical sense only: a quantity accepted by a function or procedure. Example: ``The sine function takes one arg, but the arc-tangent function can takes either one or two args.'' [This is an abbreviation that has become a new word in its own right, just as ``telephone'' and ``pianoforte'' have become ``phone'' and ``piano''. Arguments to mathematical functions and computational procedures are discussed so frequently by hackers that this abbreviation saves a lot of time.] @Wordentry[AUTOMAGICALLY] (aw'toh-maj'i-k:l-lee) @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. Example: ``Files that have a name ending in `TMP' are automagically deleted when you log out.'' [This means ``When you say goodbye to the computer, files with names ending in `TMP' are deleted. How this happens is complicated and I don't want to get into it just now. Trust me, it works.''] See @wd[MAGIC]. @Wordentry[BAGBITER] (bag'bie-t:r) @noun @pej @Begin[Defns] 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!'' A person who has caused you some trouble, inadvertently or otherwise, typically by failing to program the computer properly. @End[Defns] Synonyms: @wd[LOSER], @wd[CRETIN], @wd[CHOMPER]. @word[BAGBITING] @adj Having the quality of a bagbiter. ``This bagbiting system won't let me compute the factorial of a negative number.'' Synonyms: @wd[LOSING], @wd[CRETINOUS], @wd[BLETCHEROUS], @wd[BARFUCIOUS], @wd[CHOMPING]. @Word[BITE THE BAG] @verb To fail in some manner. Example: ``The computer keeps crashing every five minutes.'' ``Yes, the disk controller is really biting the bag.'' [The original meaning of this term was almost undoubtedly obscene, probably referring to the scrotum, but in its current usage it has become almost completely sanitized.] @Wordentry[BANG] @noun The character ``@f[!]'' (exclamation point). Synonyms: @wd[EXCL], @wd[SHRIEK]. See @wd[CHARACTERS]. [This term is more popular at @cmu than at @mit or @Stanford. This term is used to describe the character ``!'' itself rather than to replace it. For example, one would not say ``Congratulations bang.'' On the other hand, I wanted you to write ``FOO!'', those exact four characters, on a piece of paper, I would tell you ``Write eff, oh, oh, bang.''] @Wordentry[BAR] The second metasyntactic variable, after @wd[FOO]. If a hacker needs to invent exactly two names for things, he almost always picks the names @wd[FOO] and @wd[BAR]. Example: ``Suppose we have two functions, say FOO and BAR. Now suppose FOO calls BAR...'' See @wd[METASYNTACTIC VARIABLE], @wd[FOO], @wd[FOOBAR]. @Wordentry[BARF] @Begin[Defns] @interj Term of disgust or frustration. See @wd[BLETCH]. @verb To say ``Barf!'' or a similar term of disgust (because one is annoyed or offended). To fail to work because of unacceptable input; sometimes, to print an error message. Examples: ``The division operation barfs if you try to divide by zero.'' [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.'' @End[Defns] @wd[BARFULOUS], @wd[BARFUCIOUS] @adj So ugly or offensive as to make someone barf. [These meanings are derived the common slang meaning of ``barf'', namely ``to vomit''.] @Wordentry[BELLS AND WHISTLES] @noun Unnecessary (but often useful, convenient, or amusing) features of a program or other object. Example: ``Now that we've got the basic program working, let's go back and add some bells and whistles.'' On an automobile, things like power windows and and quadraphonic sound would be bells and whistles. [This term is widely used, and not just in the hacker community. To understand it, think of a plain box that does a job well, but is awfully boring to look at. Who will buy it? Now you add a few bells and whistles. They don't do anything useful, but they make the product more interesting. Nobody seems to know what distinguishes a bell from a whistle.] @Wordentry[BIGNUM] (big'num) @noun @Begin[Defns] 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. @End[Defns] See @wd[EL CAMINO BIGNUM]. [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@+[15] (32767) or 2@+[31] (2147483648). 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 2@+[1000] or 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 @c[MACLISP] system using bignums: @Begin[Format] 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 @End[Format] The @c[MACLISP] language was not the first computer system to calculate very large integers, but it was @c[MACLISP] that provided the name ``bignum''.] @Wordentry[BIT] @noun @Begin[Defns] The unit of information; the amount of information obtained by asking a yes-or-no question. A computational quantity that can take on one of two values, such as true and false, or zero and one. 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.] @Word[BITS] Information. Examples: ``I need some bits about file formats.'' [``I need to know about file formats.''] @End[Defns] [A bit is said to be @wd[SET] if its value is true or one, and @wd[RESET] or @wd[CLEAR] if its value is false or zero. One speaks of setting and clearing bits. To @wd[TOGGLE] a bit is to change it, either from zero to one or from one to zero.] @word[THE SOURCE OF ALL GOOD BITS] @noun A person from whom (or a place from which) information may be obtained. If you need to know about a program, a @wd[wizard] might be the source of all good bits. The title is often applied to a particularly competent secretary. @Wordentry[BITBLT] (bit'blit) @Begin[Defns] @verb To copy a large array of bits from one part of a computer's memory to another part, particularly when the memory is being used to determine what is shown on a display screen. More generally, to perform some operation (such as toggling) on a large array of bits while moving them. @noun The operation of @wd[BITBLTING]. @End[Defns] See @wd[BLT]. @Wordentry[BIT BUCKET] @noun @Begin[Defns] The mythical receptacle used to catch bits when they fall off the end of a register during a shift instruction. More generally, the place where information goes when it is lost or destroyed. Example: ``Oh, no! All my files just went into the bit bucket!'' The physical device used to implement output to the @wd[NUL DEVICE]. @End[Defns] [This term is used purely in jest. It's based on the fanciful notion that bits are objects that are not destroyed, but only misplaced.] @Wordentry[BIT DECAY] @noun A fanciful theory that explains the phenomenon of @wd[SOFTWARE ROT], which is that that unused programs or features will eventually stop working even if ``nothing has changed''. The theory explains that bits decay as if they were radioactive. As time passes, the contents of a file or the code in a program will become increasingly garbled. @Wordentry[BLETCH] (bletch) @interj Term of disgust. @word[BLETCHEROUS] @adj Disgusting in design or function; aesthetically unappealing. [This word is seldom used of people.] Example: ``This keyboard is bletcherous!'' [Perhaps the keys don't work very well, or are misplaced.] @i[Slightly comic.] See @wd[LOSING], @wd[CRETINOUS], @wd[BAGBITING], @wd[BOGUS], and @wd[RANDOM]. [@wd[BLETCHEROUS] applies to the aesthetics of the thing so described; similarly for @wd[CRETINOUS]. By contrast, something that is @wd[LOSING] or @wd[BAGBITING] may be failing to meet objective criteria. See @wd[BOGUS] and @wd[RANDOM], which have richer and wider shades of meaning than any of the others.] @Wordentry[BLT] (blit, belt) @verb To copy or transfer a large contiguous package of information from one place to another. ``The storage allocator picks through the table and copies the good parts up into high memory, and at the end @wd[BLT]'s it all back down again.'' @Wordentry[BOGUS] (boh'guss) @adj @Begin[Defns] Non-functional. Example: ``Your fix for that bug was bogus.'' Useless. Example: ``OPCON is a bogus program.'' False. Example: ``Your arguments are bogus.'' Incorrect. Example: ``That algorithm is bogus.'' Unbelievable. Example: ``You claim to have solved the halting problem for Turing Machines? That's totally bogus.'' Silly. Example: ``Stop writing those bogus sagas.'' @End[Defns] Astrology is bogus. So is a bolt that is obviously about to break. So is someone who makes blatantly false claims to have solved a scientific problem. @Word[BOGOSITY] (boh-gahss':t-ee) @noun The quality of being @wd[BOGUS]; also an instance or example thereof. @Word[BOGON] (boh'gahn) @noun @Begin[defns] A person who is bogus or who says bogus things. More rarely, a mythical subatomic particle that bears the unit charge of bogosity. [A convention in particle physics is to name new subatomic particles by using the Greek suffix ``on'', because Greek words were originally used to name such particles; for example, hadrons are very massive particles that were named from the Greek word ``hadros'' meaning ``heavy''. More recently, however, physicists have taken to attaching this suffix to words from other languages. For example, the particles that help to hold quarks together are called ``gluons'' from the English word ``glue''. Hackers have used this convention in fun on an ad hoc basis, but two of them, @wd[BOGON] and @wd[COMPUTRON], are used fairly regularly.] @End[defns] @Word[BOGOMETER] (boh-gahm':t-:r) @noun A mythical instrument used to measure bogosity, much as a thermometer measures temperature. Example: in a seminar, when a speaker makes an outrageous claim, a listener might raise his hand and say, ``My bogometer just triggered.'' Someone who is a bogon in the first sense probably radiates a lot of bogons in the second sense. This provides a (pseudo-)scientific explanation for how a bogometer works: it's like a Geiger counter that detects bogons. The agreed-upon unit of bogosity is the microLenat (uL), in honor of computer scientist Doug Lenat. The general consensus is that this unit is the largest that is practical for everyday use. @word[BOGOTIFY] (boh-gaht':f-ie) @verb To make or become bogus. A program that has been changed so many times as to become completely disorganized has become bogotified. If you tighten a nut too hard and strip the threads on the bolt, the bolt has become bogotified and you'd better not use it any more. @word[AUTOBOGOTIPHOBIA] (aw'to-boh-gaht':-foh'bee-uh) @noun The fear of becoming bogotified. [@wd[BOGUS] has many, but not all, of the meanings of @wd[RANDOM]. @wd[RANDOM] tends to connote pointlessness or a lack of direction, while @wd[BOGUS] tends to connote deception or misdirection. Both, however, may connote confusion. @wd[BOGUS] was originally used (in the hacker sense) at Princeton, in the late 1960's, not just in the Computer Science department, but all over campus. It came to Yale and (we assume) elsewhere through the efforts of migratory Princeton alumni, in particular Michael Shamos, now a faculty member at @cmu. The hacker usage of this word has since spread to other places.] @Wordentry[BOUNCE] @verb To play volleyball. [This term is, or was, used primarily at @stanford. At one time there was a volleyball court next to the computer laboratory. From 5:00 PM to 7:00 PM was the scheduled maintenance time for the computer, so every afternoon at 5:00 the computer would become unavailable, and over the intercom a voice would cry , ``Bounce, bounce!'' meaning ``Everyone come out and play volleyball!''] @Wordentry[BRAIN-DAMAGED] @adj Obviously wrong; extremely poorly designed; cretinous; demented. [There is a connotation that the person responsible must have suffered brain damage, because he should have known better. Calling something brain-damaged is really extreme. The word implies that it is completely unusable, and that its failure to work is due to poor design rather than some accident.] @Wordentry[BREAK] @verb @Begin[Defns] To become @wd[BROKEN] (in any sense). To cause to be @wd[BROKEN] (in any sense). ``Your latest patch to the editor broke the paragraph commands.'' Of a program, to halt or pause temporarily so that it may be examined for debugging purposes. The place where the program stops is called a @wd[BREAKPOINT]. @End[Defns] @Wordentry[BROKEN] @adj @Begin[Defns] Of programs, not working properly. ``The @c[FORTRAN] compiler is broken.'' Behaving strangely; especially (of people), exhibiting extreme depression. @End[Defns] @Wordentry[BROKET] (broh'k:t, broh'ket) @noun Either of the characters ``@f[<]'' and ``@f[>]''. The first is called a @wd[LEFT BROKET], and the second a @wd[RIGHT BROKET]. Synonym: @wd[ANGLE BRACKET]. [This word originated as a contraction of the phrase ``broken bracket'', that is, a bracket that is bent in the middle.] @Wordentry[BUCKY BITS] @noun Bits corresponding to ``control'' and ``meta'' keys on a keyboard. See @wd[DOUBLE BUCKY] and @wd[QUADRUPLE BUCKY]. [This phrase requires a long explanation. Most computer keyboards are arranged more or less like a typewriter keyboard, but have extra keys. One of them, usually marked ``control'' or ``CTRL'', is like a shift key, but instead of changing letters from lower case to upper case, it changes them into so-called ``control characters''. The character sent when you hold down the control key and type F is called simply ``control-F''. Such characters are usually used as commands to the computer, especially to a text editor. In one well-known text editor, @c[EMACS] (which was written at @mit), control-F moves forward one character, control-N moves to the next line, control-P moves to the previous line, control-D deletes a character, and so on. Control characters are so useful that sometimes special keyboards are built that have even more shift keys. One of the first of these was used at @stanford; it had the usual shift and control keys and a third key called ``meta'', as well as lots of unusual characters such as Greek letters. So one can type such characters as control-F, meta-N, control-meta-B, and so on. Now, when you type a character on a @stanford keyboard, the following information is sent to the computer: a code indicating the basic character, plus one @wd[BIT] for each shifting key, indicating whether that shifting key was pressed along with the basic character key. Programs usually treat the regular shift key as part of the basic character, indicating whether you want lower case or upper case (or whether you want ``@f[3]'' or ``@f[#]'', and so on). The other bits (control and meta) are called the @wd[BUCKY BITS]. Why ``Bucky''? Rumor has it that the idea for extra bits for characters came from computer scientist Niklaus Wirth (who invented the computer languages @c[PASCAL] and @c[MODULA-2]) when he was at @stanford, and that his nickname was ``Bucky''. Inspired by the @Stanford keyboard, the @mit @wd[SPACE CADET KEYBOARD] has @i[seven] shifting keys: four ``bucky bit'' keys @i[control], @i[meta], @i[hyper], and @i[super]; and three like the regular shift key, called @i[shift], @i[top], and @i[front]. Many keys have three symbols on them: a letter and a symbol on the top, and a Greek letter on the front. For example, the ``L'' key has an ``L'' and a two-way arrow on the top, and the Greek letter lambda on the front. If you press this key with the right hand while playing an appropriate ``chord'' with the left hand on the shift keys, you can get the following results: @Begin[Format] @Tabdivide(2) L@\lower-case ``l'' shift-L@\upper-case ``L'' front-L@\Greek lower-case lambda ``@g(l)'' front-shift-L@\Greek upper-case lambda ``@g(L)'' top-L (front and shift are ignored)@\two-way arrow @End[Format] And of course each of these may also be typed with any combination of the control, meta, hyper, and super keys. On this keyboard you can type over 8000 different characters! This allows the user to type very complicated mathematical text, and also to have thousands of single-character commands at his disposal. Many hackers are actually willing to memorize the command meanings of that many characters if it will reduce typing time. Other hackers, however, think having that many bucky bits is overkill, and object that such a keyboard can require three or four hands to operate.] @Wordentry[BUG] @noun A mistake or problem (possibly simple, possible very deep); an unwanted and unintended property, characteristic, or behavior. Examples: ``There's a bug in the editor: it writes things out backwards.'' ``The system @wd[CRASHED] because of a hardware bug.'' [That is, the computer suddenly stopped because of an equipment failure.] ``Fred is a winner, but he has a few bugs.'' [Fred is a good guy, but he has a few personality problems.] Antonym: @wd[FEATURE]. This is usually thought of as applying to a program, but can be applied to computers, people, and other things. Some say this term came from telephone company usage: ``bugs in a telephone cable'' were blamed for noisy lines. However, computer scientist Jean Sammet has repeatedly been heard to claim that the use of the term in computer science comes from a story concerning actual bugs found wedged in an early malfunctioning computer. In any case, in hacker's slang the word almost never refers to insects. Here is a plausible conversation that never actually happened: ``This ant-farm has a bug.'' ``What do you mean? There aren't even any ants in it.'' ``That's the bug.'' @Wordentry[BUM] @Begin[Defns] @verb To improve something by removing or rearranging its parts, such as wires in a computer or instructions from a program, while preserving its function. More generally, to make highly efficient, either in time or space. The connotation is that this is done at the expense of clarity. Examples: ``I managed to bum three more instructions out of that code.'' ``I bummed the program not to write the file if it would be empty.'' ``I bummed the inner loop of the program down to seven microseconds.'' @noun A small change to an algorithm, program, or object to make it more efficient. ``This hardware bum makes the jump instruction faster.'' @End[Defns] @Wordentry[BUZZ] @verb Of a program, to run with no indication of progress and perhaps without guarantee of ever finishing. The state of a buzzing program resembles @wd[CATATONIA], but you never get out of catatonia, while a buzzing loop may eventually end of its own accord. Example: ``The program buzzes for about ten seconds trying to sort all the names into order.'' @Wordentry[CANONICAL] @adj Usual; standard; ordinary. Examples: ``What is the canonical way to rejustify a paragraph in @c[EMACS]?'' This word has a somewhat more technical meaning in mathematics. For example, one sometimes speaks of a formula as being in canonical form. Two formulas such as ``9+3x@+(2)+x'' and ``3x@+(2)+x+9'' are said to be equivalent because they mean the same thing, but the second one is in canonical form because it is written in the usual way, with the highest power of x first. Usually there are fixed rules you can use to decide whether something is in canonical form. The slang meaning is a relaxation of the technical meaning. A true story: One Bob Sjoberg, new at @mit, expressed some annoyance at the use of hacker's slang. Over his loud objections, we made a point of using the slang as much as possible in his presence, and eventually it began to sink in. Finally, in one conversation, he used the word ``canonical'' in slang-like fashion without thinking. Steele: ``Aha! We've finally got you talking jargon [slang] too!'' Stallman (who wasn't quite paying attention): ``What did he say?'' Steele: ``Bob just used `canonical' in the canonical way.'' @Wordentry[CATATONIA] (kat':-toh'nee-uh) @noun A condition of suspended animation in which something is so @wd[WEDGED] that it makes no response. For example, if you are typing on your terminal and suddenly the computer doesn't even make the letters appear on the screen as you type, let alone do what you're asking it to do, then the computer is suffering from catatonia (probably because it has @wd[CRASHED]). @Wordentry[CDR] (ku'd:r) @begin[defns] @verb To remove the first item from a list of things. @word[CDR DOWN]: @verb To go down a list of things, one by one. Example: ``Shall we cdr down the agenda?'' @silly @end[defns] [This term is derived from a function of the @c[LISP] language that removes an item from a list.] @Wordentry[CHOMP] (chahmp) @verb To lose; to chew on something of which more was bitten off than one can. Synonyms: @wd[LOSE], @wd[BITE THE BAG] (see @wd[BAGBITER]). [A hand gesture commonly accompanies the use of the word @wd[CHOMP], consisting of the four fingers held together as if in a mitten or hand puppet, and the fingers and thumb open and close rapidly to illustrate a biting action. The hand may be pointed at the object of complaint, and for real emphasis you can use both hands at once. For example, to do this to a person is equivalent to saying ``You chomper!'' If you point the gesture at yourself, it is a humble but humorous admission of some failure. I would do this if someone told me that a program I had written had failed in some surprising way and I felt dumb for not having anticipated it.] @wordentry[CHOMPER] (chahmp':r) @noun Someone or something that is chomping; a loser. Synonyms: @wd[LOSER], @wd[BAGBITERP]. See @wd[CHOMP]. @Wordentry[CLOSE] (klohz) @begin(defns) @adj Of a delimiting character, used at the right-hand end of a grouping. Used in such terms as ``close parenthesis'', ``close bracket'', etc. @noun Abbreviation for ``close (or right) parenthesis'', used when necessary to eliminate oral ambiguity. See @wd[OPEN] and @wd[CHARACTERS]. @verb To terminate one's interaction with a file of information. See @wd[OPEN]. @end[defns] [Note that in these uses the word @wd[CLOSE] is always pronounced with a ``z'' sound, never an ``s'' sound. One might speculate that the term ``close parenthesis'' rather than ``closed parenthesis'' came into use because it originated as a verbal command to close a parenthetical remark, and only later came to be applied to the symbol used for this purpose.] @Wordentry[COKEBOTTLE] (kohk'baht-:l) @noun Any very unusual character, particularly one that isn't on your keyboard so you can't type it. A program written at @stanford, for example, is likely to have a lot of ``control-meta-cokebottle'' commands, that is, commands that you can only type on a @stanford keyboard because you need the control and meta keys (see @wd[BUCKY BITS]) and also unusual characters such as the downward-pointing arrow. The latter is a ``cokebottle'' unless you happen to have a @stanford keyboard. [This usage probably arose because of the unusual and distinctive shape of Coca-Cola bottles. No keyboard I know of actually has a cokebottle character on it, so any character you can't type might as well be a cokebottle for all the good it does you.] @Wordentry[COM MODE, COMM MODE] (kahm' mohd) @noun A situation in which two or more terminals are linked together by the computer so that whatever is typed on any of them appears on all of them. Ideally this is accomplished in such a way that what you type appears on the other terminals but is not otherwise interpreted by the computer (so what you type doesn't foul up your programs). (The word @wd[COM] is short for ``communicate''.) @wd[COM MODE] is used for conversation; you can talk to other hackers without leaving your terminal. It combines the immediacy of talking with all the precision (and verbosity) that written language entails. It is difficult to communicate inflection, though conventions have arisen for some of these. For example, to emphasize a word (as if printed in italics) one may type an asterisk before and after the word. Typing in all-capital letters is equivalent to raising one's voice. Neophytes, when in @wd[COM MODE], seem to think they must produce letter-perfect prose because they are typing rather than speaking. This is not the best approach. It can be very frustrating to wait while your partner pauses to think of a word, or repeatedly makes the same spelling error and backs up to fix it. It is usually best just to leave typographical errors behind and plunge forward, unless severe confusion may result; in that case it is often fastest just to type ``xxx'' and start over from before the mistake. There is a special set of slang terms used only in com mode, which are not used orally. These are used to save typing or to communicate inflection. @Begin[Description] @word[BCNU]@\Be seeing you (that is, goodbye). @word[BTW]@\By the way... @word[BYE?]@\Are you ready to unlink? (This is the standard way to end a com mode conversation; the other person types @wd[BYE] to confirm, or else continues the conversation.) @word[CUL]@\See you later. @word[FOO?]@\A greeting, also meaning @wd[R U THERE?] Often used in the case of unexpected links, meaning also ``Sorry if I butted in'' (linker) or ``What's up?'' (linkee). @word[FYI]@\For your information... @word[GA]@\Go ahead (used when two people have tried to type simultaneously; this cedes the right to type to the other). @word[HELLOP]@\A greeting, also meaning @wd[R U THERE?] (This is an instance of the @wd[-P CONVENTION].) @word[NIL]@\No (see the main entry for @wd[NIL]). @word[OBTW]@\Oh, by the way... @word[R U THERE?]@\Are you there? @word[SEC]@\Wait a second (sometimes written SEC...). @word[T]@\Yes (see the main entry for @wd[T]). @word[TNX]@\Thanks. @word[TNX 1.0E6]@\Thanks a million (``1.0E6'' is a standard way to write one million in many computer languages). @silly @\When the typing party has finished, he types two @wd[CRLF]'s (that is, presses the RETURN key twice) to signal that he is done. This leaves a blank line between individual ``speeches'' in the conversation, making it easier to re-read the preceding text, and indicates that the other person may type. :@\When three or more terminals are linked, each speech is preceded by the typist's login name (``computer id'') and a colon (or a hyphen) to indicate who is typing. You need to do this because you can't tell who is who by tone of voice! The login name often is shortened to a unique prefix (possibly a single letter) during a very long conversation. @wd[/\/\/\]@\The equivalent of a giggle. @End[Description] Synonym: @wd[TALK MODE]. (The term @wd[COM MODE] is used more at @mit, and @wd[TALK MODE] at @stanford.) @Wordentry[CONNECTOR CONSPIRACY] @noun The (perhaps only mythical) tendency of manufacturers (or, by extension, programmers or purveyors of anything) to come up with new products that don't fit together with the old stuff, thereby making you buy either all new stuff or expensive interface devices. [This term probably came into prominence with the appearance of the KL-10 model of PDP-10, none of whose connectors seemed to match anything else.] @Wordentry[CONS] (kahnz) @Begin[Defns] @verb To add a new element to a list, usually to the top rather than at the bottom. @word[CONS UP]: @verb To synthesize from smaller pieces; more generally, to create or invent. Examples: ``I'm trying to cons up a list of volleyball players.'' ``Let's cons up an example.'' @End[Defns] This term comes from the @c[LISP] programming language, which has a function called CONS that adds a data item to the front of a list. @Wordentry[CRASH] @Begin[Defns] @noun A sudden, usually drastic failure. Most often said of the @wd[SYSTEM], sometimes of magnetic disk drives. Example: ``Three @wd[LUSERS] lost their files in last night's disk crash.'' The term ``system crash'' usually, though not always, implies that the operating system or other software was at fault. Disk crashes come in two varieties: either the disks are physically unharmed but the information stored on them is lost, or else the disks are physically damaged, in which case usually the entire information content of the disk is lost. The second kind usually occurs then the magnetic read/write heads hit the surfaces of the disks and scrape off the oxide. This kind of disk crash is called a ``head crash''. @verb To fail suddenly. Example: ``Has the system just crashed?'' @verb To cause to fail. Example: ``There is a bug in the tape controller; if you try to use the tape drive, you will crash the system.'' @verb Of people, to go to sleep, particularly after a long period of work. See @wd[GRONK OUT]. @End[Defns] @Wordentry[CREEPING FEATURISM] (kreep'eeng feetch':r-iz':m) @noun The tendency for anything complicated to become even more complicated because people keep saying, ``Gee, it would be even better if it had this feature too.'' (See @wd[FEATURE].) The result is usually a patchwork because it grew one ad-hoc step at a time, rather than being planned. Planning is a lot of work, but it's easy to add just one extra little feature to help someone... and then another... and another... When creeping featurism gets out of hand it's like a cancer. Usually this term is used to describe computer programs, but it could also be said of the federal government, the IRS 1040 form, and new cars. @Wordentry[CRETIN] (kreet-:n) @Begin[Defns] @noun @pej A congenital @wd[LOSER]; an obnoxious person; someone who can't do anything right. @word[CRETINOUS] (kree'tin-uhss, kreet':n-uhss) @adj Wrong; non-functional; very poorly designed. [Also used pejoratively of people.] Synonyms: @wd[BLETCHEROUS], @wd[BAGBITING], @wd[LOSING], @wd[BRAIN-DAMAGED]. @End[Defns] @Wordentry[CRLF] (k:r'lif, crul':f) @begin[Defns] @noun A carriage return (CR) followed by a line feed (LF). More loosely, whatever it takes to get you from the end of one line of text to the beginning of the next line. @verb To output a @wd[CRLF]; to end a line of text or to begin a new line of text. @end[Defns] Synonym: @wd[TERPRI]. @Wordentry[CROCK] @noun @Begin[defns] Something, especially a program, that works but does so in an unbelievably ugly or awkward manner; more specifically, something that works acceptably but which is quite prone to failure if disturbed in the least. A tightly woven, almost completely unmodifiable structure; something very complicated that ought to be simple. @End[defns] Computer programs seldom stay the same forever; they tend to evolve, and are constantly changed as bugs are fixed or new features added. Crocks make this difficult, because while they work they are very difficult to make small changes to. @word[CROCKISH], @word[CROCKY] @adj Having the characteristics of a crock. See @wd[BLETCHEROUS]. @word[CROCKITUDE] (krahk':-tood) @noun Crock-ness, crockhood. Synonyms: @wd[KLUDGE]. @wordentry[CRUFT] (kruhft) @begin[defns] @noun An unpleasant substance. The dust that gathers under your bed is cruft. @noun The results of shoddy construction. @word[CRUFT TOGETHER] @verb To make something quickly and haphazardly to get it working quickly, without regard to craftsmanship. Example: ``There isn't any program now to reverse all the lines of a file, but I can probably cruft one together in about ten minutes.'' @end[defns] The origin of this word is unknown. @Wordentry[CRUFTY] (kruhft'ee) @Begin[Defns] @adj Unpleasant, especially to the touch; yucky, like spilled coffee smeared with peanut butter and catsup. @adj Poorly built, possibly overly complex. ``This is standard old crufty DEC software''. @adj Generally unpleasant. @noun (also spelled @wd[CRUFTIE]) A small crufty object, or (in a program) a small data structure, especially one that doesn't fit well into the scheme of things. Every desk seems to have one drawer that accumulates crufties. Example: ``A @c[LISP] property list is a good place to store crufties.'' [In the @c[LISP] language, odd data structures can be stored in a catch-all data structure called a property list.] @End[Defns] @wordentry[CRUFTSMANSHIP] @noun The antithesis of craftsmanship. @Wordentry[CRUNCH] @verb @Begin[Defns] To process, usually in a time-consuming or complicated way. The connotation is of an essentially trivial operation which is nonetheless painful to perform, possibly because the trivial operation must be performed millions of times. When the trivial operation involves numerical computation, this is called @wd[NUMBER CRUNCHING]. Example: ``@c[FORTRAN] programs mostly do number crunching.'' To reduce the size of a file by a complicated scheme that produces bit configurations completely unrelated to the original data, such as by the mathematical technique called ``Huffman codes''. (The file ends up looking like a paper document would if somebody crunched the paper into a wad.) Since such a compression operation usually requires a great deal of computation (it is much more sophisticated than such simpler methods as counting consecutive repeated characters), the term is doubly appropriate. Sometimes the term @wd[FILE CRUNCHING] is used to distinguish it from @wd[NUMBER CRUNCHING]. @noun The character ``@f[#]''. See @wd[CHARACTERS]. @End[Defns] @Wordentry[CTY] (sit'ee) @noun The terminal physically associated with a computer's operating console. The term is a contraction of ``Console @wd[TTY]'', that is, ``Console TeleTYpe''. @Wordentry[CUSPY] (cuhsp'ee) @adj Clean; well-written; functionally excellent. A program which performs well and interfaces well to users is cuspy. See @wd[RUDE]. Antonyms: @wd[RUDE], @wd[CRUFTY], @wd[BLETCHEROUS]. This term originated at WPI. It comes from the acronym CUSP, used by DEC to mean a ``Commonly Used System Program'', that is, a utility program used by many people. Ideally such programs, whatever the source, are built to high standards of excellence. The extent to which a person uses this word obviously depends largely on how highly he regards DEC-supplied software. @wordentry[CYCLE] @noun The ``basic unit of computation''. What every hacker wants more of. You might think that single machine instructions would be the measure of computation, and indeed computers are often compared by how many instructions they can process per second, but some instructions take longer than others. Nearly all computers have an internal clock, though, and you can describe an instruction as taking so many ``clock cycles''. Frequently the computer can access its memory once on every clock cycle, and so one speaks also of ``memory cycles''. These are technical meanings of ``cycle''. The slang meaning comes from the observation that there are only so many cycles per second, and when you are sharing a computer, the cycles get divided up among the users. The more cycles the computer spends working on your program rather than someone else's, the faster your program will run. That's why every hacker wants more cycles: so he can spend less time waiting for the computer to respond. @word[CYCLE CRUNCH] @noun The situation where the number of people trying to use the computer simultaneously has reached the point where no one can get enough cycles because they are spread too thin. Usually the only solution is to buy another computer. @word[CYCLE DROUGHT] @noun A scarcity of cycles. It may be due to a @wd[cycle crunch], but could also occur because part of the computer is temporarily not working, leaving fewer cycles to go around. Example: ``The @wd[high moby] is @wd[DOWN], so we're running with only half the usual amount of memory. There will be a @wd[cycle drought] until it's fixed.'' @Wordentry[DAEMON] (day'm:n, dee'm:n) @noun A program which is not invoked explicitly, but which lays dormant waiting for some condition(s) to occur. The idea is that the perpetrator of the condition need not be aware that a daemon is lurking (though often a program will commit an action only because it knows that it will implicitly invoke a daemon). For example, many operating systems have a printing daemon. When you want to print a file on some printing device, instead of explicitly running a program that does the printing, you just copy your file to a particular directory (file area). The printer daemon is just a program that is always running; it checks the special directory periodically, and whenever it finds a file there it prints it and then deletes it. The advantage is that programs which want (in this example) files printed need not compete for access to the printing device itself, and need not wait until the printing process is completed. In particular, a user doesn't have to sit there waiting with his terminal tied up while the printing program does its work; he can do something else useful while the daemon does its job. See @wd[DEMON], @wd[DRAGON], and @wd[PHANTOM]. @wd[DAEMON] and @wd[DEMON] are often used interchangeably, but seem to have distinct connotations. @wd[DAEMON] was introduced to computing by people working on CTSS, the Compatible TimeSharing System, which was the first timesharing system, developed at @mit. They pronounced it (dee'm:n), and used it to refer to what is now called a @wd[DRAGON] or @wd[PHANTOM]. The meaning and pronunciation have drifted, and we think the definitions given here reflect current usage. @Wordentry[DAY MODE] @noun The state a person is in when he is working during the day and sleeping at night. See @wd[PHASE] and @wd[NIGHT MODE]. @wordentry[DDT] (dee'dee'tee') @noun A program that helps you to debug other programs by showing individual machine instructions in a readable symbolic form and letting the user change them. At @mit, DDT is also used as the ``top level command language'' that is used to run other programs. The DEC @i[PDP-10 Reference Handbook] (1969) contained this footnote on the first page of the documentation for DDT: @Begin[Quotation] Historical footnote: DDT was developed at MIT for the PDP-1 computer in 1961. At that time DDT sttod for ``DEC Debugging Tape''. Since then, the idea of an on-line debugging program has propagated throughout the computer industry. DDT programs are now available for all DEC computers. Since mdeia other than tape are now frequently used, the more descriptive name ``Dynamic Debugging technique'' has been adopted, retaining the DDT acronym. Confusion between DDT-10 and another well known pesticide, dichloro-diphenyl-trichloroethane (C@-[14]H@-[9]Cl@-[5]) should be minimal since each attacks a different, and apparently mutually exclusive, class of bugs. @End[Quotation] Sadly, this quotation was removed from later editions of the handbook as DEC became much more ``businesslike''. @Wordentry[DEADLOCK] @noun A situation wherein two or more processes (or persons) are unable to proceed because each is waiting for another to do something. Here is a typical example: two programs running on the same computer both want the exclusive use of two things, say a line printer and a disk. The first one grabs the line printer and then tries to grab the disk, but fails because the second one successfully grabbed the disk and is now waiting to get the line printer. Deadlock also occurs when two people meet in a narrow corridor, and each tries to be polite by moving aside to let the other pass, but they end up swaying from side to side without making any progress because they always both move the same way at the same time. Synonym: @wd[DEADLY EMBRACE]. @Wordentry[DEADLY EMBRACE] @noun Deadlock. [This term is usually used only when exactly two processes are involved, while deadlock can involve any number. Also, @wd[DEADLY EMBRACE] seems to be the more popular term in Europe, while @wd[DEADLOCK] is more frequently used in the United States.] @wordentry[DELTA] @begin[Defns] @noun A change, especially a small or incremental change. Example: ``I just doubled the speed of my program!'' ``What was the delta on program size?'' ``About thirty percent.'' [He doubled the speed of his program, but increased its size by thirty percent.] @noun A small quantity, but not as small as @wd[EPSILON]. @end[Defns] @Wordentry[DEMENTED] @adj Useless; totally non-functional; @wd[BRAIN-DAMAGED]. [This is yet another term of disgust used to describe a program. The connotation in this case is that the program works as designed, but the design is bad; perhaps also that the program explicitly exhibits strange behavior. For example, a program that generates large numbers of meaningless error messages, implying that it is on the point of imminent collapse, would be described as demented.] @Wordentry[DEMON] (dee'm:n) @noun A portion of a program which is not invoked explicitly, but which lays dormant waiting for some condition(s) to occur. See @wd[DAEMON]. @wd[demons] are usually processes that are pieces of a single program, while @wd[daemons] are usually entire programs running in the context of a large system, such as an operating system; this distinction is admittedly not hard and fast. Demons are particularly common in artificial intelligence programs. For example, a knowledge manipulation program might implement inference rules as demons. Whenever a new piece of knowledge was added, various demons would activate (which demons depends on the particular piece of data) and would create additional pieces of knowledge by applying their respective inference rules to the original piece. These new pieces could in turn activate more demons as the inferences filtered down through chains of logic. Meanwhile the main program could continue with whatever its primary task was.] @Wordentry[DIDDLE] (did':l) @Begin[Defns] @verb To work with in a not particularly serious manner; to make a very simple change (as to a program). Examples: ``Let's diddle this piece of code and see if the problem goes away.'' [That is, let's try the obvious quick fix.] ``I diddled the text editor to ring the bell before it deleted all your files.'' @noun The action or result of diddling. @end[Defns] Synonyms: @wd[TWEAK], @wd[TWIDDLE]. @Wordentry[DIKE] (diek) @verb To remove or disable a portion of something, as a wire from a computer or a subroutine from a program. [A standard slogan: ``When in doubt, dike it out.'' (The implication is that the program (or whatever) is so bad that taking something out can only make things better!) The word ``dikes'' is widely used among mechanics and engineers to mean ``diagonal cutters'', a heavy-duty metal-cutting device; to ``dike something out'' means to use such cutters to remove something. Among hackers this term has been metaphorically extended to non-physical objects such as pieces of program.] @wordentry[DOUBLE BUCKY] @adj Using both the @i[control] and @i[meta] keys on a keyboard that has them. ``The @c[EMACS] command to reformat a @c[LISP] program is double-bucky-G.'' [That is, the command is Control-Meta-G.] [For a complete explanation, see @wd[BUCKY BITS]. The following lyrics were written on May 27, 1978, in celebration of the @stanford keyboard. A typical @mit comment was that the ``bucky bits'' (control and meta shifting keys) were nice, but there weren't enough of them; you could only type 512 different characters on a @stanford keyword. An obvious thing was simply to add more shifting keys, and this was eventually done; one problem, is that a keyboard with that many shifting keys is hard on touch-typists, who don't like to move their hands away from the home position on the keyboard. It was half-seriously suggested that the extra shifting keys be pedals; typing on such a keyboard would be very much like playing a full pipe organ. This idea is mentioned below, in what is a parody of a very fine song by Jeffrey Moss called ``Rubber Duckie'', which was published in ``The Sesame Street Songbook''. @Begin[Format] @tabset(+4,+8,+4) @hsp(1 in)Double Bucky Double bucky, you're the one! You make my keyboard lots of fun. @\Double bucky, an additional bit or two: (Vo-vo-de-o!) Control and meta, side by side, Augmented ASCII, nine bits wide! @\Double bucky! Half a thousand glyphs, plus a few! @\@\Oh, @\@\I sure wish that I @\@\Had a couple of @\@\@\Bits more! @\@\Perhaps a @\@\Set of pedals to @\@\Make the number of @\@\@\Bits four: @\@\Double double bucky! Double bucky, left and right OR'd together, outta sight! @\Double bucky, I'd like a whole word of @\Double bucky, I'm happy I heard of @\Double bucky, I'd like a whole word of you! -- The Great Quux (with apologies to Jeffrey Moss) @end[Format] ] @Wordentry[DO PROTOCOL] @verb To perform an interaction with somebody or something according to a well-defined standard procedure. For example, ``Let's do protocol with the check'' at a restaurant means to ask the waitress for the check, calculate the tip and everybody's share, make change as necessary, and pay the bill. @Wordentry[DOWN] @Begin[Defns] @adj Not working; deactivated. Example: ``The up escalator is down.'' That is considered a humorous thing to say, but ``The elevator is down'' @i[always] means ``The elevator isn't working'' and never refers to what floor the elevator is on. @wd[GO DOWN] @verb To stop functioning; usually said of the @wd[SYSTEM]. The message every hacker hates to hear from the operator is, ``The system will go down in five minutes.'' @wd[TAKE DOWN], @wd[BRING DOWN] @verb To deactivate purposely, usually for repair work. Example: ``I'm taking the system down to work on that bug in the tape drive.'' @End[Defns] Antonym: @wd[UP]. See @wd[CRASH]. @Wordentry[DPB] (d:-pib', duh-pib') @verb To plop something down in the middle. @silly. Example: ``Dpb yourself into that couch, there.'' [The connotation would be that the couch is full except for one slot just big enough for you to sit in. @f[DPB] means ``DePosit Byte'', and is the name of a PDP-10 instruction that inserts some bits into the middle of some other bits.] @Wordentry[DRAGON] @noun A program similar to a @wd[DAEMON], except that it doesn't sit around waiting for something to happen, but is instead used by the system to perform various useful tasks that just have to be done periodically. [A typical example would be an accounting program that accumulates statistics, keeps track of who is logged in, and so on. Another example: most timesharing systems have several terminals, and at any given time some are in use and some are sitting idle; the idle ones usually sit there with some idiotic message on their screens, such as ``Logged off.'', from the last time someone used it. One timesharing system at @MIT puts these idle terminals to good use by displaying useful information on them, such as who is using the computer, where they are, what they're doing, what their telephone numbers are, and so on, along with other information such as pretty pictures (the picture collection includes a unicorn, Snoopy, and the U.S.S. Enterprise from Star Trek). All this information is displayed on idle terminals by the @wd[NAME DRAGON], so called because it originally printed just the names of the users. (That it now shows all kinds of things, including useless though pretty pictures, is an example of @wd[CREEPING FEATURISM].) The name dragon is a program started up by the system, and it runs about every five minutes and updates the information on all idle terminals.] @Wordentry[DWIM] (dwim) @noun A complicated procedure (in the @c[INTERLISP] dialect of @c[LISP]) that attempts to correct your mistakes automatically. For example, if you spell something wrong, or don't balance your parentheses properly, it tries to figure out what you meant: @wd[DWIM] stands for ``Do What I Mean''. When this works, it is very impressive. When it doesn't work, anything can happen. When a program has become very big and complicated, so complicated that no one can understand how to use it, it is often suggested in jest that @wd[DWIM] be added to it. See @wd[BELLS AND WHISTLES]. @Wordentry[EL CAMINO BIGNUM] (el' k:-mee'noh big'num) @noun El Camino Real. El Camino Real is the name of a street through the San Francisco peninsula that originally extended (and still appears in places) all the way down to Mexico City. Navigation on the San Francisco peninsula is usually done relative to El Camino Real, which is assumed to run north and south even though it doesn't really in many places (see @wd[LOGICAL]). El Camino Real runs right past Stanford University, and so is familiar to hackers. The Spanish word ``real'' (which has two syllables (ree-ahl')) means ``royal''; El Camino Real is ``the royal road''. Now the English word ``real'' is used in mathematics to describe numbers (and by analogy is misused in computer jargon to mean floating-point numbers). In the @c[FORTRAN] language, for example, a ``real'' quantity is a number typically precise to seven decimal places, and a ``double precision'' quantity is a larger floating-point number, precise to perhaps fourteen decimal places. When a hacker from @mit visited @stanford in 1976 or so, he remarked what a long road El Camino Real was. Making a pun on ``real'', he started calling it ``El Camino Double Precision''--but when the hacker was told that the road was hundreds of miles long, he renamed it ``El Camino Bignum'', and that name has stuck. (See @wd[BIGNUM].) @Wordentry[ENGLISH] @noun The source code for a program, which may be in any computer language. This term is slightly obsolete, and used mostly by old-time hackers who were around @mit in the mid-1960's. To a real hacker, a program written in his favorite programming language is as readable as English. @Wordentry[EPSILON] (ep'si-lahn) @Begin[Defns] @noun A small quantity of anything. Example: The ``cost is epsilon.'' @adj Very small, negligible. ``I tried to speed up the program, but got epsilon improvement.'' @word[WITHIN EPSILON OF] @prep Close enough to be indistinguishable for all practical purposes. This is even closer than being @wd[WITHIN DELTA OF]. Example: ``That's not what I asked for, but it's within epsilon of what I wanted.'' Alternatively, it may mean @i[not] close enough, but very little is required to get it there: ``My program is within epsilon of working.'' @end[Defns] See @wd[DELTA]. [The terms @wd[EPSILON] and @wd[DELTA] are names of Greek letters; the slang usage stems from the traditional use of these letters in mathematics for very small numerical quantities, particularly in so-called ``epsilon-delta'' proofs in the differential calculus. The term @wd[DELTA] is usually used once @wd[EPSILON] has been mentioned to mean a quantity that is slightly bigger than @wd[EPSILON] but still very small. For example, ``The cost isn't epsilon, but it's delta'' means that the cost isn't totally negligible, but it is nevertheless very small.] @Wordentry[EXCH] (eks'ch:, ekstch) @verb To exchange two things, each for the other; to swap places. If you point to two people sitting down and say ``Exch!'', you are asking them to trade places. [@f[EXCH], meaning EXCHange, is the name of a PDP-10 instruction that exchanges the contents of a register and a memory location.] @Wordentry[EXCL] (eks'c:l) @noun The character ``@f[!]''. See @wd[CHARACTERS]. @Wordentry[FAULTY] @adj Non-functional; buggy. [This word means about the same thing as @wd[BAGBITING], @wd[BLETCHEROUS], and @wd[LOSING], but the connotation is much milder.] @Wordentry[FEATURE] @noun @Begin[Defns] An intended property or behavior (as of a program). Whether it is good or not is immaterial. A good property or behavior (as of a program). Whether it was intended or not is immaterial. A surprising property or behavior; in particular, one that is purposely inconsistent because it works better that way. For example, in the @c[EMACS] text editor, the ``transpose characters'' command exchanges the two characters on either side of the cursor on the screen, @i[except] when the cursor is at the end of a line, in which case the two characters before the curspor are exchanged. While this behavior is perhaps surprising, and certainly inconsistent, it has been found through extensive experimentation to be what most users want; the inconsistency is therefore a @wd[feature] and not a @wd[bug]. A property or behavior that is gratuitous or unnecessary, though perhaps also impressive or cute. For example, one feature of the @c[maclisp] language is the ability to print numbers as Roman numerals. See @wd[BELLS AND WHISTLES]. A property or behavior that was put in to help someone else but that happens to be in your way. @End[Defns] [To call something a feature sometimes means the author of the program did not consider the particular case, and the program responded in a way that was unexpected, but not strictly incorrect. A standard joke is that a @wd[BUG] can be turned into a @wd[FEATURE] simply by documenting it (then theoretically no one can complain about it because it's in the manual), or even by simply declaring it to be good. ``That's not a bug; it's a feature!'' If someone tells you about some new improvement to a program, you might respond, ``Feetch, feetch!'' The meaning of this depends critically on vocal inflection. With enthusiasm, it means something like, ``Boy, that's great! What a great hack!'' Grudgingly or with obvious doubt, it means ``I don't know; it sounds like just one more unnecessary and complicated thing.'' With a tone of resignation, it means, ``Well, I'd rather keep it simple, but I suppose it has to be done.'' The following terms covers the spectrum of terms used to describe programs or portions thereof, except for the first two, which tend to be applied more to hardware or to the @wd[SYSTEM], but are included for completeness: @Begin[Format] @wd[CRASH] @wd[STOPPAGE] @wd[BUG] @wd[SCREW] @wd[LOSS] @wd[MISFEATURE] @wd[CROCK] @wd[KLUGE] @wd[HACK] @wd[WIN] @wd[FEATURE] @wd[PERFECTION] @End[Format] The last is never actually attained.] @Wordentry[FEEP] (feep) @Begin[Defns] @noun The soft electronic ``bell'' of a display terminal (except for a DEC VT-52!); a beep. @verb To make (or to cause a terminal to make) a @wd[FEEP] sound. @wd[FEEPER] @noun The device in the terminal (usually a loudspeaker of some kind) that makes the feep sound. @wd[FEEPING CREATURISM] @noun This term isn't really well-defined, but it sounds so nice (being a spoonerism on @wd[CREEPING FEATURISM]) that most hackers have said or heard it. It probably has something to do with terminals prowling about in the dark making their customary noises. @End[Defns] [A true @wd[TTY] does not feep; it has a real mechanical bell that just rings. Synonyms for @wd[FEEP] are @wd[BEEP], @wd[BLEEP], or just about anything suitably onomatopoeic. (Jeff Macnelly, in his comic strip @i[Shoe], uses the word @wd[EEP] for sounds made by computer terminals and video games; this is perhaps the closest one yet.) The term @wd[BREEDLE] is sometimes heard at @stanford, where the terminal bleepers are not particularly soft. (They sound more like the musical equivalent of a raspberry or Bronx cheer; for a close approximation, imagine the sound of a @i[Star Trek] communicator's beep lasting for five seconds.) By contrast, the ``feeper'' on a VT-52 has been compared to the sound of a '52 Chevy stripping its gears. @Wordentry[FENCEPOST ERROR] @noun An ``off-by-one'' error; the discrete equivalent of a boundary condition. This problem is often exhibited in programs containing iterative loops: something will be done one time too few or too many. The term comes from the following problem: ``If you build a fence 100 feet long with posts 10 feet apart, how many posts do you need?'' (Either 9 or 11 is a better answer than the obvious 10.) For example, suppose you have a long list or array of items, and want to process items @i[m] through @i[n]; how many items are there? The obvious answer is @i[n]@#@i[m], but that is off by one; the right answer is @i[n]@#@i[m]+1. A program that used the ``obvious'' formula would have a fencepost error in it. @Wordentry[FINE] @adj Good, but not good enough to be @wd[CUSPY]. [This term is used primarily at @wpi. The word ``fine'' is occasionally elsewhere, too, but without the implicit comparison to the higher level of perfection implied by @wd[CUSPY].] @wordentry[FLAG] @noun A variable or quantity that can take on one of two values; a bit, particularly one that is used to indicate one of two outcomes or is used to control which of two things is to be done. Examples: ``This flag controls whether to clear the screen before printing the message.'' ``The program status word contains several flag bits.'' @Wordentry[FLAG DAY] @noun A change which is neither forward nor backward compatible (so old programs won't work under the new system, and new programs won't work under the old one), and which is costly to make and costly to undo. Example: ``If we change @c[maclisp] to use square brackets instead of parentheses, it will cause a flag day for everybody.'' [This term has nothing to do with the use of the word @wd[FLAG] to mean a variable that has two values. It came into use when a massive change was made to the @c[multics] timesharing system to convert from the old ASCII code to the new one; this was scheduled for Flag Day, June 14, 1966.] @Wordentry[FLAKY, FLAKEY] @adj Subject to frequent or intermittent @wd[LOSSAGE]. [This use is of course related to the common slang use of the word, to describe a person as eccentric or crazy. A system that is flakey is working, sort of, enough that you are tempted to try to use it, but it fails frequently enough that the odds in favor of finishing what you start are low.] @Wordentry[FLAME] @begin[defns] @verb To speak incessantly and/or rabidly on some relatively uninteresting subject or with a patently ridiculous attitude. @word[FLAME ON] @verb To continue to flame. @word[FLAMER] @noun One who flames; a fanatic. @word[FLAMAGE] (flaym':j) @noun Flaming; the content of a flame. (Both @wd[FLAMAGE] and @wd[FLAMING] are used in this sense.) @end[defns] Synonym: @wd[RAVE]. When a discussion degenerates into useless controversy, one might tell the participants, ``Now you're just flaming'' or ``Stop all that flamage!'' to get them to cool down (so to speak). @Wordentry[FLAP] @verb To give the command to unload a @wd[MICROTAPE], or more generally any magnetic tape, from its drive. (When this operation is finished, the take-up reel keeps spinning, and the end of the tape goes flap, flap, flap...) @Wordentry[FLAVOR] @noun @Begin[Defns] Variety, type, kind. ``@c[EMACS] commands come in two flavors: single-character and named.'' ``These lights come in two flavors, big red ones and small green ones.'' See @wd[VANILLA]. The attribute that causes something to be @wd[FLAVORFUL]. Usually used in the phrase ``yields additional flavor.'' Example: ``This feature yields additional flavor by allowing one to print text either right-side-up or upside-down.'' @End[Defns] @Wordentry[FLAVORFUL] @adj Aesthetically pleasing. Antonym: @wd[BLETCHEROUS]. See @wd[TASTE]. @Wordentry[FLUSH] @verb @Begin[Defns] To delete, destroy, or get rid of something, typically something that is useless or superfluous. ``All that nonsense has been flushed.'' This is standard @mit terminology within the ITS timesharing system for aborting an output operation; one speaks of the text that would have been printed, but was not, as having been flushed. Under that timesharing system, if you ask to have a file printed on your terminal, it is printed a page at a time; at the end of each page, it asks whether you want to see more, and if you say no, it says ``FLUSHED''. (A speculation is that this term arose from a vivid image of flushing unwanted characters by hosing down the internal output buffer, washing the characters away before they can be printed.) To exclude someone from an activity. To leave at the end of a day's work (as opposed to leaving for a meal). Examples: ``I'm going to flush now.'' ``Time to flush.'' @End[Defns] @Wordentry[FOO] (foo) @Begin[Defns] @interj Term of disgust. For greater emphasis, one says @wd[MOBY FOO] (see @wd[MOBY]). @word[FOO?] What? What's going on here? (See @wd[COM MODE].) @noun The first metasyntactic variable; that is, when you have to invent an arbitrary temporary name for something for the sake of exposition, @wd[FOO] is usually used. If you need a second one, @wd[BAR] or @wd[BAZ] is usually used; there is a slight preference at @mit for @wd[BAR] and at @stanford for @wd[BAZ]. (It was probably at @stanford that @wd[BAR] was corrupted to @wd[BAZ]. Clearly @wd[BAR] was the original, for the concatenation @wd[FOOBAR] is widely used also, and this in turn can be traced to the scatological acronym ``FUBAR'' that arose in the armed forced during World War II.) If @wd[BAR] is used, then @wd[BAZ] is used as a third name, and @wd[QUUX] enjoys some popularity as the next name after that. Example: ``The bug can happen in this way. Suppose you have two functions FOO and BAR. FOO calls BAR with two arguments. Now BAR calls BAZ, passing it just one of the two arguments...'' In effect, these words serve as extra pronouns; they are always ``nonce names''. @End[Defns] [This word is certainly a favorite among hackers. While its use in connection with @wd[BAR] clearly stems from ``FUBAR'', its original appearance appears to be untraceable, and may derive from other common interjections such as the Yiddish ``Feh!''. Bill Holman featured the word @wd[FOO] prominently in his comic strip @i[Smokey Stover], in particular on license plates of cars.] @Wordentry[FRIED] @adj @Begin[Defns] Non-functional because of hardware failure; burned out. Example: ``The disk controller is fried.'' (Sometimes this literally happens to electronic circuits! In particular, resistors can burn out and transformers can melt down, emitting terribly-smelling smoke. However, this term is also used metaphorically.) Of people, exhausted, ``burned out''. This is said particularly of those who continue to work in such a state, and often used as an explanation or excuse. Example: ``Yeah, I know that fix destroyed the file system, but I was fried when I put it in.'' @End[Defns] @Wordentry[FROB] (frahb) @Begin[Defns] @noun A protruding arm or trunnion. (This is the official definition by the Tech Model Railroad Club at @mit.) Any somewhat small thing; an object that you can comfortably hold in one hand; something you can frob. See @wd[FROBNITZ]. @verb Abbreviated form of @wd[FROBNICATE]. @End[Defns] @Wordentry[FROBNICATE] (frahb'ni-kayt) @verb To manipulate or adjust; to do the appropriate thing to; to play with; to fondle. This word is usually abbreviated to simply @wd[FROB], but @wd[FROBNICATE] is recognized as the official full form. Examples: ``Please frob the light switch.'' [That is, flip the light switch.] ``Stop frobbing that clasp; you'll break it.'' Synonyms: @wd[TWEAK], @wd[TWIDDLE]. [@wd[FROB], @wd[TWIDDLE], and @wd[TWEAK] sometimes connote points along a spectrum. @wd[FROB] connotes aimless manipulation; @wd[TWIDDLE] connotes gross manipulation, often a coarse search for a proper setting; @wd[TWEAK] connotes fine-tuning. Suppose someone is turning a knob on an oscilloscope. If he's carefully adjusting it, searching for some particular point, he is probably tweaking it; if he is turning it rather quickly while looking at the screen, he is probably twiddling it; but if he's just doing it because turning a knob is fun, he's frobbing it.] @Wordentry[FROBNITZ] (frahb'nitz), plural @word[FROBNITZEM] (frahb'nit-z:m) @noun @begin[defns] An unspecified physical object; a widget; a black box. By extension, a data structure in a program, when regarded as an object. @end[defns] [This rare form is usually abbreviated to @wd[FROTZ] (frahtz), or more commonly to @wd[FROB]. Also used are @wd[FROBNULE] (frahb'nyool), @wd[FROBULE] (frahb'yool), and @wd[FROBNODULE] (frahb-nahd'yool). Starting perhaps in 1979, @wd[FROBBOZ] (fruh-bahz', fr:-bahz'), plural @wd[FROBBOTZIM] (fruh-baht'z:m), has also become very popular, largely due to its exposure as a name via the Adventure-type game called Zork (which originated at @mit).] @Wordentry[FROG, PHROG] @Begin[Defns] @interj Term of disgust (hackers seem to have a lot of them). @noun Of things, a @wd[CROCK]. Of people, something between a turkey and a toad. Jake Brown, a hacker whose login name at @stanford is @f[FRG]. @word[FROGGY] @adj Similar to @wd[BAGBITING], but milder. ``This froggy program is taking forever to run!'' @End[Defns] @Wordentry[FROTZ] (frahtz) @begin[defns] @noun An abbreviated form of @wd[FROBNITZ]. @word[MUMBLE FROTZ] @interj A term of fairly mild disgust, usually used as an objection to something someone has just said. See @wd[MUMBLE]. @End[Defns] @Wordentry[FRY] @verb @Begin[Defns] To fail. Said especially of smoke-producing hardware failures. More generally, to become non-working. (This term is never said of software, only of hardware and humans.) @End[Defns] See @wd[FRIED]. @Wordentry[FTP] (ef'tee'pee') @Begin[Defns] @noun The File Transfer Protocol for transmitting files between systems on the @c[ARPANET]. @noun A program that implements the protocol and thereby helps you to transfer files. @verb To transfer a file using the File Transfer Program. Example: ``Lemme get this copy of Wuthering Heights @wd[FTP]'d from @stanford.'' @verb More generally, to transfer a file between two computers using any electronic network, such as Ethernet (as opposed, say, to using a magnetic tape as the transfer medium). @End[Defns] @Wordentry[FUDGE] @Begin[Defns] @verb To perform in an incomplete but marginally acceptable way, particularly with respect to the writing of a program. ``I didn't feel like doing it all the right way, so I fudged it.'' @noun The code resulting from fudging as defined above. @verb To make something come out the way it was supposed to by making an @i[ex post facto] change, such as to a @wd[FUDGE FACTOR]. @End[Defns] [All these uses are related to the common slang use of the word to mean something like cheating, as when a scientist fudges his measurements to fit his pet theory.] @Wordentry[FUDGE FACTOR] @noun A value or parameter that is varied in an ad hoc way to produce a desired result. See @wd[SLOP]. @Wordentry[GABRIEL] @noun An unnecessary (in the opinion of the opponent) stalling tactic when playing volleyball, such as tying one's shoelaces or hair repeatedly, asking the time, etc. Also used to refer to the perpetrator of such tactics. @word[GABRIEL MODE] @noun The state a person is in when he performs one stalling tactic after another. See @wd[MODE]. This is in honor of Richard P. Gabriel, a @stanford hacker and volleyball fanatic. His reputation for stalling is a bit undeserved, and has the status of a running gag. One may speak of ``pulling a Gabriel'', or of ``being in Gabriel mode''. See @wd[RPG]. @Wordentry[GARPLY] (gahrp'lee) @noun A meta-word, like @wd[FOO]. This one is used mostly at @stanford. @Wordentry[GAS] @Begin[Defns] @interj A term of disgust and hatred, implying that gas should be dispensed in generous quantities, thereby exterminating the source of irritation. ``Some loser just reloaded the system for no reason! Gas!'' An exclamation suggesting that someone or something ought to be flushed (gotten rid of) out of mercy. ``The system is getting wedged every few minutes. Gas!'' @verb To get rid of; to @wd[FLUSH]. ``You should gas that old crufty software.'' @wd[GASEOUS] @adj Deserving of being gassed. @End[Defns] @Wordentry[GC] (jee'see') @Begin[Defns] @verb To clean up and throw away useless things. ``I think I'll GC the top of my desk today.'' To recycle, reclaim, or put to another use. To forget. (The implication is sometimes that one has done so deliberately.) ``You told me last week where it was, but I GC'd those bits.'' @noun An instantiation of the GC process. @End[Defns] @wd[GC] is an abbreviation of ``garbage collect'' or ``garbage collection'', which is computer science jargon for a particular class of strategies for dynamically reallocating computer memory. One such strategy involves periodically scanning all the data in memory and determining what is no longer useful; useless data items are then discarded so that the memory they occupy can be recycled and used for another purpose. Implementations of the @c[LISP] language usually use garbage collection. Sometimes the full phrase is used, but the acronym is more frequently used because it's shorter. Note that there is an ambiguity in usage that has to be resolved by context: ``I'm going to garbage-collect my desk'' usually means to clean out the drawers, but it could also mean to throw away or recycle the desk itself. @Wordentry[GEDANKEN] (ge-dahnk-:n) @adj Wild-eyed; impractical; not well-thought-out; untried; untested. ``Gedanken'' is a German word for ``thought''. A thought experiment is one you carry out in your head. In physics, the term ``gedanken experiment'' is used to refer to an experiment that is impractical to carry out, but useful to consider because you can reason about it theoretically. (A classic gedanken experiment of relativity theory involves thinking about a man flying through space in an elevator.) Gedanken experiments are very useful in physics, but you have to be careful. It was a gedanken experiment that led Aristotle to conclude that heavy things always fall faster than light things (he thought about a rock and a feather); this was accepted until Galileo proved otherwise. Among hackers, however, the word has a pejorative connotation. It is said of a project, especially one in artificial intelligence research, which is written up in grand detail (typically as a Ph.D. thesis) without ever being implemented to any great extent. Such a project is usually perpetrated by people who aren't very good hackers or find programming distasteful or are just in a hurry. A gedanken thesis is usually marked by an obvious lack of intuition about what is programmable and what is not, and about what does and does not constitute a clear specification an algorithm. @Wordentry[GLASS TTY] (glass ti'tee) @noun A terminal which has a display screen but which, because of hardware or software limitations, behaves like a teletype or other printing terminal, thereby combining the disadvantages of both: like a printing terminal, it can't do fancy display hacks, and like a display terminal, it doesn't produce hard copy (a paper copy that you can carry away with you). An example is the Lear Siegler ADM-3 terminal, which was actually advertised as ``the dumb terminal'' when it first came out (implying that it was also cheap). See @wd[TTY]. Here is a true story about a glass tty. One day an MIT hacker was in a motorcycle accident and broke his leg. He had to stay in the hospital quite a while, and got restless because he couldn't @wd[HACK] (use the computer). Two of his friends therefore took a display terminal and a telephone connection for it to the hospital, so that he could use the computer by telephone from his hospital bed. Now this happened some years before the spread of home computers, and computer terminals were not a familiar sight to the average person. When the two friends got to the hospital, a guard stopped them and asked what they were carrying. They explained that they wanted to take a computer terminal to their friend who was a patient. The guard got out his list of things that patients were permitted to have in their rooms: TV, radio, electric razor, typewriter, tape player... no computer terminals. Computer terminals weren't on the list, so they couldn't take it in. Rules are rules. Fair enough, said the two friends, and they left again. They were frustrated, of course, because they knew that the terminal was as harmless as a TV or anything else on the list... which gave them an idea. The next day they returned, and the same thing happened: a guard stopped them and asked what they were carrying. They said, ``This is a TV typewriter!'' The guard was skeptical, so they plugged it in and demonstrated it. ``See? You just type on the keyboard and what you type shows up on the TV screen.'' Now the guard didn't stop to think about how utterly useless a typewriter would be that didn't produce any paper copies of what you typed; but this was clearly a TV typewriter, no doubt about it. So he checked his list: ``A TV is all right, a typewriter is all right... okay, take it on in!'' @Wordentry[GLITCH] @Begin[Defns] @noun A sudden interruption in electric service, sanity, continuity, or program function. It may or may not be possible to recover from it. @verb To commit a glitch. See @wd[GRITCH]. @verb To scroll a display screen. @End[Defns] An interruption in electric service is usually called a @wd[POWER GLITCH]. This is of grave concern because it usually crashes all the computers. Have you ever been in the middle of a sentence and then forgotten what you were going to say? If this happened to a hacker, he might say, ``Sorry, I just glitched''. (This would be a ``mental glitch''.) This word almost certainly comes from Yiddish, where it means to slide or skid on a slippery surface. A fall while walking on ice would be a @i[glitch]. Yiddish got it from the German verb @i[glitschen], meaning ``to slip''. @Wordentry[GLORK] (glohrk) @Begin[Defns] @interj Term of mild surprise, usually tinged with outrage, as when one attempts to save the results of two hours of editing and finds that the system has just crashed. A meta-word. See @wd[FOO]. @verb Similar to @wd[GLITCH], but usually used reflexively. ``My program just glorked itself.'' @End[Defns] @Wordentry[GOBBLE] @verb To consume or to obtain. @wd[GOBBLE UP] tends to imply ``consume'', while @wd[GOBBLE DOWN] tends to imply ``obtain''. Examples: ``The output spy gobbles characters out of a TTY output buffer.'' (See @wd[OUTPUT SPY].) ``I guess I'll gobble down a copy of the documentation tomorrow.'' See @wd[SNARF]. @Wordentry[GORP] (gohrp) This is yet another metasyntactic variable, like @wd[FOO] and @wd[BAR]. It is used primarily at @cmu. (It may be related to its use as the generic term for dried hiker's food, stemming from the acronym ``Good Old Raisins and Peanuts'', but this is uncertain.) @wordentry[GOSPERISM] (gahss'p:r'iz':m) A hack, invention, or saying by arch-hacker R. William (Bill) Gosper. This notion merits its own term because there are so many of them. Many of the entries in @wd[HAKMEM] are Gosperisms; see also @wd[LIFE]. @Wordentry[GRIND] @verb @Begin[Defns] To format code, especially @c[LISP] code, by indenting the lines so that it looks pretty. (This term is used primarily within the @c[MACLISP] community. Elsewhere, to format code so that it looks nice is to @wd[PRETTY-PRINT] it.) To run seemingly interminably, performing some tedious and inherently useless task. Synonym: @wd[CRUNCH]. @End[Defns] @Wordentry[GRITCH] @Begin[Defns] @noun A complaint (often caused by a GLITCH (q.v.)). @verb To complain. Often verb-doubled: ``Gritch gritch''. A synonym for @wd[GLITCH], as both a verb and a noun. @End[Defns] @Wordentry[GROK] (grahk) @verb To understand, usually in a global sense; especially, to understand all the implications and consequences of making a change. Example: ``JONL is the only one who groks the @c[MACLISP] compiler.'' (This word comes from the novel @i[Stranger in a Strange Land] by Robert Heinlein, where it is a Martian word meaning roughly ``to be one with''.) @Wordentry[GRONK] (grahnk) @begin[defns] @verb To clear the state of a wedged device and restart it. More severe than ``to frob'' (q.v.). GRONKED: @adj Of people, the condition of feeling very tired or sick. Of things, totally non-functional. (For things, @wd[GRONKED] and @wd[BROKEN] mean about the same thing, but they have very different connotations when used of people. @wd[GRONKED] connotes physical exhaustion or illness or temporary mental exhaustion, while @wd[BROKEN] connotes mental or emotional illness.) GRONK OUT: @verb Of things, to cease functioning. ``My terminal just gronked out.'' Of people, to go home and go to sleep. ``I guess I'll gronk out now; see you all tomorrow.'' When you are gronked, the best thing to do is to gronk out. @end[defns] (This word has been popularized as a noise made by dinosaurs in the comic strip @i[B.C.] by Johnny Hart, but the word apparently predates it.) @Wordentry[GROVEL] @verb @begin[defns] To work interminably and without apparent progress. Often used with ``over'' or ``through''. Example: ``The file scavenger has been grovelling through the file directories for ten minutes now.'' To examine minutely or in complete detail. ``The compiler grovels over the entire source program before beginning to translate it.'' ``I grovelled through all the documentation, but I still couldn't find the command I wanted.'' @wd[GROVEL OBSCENELY]: this is the standard emphatic form of @wd[GROVEL]. @end[defns] @Wordentry[GRUNGY] (gruhn'jee) @adj @begin[defns] Incredibly dirty, greasy, grubby. Anything which has been washed within the last year is not really grungy. If you sleep all night in your clothes and then get up and start hacking again, you feel grungy. More generally, awful or ugly. Programs (especially crocks) can be described as grungy. A person with a headache or a cold probably feels grungy. @end[defns] @Wordentry[GUBBISH] (guhb'ish) @noun Garbage; crap; nonsense. ``What is all this gubbish?'' (This word is probably a portmanteau of ``garbage'' and ``rubbish''.) @Wordentry[GUN] @verb To forcibly terminate a program. May be used with or without ``down''. ``Some idiot left a useless background program running, soaking up half the @wd[cycles]. So I gunned it.'' @Wordentry[HACK] @Begin[Defns] @noun A quick bit of work that produces what is needed, but not well. The result of that work; a @wd[CROCK] (occasionally the connotation is affectionate). An incredibly good, and perhaps very time-consuming, piece of work that produces exactly what is needed. The result of that work. A clever technique. A brilliant practical joke. The value of the hack varies in proportion to its cleverness, harmlessness, surprise value, fame, and appropriate use of technology. @verb With ``together'', to throw something together so it will work. See @wd[CRUFT] and @wd[KLUDGE]. To bear emotionally or physically. ``I can't hack this heat!'' To work with a computer. To work on something (typically a program). In specific sense: ``What are you doing?'' ``I'm hacking TECO.'' In general sense: ``What do you do around here?'' ``I hack TECO.'' (The former is time-immediate, the latter time-extended.) More generally, ``I hack x'' is roughly equivalent to ``x is my bag''. Example: ``I hack solid-state physics.'' To pull a prank on. See definition 6 above and also definition 6 of @wd[HACKER]. To waste time (as opposed to @wd[TOOL]). Example: ``Watcha up to?'' ``Oh, just hacking.'' @word[HACK VALUE]: @noun Term used as the reason or motivation for expending effort toward a seemingly useless goal, the point being that the accomplished goal is a hack. For example, the @c[MACLISP] language can read and print integers as roman numerals; the code for this was installed purely for hack value. @word[HACK UP (ON)]: @verb To hack, but with the connotation that the result is a @wd[HACK] as in definition 2 above. Examples: ``You need a quick-and-dirty sorting routine? I'll see if I can hack one up by tomorrow.'' ``I hacked up on EMACS so it can use the Greek alphabet.'' @word[HOW'S HACKING?]: A friendly greeting among hackers. (It recognizes the other person as a hacker and invites him to describe what he has been working on recently.) @word[HAPPY HACKING]: A farewell. @word[BACK TO HACKING]: Another farewell. ``Happy hacking'' implies that the other person will continue hacking (perhaps you interrupted him). ``Oh, well, back to hacking'' implies that you, the speaker are going to return to work (and perhaps the other person also). @word[HACK HACK]: A somewhat pointless but friendly comment, often used as a farewell but occasionally also as a greeting. @End[Defns] ``The word @wd[HACK] doesn't really have 69 different meanings,'' according to Phil Agre, an @mit hacker. ``In fact, @wd[HACK] has only one meaning, an extremely subtle and profound one which defies articulation. Which connotation is implied by a given use of the word depends in similarly profound ways on the context. Similar remarks apply to a couple of other hacker words, most notably @wd[RANDOM].'' Hacking might be characterized as ``an appropriate application of ingenuity''. Whether the result is a quick-and-dirty patchwork job or a carefully crafted work of art, you have to admire the cleverness that went into it. Here are three examples of practical joke hacks: @Begin[Itemize] @Begin[Multiple] In 1961, students from Caltech (California Institute of Technology in Pasadena) hacked the Rose Bowl football game. One student posed as a reporter and ``interviewed'' the director of the University of Washington card stunts (such stunts involve people in the stands who hold up colored cards to make pictures). The reporter learned exactly how the stunts were operated, and also that the director would be out to dinner later. While the director was eating, the students (who called themselves the ``Fiendish Fourteen'') picked a lock and stole one of the direction sheets for the card stunts. They then had a printer run off 2300 copies of the sheet. The next day they picked the lock again and stole the master plans for the stunts, large sheets of graph paper colored in with the stunt pictures. Using these as a guide, they carefully made ``corrections'' for three of the stunts on the duplicate instruction sheets. Finally, they broke in once more, replacing the stolen master plans and substituting the stack of altered instruction sheets for the original set. The result was that three of the pictures were totally different. Instead of spelling ``WASHINGTON'', the word ``CALTECH'' was flashed. Another stunt showed the word ``HUSKIES'', the Washington nickname, but spelled it backwards. And what was supposed to have been a picture of a husky instead showed a beaver. (Both Caltech and @mit use the beaver as a mascot. Beavers are nature's engineers.) After the game, the Washington faculty athletic representative said, ``Some thought it ingenious; others were indignant.'' The Washington student body president remarked, ``No hard feelings, but at the time it was unbelievable. We were amazed.'' This is now considered a classic hack, particularly because revising the direction sheets constituted a form of programming not unlike computer programming. @End[Multiple] @Begin[Multiple] On November 20, 1982, @mit hacked the Harvard-Yale football game. Just after Harvard's second touchdown against Yale in the second quarter, a small black ball popped up out of the ground at the 40-yard line, and grew bigger, and bigger, and bigger. The letters ``MIT'' appeared all over the ball. As the players and officials stood around gawking, the ball grew to six feet in diameter and then burst with a bang and a cloud of white smoke. As the @i[Boston Globe] later reported, ``If you want to know the truth, M.I.T@. won The Game.'' The prank had taken weeks of careful planning by members of @mit@;'s Delta Kappa Epsilon fraternity. The device consisted of a weather balloon, a hydraulic ram powered by Freon gas to lift it out of the ground, and a vacuum-cleaner motor to inflate it. They made eight separate expeditions to Harvard Stadium between 1 and 5 @c[AM], in which they located an unused 110-volt circuit in the stadium, and ran buried wiring from the stadium circuit to the 40-yard line, where they buried the balloon device. When the time came to activate the device, two fraternity members had merely to flip a circuit breaker and push a plug into an outlet. This stunt had all the earmarks of a perfect hack: surprise, publicity, the ingenious use of technology, safety, and harmlessness. The use of manual control allowed the prank to be timed so as not to disrupt the game (it was set off between plays, so the outcome of the game would not be unduly affected). The perpetrators had even thoughtfully attached a note to the balloon explaining that the device was not dangerous and contained no explosives. Harvard president Derek Bok commented: ``They have an awful lot of clever people down there at @mit, and they did it again.'' President Paul E. Gray of @mit said, ``There is absolutely no truth to the rumor that I had anything to do with it, but I wish there were.'' Such is the way of all good hacks. @End[Multiple] @End[Itemize] @wordentry[HACK ATTACK] @noun A period of greatly increased hacking activity. ``I've been up for thirty hours; I had a hack attack and finished off that new feature I thought would take two weeks to program.'' @Wordentry[HACKER] @noun @Begin[Defns] A person who enjoys learning the details of computer systems and how to stretch their capabilities, as opposed to most users of computers, who prefer to learn only the minimum amount necessary. One who programs enthusiastically, or who enjoys programming rather than just theorizing about programming. A person capable of appreciating @wd[HACK VALUE]. A person who is good at programming quickly. (By the way, not everything a hacker produces is a hack.) An expert on a particular program, or one who frequently does work using it or on it; example: ``A SAIL hacker''. (This definition and the preceding ones are correlated, and people who fit them congregate.) An expert of any kind. One might be an astronomy hacker, for example. A malicious or inquisitive meddler who tries to discover information by poking around. For example, a ``password hacker'' is one who tries, possibly by deceptive or illegal means, to discover other peopel's computer passwords. A ``network hacker'' is one who tries to learn about the computer network (possibly because he wants to improve it and possibly because he wants to interfere--one can tell the difference only by context and tone of voice). @word[HACKISH]: @adj Being or involving a hack. @word[HACKISHNESS], @word[HACKITUDE]: @noun The quality of being or involving a hack. (The word @wd[HACKITUDE] is considered silly; the standard term is @wd[HACKISHNESS].) @End[Defns] Hackers consider themselves somewhat of an elite, though one to which new members are gladly welcome. It is a meritocracy based on ability. There is a certain self-satisfaction in identifying yourself as a hacker (but if you claim to be one and are not, you'll quickly be labelled @wd[BOGUS]). @Wordentry[HAIR] @noun Complexity. ``Decoding TECO commands requires a certain amount of hair.'' @word[INFINITE HAIR], @word[HAIR SQUARED]: @noun Extreme complexity. [The phrase @wd[INFINITE HAIR] is usually used in sentences, while @wd[HAIR SQUARED] is used as an interjection. For example: ``I wrote a program to do my income taxes; handling Schedule G properly required infinite hair.'' (To which his friend replies, ``Hair squared!'') @Wordentry[HAIRY] @adj @Begin[Defns] Overly complicated. ``DWIM is incredibly hairy.'' Incomprehensible. ``DWIM is incredibly hairy.'' Of people: high-powered, authoritative, rare, expert, and/or incomprehensible. This usage is difficult to explain except by example: ``He knows a hairy lawyer who says there's nothing to worry about.'' F. Lee Bailey would be considered hairy. @End[Defns] @Wordentry[HAKMEM] (hak'mem) @noun @MIT Artificial Intelligence Memo 239 (February 1972). A collection of neat mathematical, programming, and electronic hacks contributed by people at MIT and elsewhere. (The title of the memo really is ``HAKMEM'', which is an acronym of sorts for ``hacks memo''.) Some of them are very useful techniques or powerful theorems, but most fall into the category of mathematical and computer trivia. A sampling of the entries (with authors), slightly paraphrased: @Begin[Description] Item 41@\(Gene Salamin) There are exactly 23,000 prime numbers less than 2@+[18]. Item 46@\(Rich Schroeppel) The most @i[probable] suit distribution in bridge hands is 4-4-3-2, as compared to 4-3-3-3, which is the most @i[evenly] distributed. This is because the world likes to have unequal numbers: a thermodynamic effect saying things will not be in the state of lowest energy, but in the state of lowest disordered energy. Problem 81@\(Rich Schroeppel) Count the magic squares of order 5 (that is, all the 5-by-5 arrangements of the numbers from 1 to 25 such that all rows, columns, and diagonals add up to the same number). There are about 320 million, not counting those that differ only by rotation and reflection. Item 174@\(Bill Gosper and Stuart Nelson) 21963283741 is the only number such that if you represent it on the PDP-10 as both an integer and a floating-point number, the bit patterns of the two representations are identical. @End[Description] HAKMEM also contains some rather more complicated mathematical and technical items, but these examples show some of its fun flavor. @Wordentry[HANDWAVE] @Begin[Defns] @verb To gloss over a complex point; to distract a listener; to support a (possibly actually valid) point with blatantly faulty logic. If someone starts a sentence with ``Clearly...'' or ``Obviously...'' or ``It is self-evident that...'', you can be sure he is about to handwave. @noun A specific act of handwaving. Example: ``Boy, what a handwave!'' @End[Defns] The use of this word is often accompanied by gestures: both hands up, palms forward, swinging the hands in a vertical plane pivoting at the elbows and/or shoulders (depending on the magnitude of the handwave); alternatively, holding the forearms still while rotating the hands at the wrist to make them flutter. In context, the gestures alone can suffice as a remark; if a speaker makes an outrageous unsupported assumption, you might simply wave your hands in this way, as an accusation more eloquent than words could express that his logic is faulty. @Wordentry[HARDWARILY] (hahrd-war':-lee) @adv In a way pertaining to hardware. ``The system is hardwarily unreliable.'' Note: the adjective ``hardwary'' is @i[not] used. See @wd[SOFTWARILY]. @Wordentry[HIRSUTE] @adj This word is occasionally used humorously as a synonym for @wd[HAIRY]. @Wordentry[HOOK] @noun An extraneous piece of software or hardware included in order to simplify later changes, or to permit changes by a user. For instance, a PDP-10 program might execute a location that is normally a @wd[JFCL] (no operation), but by changing the @wd[JFCL] to a @wd[PUSHJ] (subroutine call) one can insert a debugging routine at that point. As another example, a simple program that prints numbers might always print them in base ten, but a more flexible version would let a variable determine what base to use; setting the variable to 5 would make the program print numbers in base five. The variable is a simple hook. An even more flexible program might examine the variable, and treat a value of 16 or less as the base to use, but treat any other number as the address of a user-supplied program for printing a number. This is a very powerful hook; one can then write a routine to print numbers as roman numerals, say, or as Hebrew characters, and plug it into the program through the hook. Often the difference between a good program and a superb one is that the latter has useful hooks in judiciously chosen places. Both may do the original job about equally well, but the one with the hooks is much more flexible for future expansion of capabilities. @Wordentry[INFINITE] @adj Consisting of a large number of objects; extreme. Used very loosely. Example: ``This program produces infinite garbage.'' ``He is an infinite loser.'' [The slang use of @wd[INFINITE] is an abuse of its precise technical meaning in mathematics.] @word[INFINITE HAIR]: @noun See @wd[HAIR]. @wordentry[J. RANDOM] (jay' ran'd:m) @adj Arbitrary; ordinary; any one; ``any old''. ``Would you let J. Random Loser marry your daughter?'' See @wd[RANDOM]. @Wordentry[JFCL] (j:-fik':l, jif'k:l) @verb To cancel or annul something. ``Why don't you jfcl that out?'' [The PDP-10 has several instructions that don't do anything (remember that ``SKIP'' means ``do not SKIP'', as explained in the entry for @wd[AOS]). However, the fastest do-nothing instruction happens to be @wd[JFCL], which stands for ``Jump if Flag set and then CLear the flag''; this does something useful, but is a very fast no-operation if no flag is specified. If one wants to patch a program by removing one instruction, the easiest thing to do is to replace the instruction with one that doesn't do anything. Such an instruction is said to have been JFCL'd out. This bit of jargon was then extended metaphorically. The license plate on hacker Geoff Goodfellow's BMW is JFCL.] @Wordentry[JIFFY] (jif'ee) @noun @Begin[Defns] The time unit used by a clock attached to a computer to measure CPU time, typically either 1/60 second or (less commonly) one millisecond. ``The swapper runs every six jiffies'' means that the virtual memory management routine is executed once for every six ticks of the clock, or ten times a second. An indeterminate time from a few seconds to forever. ``I'll do it in a jiffy'' means certainly not now and possibly never. This is a bit contrary to the more widespread use of the word. @End[Defns] @Wordentry[JOCK] @noun A programmer who is characterized by the large and somewhat brute-force programs he writes. Brute-force programs typically work by enumerating all possible combinations of things in an effort to find the one combination that solves the problem. @Wordentry[KLUGE], @word[KLUDGE] (klooj) @noun @Begin[Defns] A Rube Goldberg device in hardware or software. A clever programming trick intended to solve a particular nasty case in an efficient, if not clear, manner. Often used to repair bugs. Often verges on being a crock. Something that works for the wrong reason. @verb To insert a kluge into a program. ``I've kluged this routine to get around that weird bug, but there's probably a better way.'' Also @wd[KLUGE UP]. @wd[KLUGE AROUND]: To avoid (a problem) by inserting a kluge. A feature which is implemented in a @wd[RUDE] manner. @End[Defns] @wordentry[LASER CHICKEN] @noun Kung Pao Chicken, a standard Chinese dish containing chicken, peanuts, and bell peppers in a spicy pepper-oil sauce. A few hackers call it ``laser chiicken'' for two reasons; it can @wd[zap] you just like a laser, and the pepper-oil sauce has a red color reminiscent of a laser beam. @Wordentry[LIFE] @noun A cellular-automaton game invented by mathematician John Horton Conway, and first introduced publicly by Martin Gardner in his column ``Mathematical Games'' (Scientific American, October 1970). Hackers at various places contributed to the mathematical analysis of this game, notably Bill Gosper at @mit. When a hacker mentions ``life'', he is much more likely to mean this game than the magazine, the breakfast cereal, or the human state of existence. @Wordentry[LINE STARVE] @Begin[defns] @verb To feed the paper through the terminal the wrong way by one line (most terminals can't do this!). On a display terminal, to move the cursor up to the previous line of the screen. Example: ``To print X squared, you just output X, line starve, 2, line feed.'' (The line starve causes the 2 to appear on the line above the X, and the line feed gets back to the original line.) @noun A ``character'' (or character sequence) that causes a terminal to perform this action. @End[defns] [This is @i[not] standard ASCII terminology. Even among hackers it is considered a bit silly.] @Wordentry[LOGICAL] @adj Conventional; assumed for the sake of exposition or convenience; not the actual thing but in some sense equivalent to it; not necessarily corresponding to reality. Example: If a person who had long held a certain post (for example, Les Earnest at @stanford) left and was replaced, the replacement would for a while be known as the ``logical Les Earnest''. Pepsi might be referred to as ``logical Coke'' (or vice versa). At @stanford, ``logical'' compass directions denote a coordinate system in which ``logical north'' is toward San Francisco, ``logical south'' is towards San Jose, ``logical west'' is toward the ocean, and ``logical east'' is away from the ocean, even though logical north varies between physical (true) north near San Fransisco and physical west near San Jose. The best rule of thumb here is that El Camino Real by definition always runs logical north-and-south. In giving directions, one might say, ``To get to Rincon Tarasco restaurant, get onto El Camino Bignum going logical north.'' Using the word ``logical'' helps to prevent the recipient from worrying about that the fact that the sun is setting almost directly in front of him. A similar situation exists at @mit. Route 128 (famous for the electronics industries that have grown up along it) is a three-quarters circle surrounding Boston at a radius of ten miles, terminating at the coastline at each end. It would be most precise to describe the two directions along this highway as being ``clockwise'' and ``counterclockwise'', but the road signs all say ``north'' and ``south'', respectively. A hacker would describe these directions as ``logical north'' and ``logical south'', to indicate that they are conventional directions not corresponding to the usual convention for those words. (If you went logical south along the entire length of route 128, you would start out going northwest, curve around to the south, and finish headed due east!) Synonym: @wd[VIRTUAL]. Antonym: @wd[PHYSICAL]. [This use is an extension from its technical use in computer science. A program can be written to do input or output using a ``logical device''; when the program is run, the user can specify which ``physical'' (actual) device to use for that logical device. For example, a program might write all its error messages to a logical device called ERROR; the user can then specify whether logical device ERROR should be associated to the terminal, a disk file, or the @wd[NULL DEVICE] (to throw the error messages away). A speculation is that the word ``logical'' is used because even though a thing isn't the actual object in question, you can reason logically about the thing as if it were the actual object.] @Wordentry[LOSE] @verb @Begin[Defns] To fail. A program loses when it encounters an exceptional condition or fails to work in the expected manner. To be exceptionally unaesthetic. Of people, to be obnoxious or unusually stupid (as opposed to ignorant). See @wd[LOSER]. @word[DESERVE TO LOSE]: @verb Said of someone who willfully does @wd[the wrong thing], or uses a feature known to be @wd[marginal]. What is meant is that one deserves the consequences of one's losing actions. ``Boy, anyone who tries to use UNIX deserves to lose!'' @word[LOSE LOSE]:- @interj A reply or comment on an undesirable situation. Example: ``I accidentally deleted all my files!'' ``Lose lose.'' @End[Defns] @Wordentry[LOSER] @noun An unexpectedly bad situation, program, programmer, or person. Someone who habitually loses (even winners can lose occasionally). Someone who knows not and knows not that he knows not. Emphatic forms are @wd[REAL LOSER], @wd[TOTAL LOSER], and @wd[COMPLETE LOSER] (but not ``moby loser'', which would be a contradiction in terms). @Wordentry[LOSS] @noun Something (but not a person) that loses; a situation in which something is losing. Emphatic forms are @wd[MOBY LOSS], @wd[TOTAL LOSS], @wd[COMPLETE LOSS]. @wd[WHAT A LOSS!]: @interj A remark to the effect that a situation is bad. Example: Suppose someone said ``Fred decided to write his program in @c[ADA] instead of @c[LISP].'' The reply ``What a loss!'' comments that the choice was bad, or that it will result in an undesirable situation, but may also implicitly recognize that Fred was perhaps forced to make that decision because of outside influences. On the other hand, the reply ``What a loser!'' is a more general remark about Fred himself, and implies that bad consequences will be entirely his fault. @Wordentry[LOSSAGE] (lawss':j) @noun The stuff of which losses are made. This is a collective noun. ``What a loss!'' and ``What lossage!'' are nearly synonymous remarks. @Wordentry[LPT] (lip':t) @noun A Line PrinTer. ``The LIST command can be used to send a file to the LPT.'' @Wordentry[LUSER] (loo'z:r) @noun A @wd[USER] who is probably also a @wd[LOSER]. (@wd[LUSER] and @wd[LOSER] are pronounced identically.) [This word was coined about eight years ago at @mit. When you first walk up to a terminal at @mit and type Control-Z to get the computer's attention, it prints out some status information, including how many people are already using the computer; it might print ``14 users'', for example. Someone thought it would be a great joke to patch the system to print ``14 losers'' instead. There ensued a great controversy, as some of the users didn't particularly want to be called losers to their faces every time they used the computer. For a while several hackers struggled covertly, each changing the message behind the back of the others; any time you logged into the computer it was even money whether it would say ``users'' or ``losers''. Finally, someone tried the compromise ``lusers'', and it stuck. To this day, when you connect to the @mit computer, it will say ``12 lusers''.] @Wordentry[MACROTAPE] (mak'roh-tayp) @noun An industry standard reel of magnetic tape, as opposed to a @wd[MICROTAPE]. @Wordentry[MAGIC] @adj @Begin[Defns] As yet unexplained, or too complicated to explain. (Arthur C. Clarke once said that any sufficiently advanced technology is indistinguishable from magic.) ``The precise form in which characters are printed to the terminal is controlled by a number of magic bits.'' ``This routine magically computes the parity of an eight-bit byte in only three instructions.'' Characteristic of something that works but no one really understands why. Characteristic of a feature not generally publicized which allows something otherwise impossible, or a feature formerly in that category but now unveiled. Example: The keyboard commands which override the screen-hiding features. @End[Defns] See @wd[AUTOMAGICALLY]. [Some years ago I was snooping around in the cabinets that housed the @mit AI Lab's PDP-10, and noticed a little switch glued to the frame of one cabinet. It was obviously a homebrew job, added by one of the lab's hardware hackers (no one know who). You don't touch an unknown switch on a computer without knowing what it does, because you might @wd[CRASH] it. The switch was labeled in a most unhelpful way. It had two positions, and scrawled in pencil on the metal switch body were the words ``magic'' and ``more magic''. The switch was in the ``more magic'' position. I called another hacker over to look at it. He had never seen the switch before either. Closer examination revealed that the switch only had one wire running to it! The other end of the wire did disappear into the maze of wires inside the computer, but it's a basic fact of electricity that a switch can't do anything unless there are two wires connected to it. This switch had a wire connected on one side and no wire on its other side. It was clear that this switch was someone's idea of a silly joke. Convinced by our reasoning that the switch was inoperative, we flipped it. The computer instantly crashed. Imagine our utter astonishment. We wrote it off as coincidence, but nevertheless restored the switch to the ``more magic'' position before reviving the computer. A year later, I told this story to yet another hacker, David Moon as I recall (see @wd[MOON]). He clearly doubted my sanity, or suspected me of a supernatural belief in the power of this switch, or perhaps thought I was fooling him with a @wd[BOGUS] @wd[SAGA]. To prove it to him, I showed him the very switch, still glued to the cabinet frame with only one wire connected to it, still in the ``more magic'' position. We scrutinized the switch and its lone connection, and found that the other end of the wire, though connected to the computer wiring, was connected to a ground pin. That clearly made the switch doubly useless: not only was it electrically nonoperative, but it was connected to a place that couldn't affect anything anyway. So we flipped the switch. The computer promptly crashed. This time we ran for Richard Greenblatt, a long-time @mit hacker, who was close at hand. He had never noticed the switch before, either. He inspected it, concluded it was useless, got some diagonal cutters and @wd[DIKED IT OUT]. We then revived the computer and it ran fine ever since. We still don't know how the switch crashed the machine. There is a theory that some circuit near the ground pin was @wd[MARGINAL], and flipping the switch changed the electrical capacitance enough to upset the circuit as millionth-of-a-second pulses went through it. But we'll never know for sure; all we can really say is that the switch was @wd[MAGIC]. I still have that switch in my basement. Maybe I'm silly, but I usually keep it set on ``more magic.''] @Wordentry[MARGINAL] @adj @Begin[Defns] Extremely small. ``A marginal increase in memory can decrease GC time drastically.'' [In evertyday terms, this means that it's a lot easier to clean off your desk if you have a spare place to put some of the junk while you sort through it.] See @wd[EPSILON]. Of extremely small merit. ``This proposed new feature seems rather marginal to me.'' Of extremely small probability of winning. ``The power supply was rather marginal anyway; no wonder it fried.'' @word[MARGINALLY]: @adv Slightly; somewhat. ``The ravs here are only marginally better than at Small Eating Place.'' @word[MARGINAL HACKS]: @noun Margaret Jacks Hall, a building into which the @stanford AI Lab was recently moved. @End[Defns] @Wordentry[MICROTAPE] (miek'roh-tayp) @noun A DECtape, as opposed to a MACROTAPE. A DECtape is a small reel of magnetic tape about four inches in diameter and an inch wide. Unlike standard magnetic tapes, microtapes allow ``random access'' to the data. In their heyday they were used in pretty much the same ways one would now use a floppy disk: as a small, portable way to save and transport files and programs. Apparently the term ``microtape'' was actually the official term used within DEC for these tapes until someone consed up [invented] the word ``DECtape'', which of course has more commercial appeal. @Wordentry[MISFEATURE] @noun A feature that eventually clobbers someone, possibly because it is not adequate for a new situation that has evolved. It is not the same as a bug because fixing it involves a gross philosophical change to the structure of the system involved. A misfeature is different from a simple unforeseen side effect; the term implies that the misfeature was actually carefully planned to be that way, but future consequences or circumstances just weren't predicted accurately. This is different from just not having thought ahead about it at all. Often a former feature becomes a misfeature because a tradeoff was made whose parameters subsequently changed (possibly only in the judgement of the implementors). Example: ``Well, yeah, it's kind of a misfeature that file names are limited to six characters. That decision was made N years ago to simplify the file access software and save space on the disk, and now we're stuck with it.'' @Wordentry[MOBY] (moh'bee) @Begin[defns] @adj Large, immense, complex, impressive. Examples: ``A Saturn V rocket is a truly moby frob.'' ``Some @mit undergrads pulled off a moby hack at the Harvard-Yale game.'' @noun The total size of a computer's address space, that is, the amount of memory that a given computer can access. Examples: for a PDP-10, a moby is 256K 36-bit words; for a PDP-8, it is 4096 12-bit words; for a 68000 or a VAX, it is 4294967296 8-bit bytes. [This term is useful because when a computer has ``virtual memory mapping'' a computer may have more physical memory attached to it than any one program can access directly. One can then say ``This computer has six mobies'' to mean that the ratio of physical memory to address space is six, without having to say specifically how much memory there actually is. That in turn implies that the computer can timeshare six ``full-sized'' programs without having to swap programs between memory and disk. If a computer has exactly two mobies, then the one with smaller (physical) addresses is called the ``low moby'', and the other one is called the ``high moby''. Example: ``Response times will be long today. The high moby just fried, so we're limping along with only half our memory.''] @noun 256K 36-bit words, which is the size of a moby on every hacker's favorite computer, the PDP-10. This amount is sufficiently close to a megabyte (one million bytes) that sometimes the terms ``moby'' and ``megabyte'' are used interchangeably. @adj An honorific term of address (never of third-person reference), usually used to show admiration, respect, and/or friendliness to a competent hacker. Example: ``So, moby Knight, how's the CONS machine doing?'' [Tom Knight was one of the designers of the @mit LISP Machine, a personal computer designed to run LISP; the prototype was called CONS.] @adj In backgammon, doubles on the dice, as in ``moby sixes'', ``moby threes'', ``moby ones'', etc. Compare this with @wd[BIGNUMS]: double sixes are both bignums and moby sixes, but moby ones are not bignums (the use of term ``moby'' to describe double ones is sarcastic). @word[MOBY FOO, MOBY WIN, MOBY LOSS, MOBY HACK]: These are standard emphatic forms. @end[defns] @Wordentry[MODE] @noun A general state, usually used with an adjective or noun describing the state. Use of the word ``mode'' rather than ``state'' implies that the state is extended over time, and probably also that some activity characteristic of that state is being carried out. Examples: ``No time to hack; I'm in thesis mode.'' ``I'll be in vacation mode next week.'' ``My editor is stuck in some weird mode where every character I type appears twice on the screen.'' ``The E editor normally uses a display terminal, but if you're on a TTY it will switch to non-display mode.'' [This term is normally used in a technical sense to describe the state of a program; extended usage, for example to describe people, is definitely slang.] See @wd[DAY MODE], @wd[NIGHT MODE], and @wd[YOYO MODE]; also @wd[COM MODE], @wd[TALK MODE], and @wd[GABRIEL MODE]. @Wordentry[MODULO] (mahd'yoo-loh) @prep Except for. This is from mathematical terminology: one writes ``4@#22 mod 9'' to mean that 4 and 22 give the same remainder when divided by 9 (the precise meaning is a bit more complicated, but that's the idea). One might say that that 4=22 ``except for some 9's''. Examples: ``Well, LISP seems to work okay now, modulo that GC bug.'' ``I feel fine today modulo a slight headache.'' @Wordentry[MUMBLAGE] (muhm'bl:j) @noun The topic of one's mumbling (see @wd[MUMBLE]). ``All that mumblage'' is used like ``all that stuff'' when it is not quite clear what it is or how it works, or like ``all that crap'' when ``mumble'' is being used as an implicit replacement for obscenities. @Wordentry[MUMBLE] @interj @Begin[Defns] Said when the correct response is either too complicated to enunciate or the speaker has not thought it out. Often prefaces a longer answer, or indicates a general reluctance to get into a big long discussion. Example: ``Don't you think that we could improve LISP performance by using a hybrid reference-count transaction garbage collector, if the cache is big enough and there are some extra cache bits for the microcode to use?'' ``Well, mumble... I'll have to think about it.'' Sometimes used as an expression of disagreement. ``I think we should buy a VAX.'' ``Mumble!'' Common variant: @wd[MUMBLE FROTZ]. Yet another metasyntactic variable, like @wd[FOO]. @End[Defns] @Wordentry[MUNCH] @verb To transform information in a serial fashion, often requiring large amounts of computation. To trace down a data structure. Synonyms: @wd[CRUNCH], @wd[GROVEL]. @wd[MUNCH] connotes somewhat less pain than the other two words. @Wordentry[MUNCHING SQUARES] @noun A display hack dating back to the PDP-1 (early 1960's) at @mit, which employs a trivial computation (involving XOR'ing of x-y display coordinates, described in items 146-148 of @wd[HAKMEM]) to produce an impressive display of moving, growing, and shrinking squares. The hack usually has a parameter (usually taken from toggle switches) which when well-chosen can produce amazing effects. Some of these, discovered recently on the LISP machine, have been christened @wd[MUNCHING TRIANGLES], @wd[MUNCHING W'S], and @wd[MUNCHING MAZES]. More generally, suppose a graphics program produces an impressive and ever-changing display of some basic form FOO on a display terminal, and does it using a relatively simple program; then the program (or the resulting display) is likely to be referred to as ``munching FOOs''. [By the way, note the use of the word FOO as a metasyntactic variable in the last sentence.] @Wordentry[MUNG] (muhng) @verb @Begin[defns] To make changes to a file, often large-scale, usually irrevocable. Occasionally accidental. To destroy, usually accidentally, occasionally maliciously. Note that the @wd[SYSTEM] only mungs things maliciously (this is a consequence of Murphy's Law). The kind of beans of which the sprouts are used in Chinese food. (That's their real name! Mung beans! Really!) @End[defns] [This word is said to be a recursive acronym: MUNG means Mung Until No Good.] @wordentry[MUNGE] (muhnj) @verb Variant of @wd[MUNG]. @Wordentry[N] (en) @noun @Begin[Defns] Some large and indeterminate number. ``There were N bugs in that crock!''. An arbitrarily large (and perhaps infinite) number. A variable whose value is specified by the current context. For example, when ordering a meal at a restaurant N may be understood to mean however many people there are at the table. From the remark ``We'd like to order N wonton soups and a family dinner for N-1'' you can deduce that one person at the table wants to eat only soup, even though you don't know how many people there are. A silly riddle: ``How many computers does it take to shift the bits in a register? N+1: N to hold all the bits still, and one to shove the register over.'' @word[NTH] (enth): @adj The ordinal counterpart of N. ``Now for the Nth and last time...'' In the specific context ``Nth-year graduate student'', N is generally assumed to be at least 4, and is usually 5 or more. See also @wd[69]. @End[Defns] @Wordentry[NIGHT MODE] @noun The state a person is in when he is working at night and sleeping during the day. (The advantage of being in night mode is that the computers are usually overloaded during the day; at night more cycles are available.) See @wd[PHASE] and @wd[DAY MODE]. @Wordentry[NIL] (nil) No. This word is used in reply to a question, particularly one asked using the ``-P'' convention. Example: ``Foodp?'' ``NIL.'' That simple interchange means, ``Do you want to come eat with us?'' ``No, thanks.'' See @wd[T]. [In the @c[LISP] language, the name NIL means ``false'', among other things.] @Wordentry[OBSCURE] @adj Little-known; incomprehensible; undocumented. This word is used in an exaggeration of its normal meaning, to imply a total lack of comprehensibility. ``The reason for that last crash is obscure.'' ``That program has a very obscure command syntax.'' ``This kludge works by taking advantage of an obscure feature in TECO.'' The phrase @wd[MODERATELY OBSCURE] implies that it could be figured out but probably isn't worth the trouble. @Wordentry[OPEN] @noun A left parenthesis ``(''. This word is used as shorthand to eliminate ambiguity when communicating a sequence of characters orally. To read aloud the LISP program ``(DEFUN FOO (X) (PLUS X 1))'' (which takes an argument X and adds 1 to it) one might say: ``Open def-fun foo, open eks close, open, plus ekx one, close close.'' See @wd[CLOSE]. On the MIT system there is a program that allows you to see what is being printed on someone else's terminal. It works by ``spying'' on the other guy's output, by examining the insides of the monitor system. It can do this because the MIT system purposely has very little in the way of ``protection'' that prevents one user from interfering with another. Fair is fair, however. There is another program that will automatically notify you if anyone starts to spy on your output. It works in exactly the same way, by looking at the insides of the operating system to see if anyone else is looking at the insides that have to do with your output. This ``counterspy'' program is called @wd[JEDGAR] (pronounced as two syllables: jed'gar), in honor of the former head of the FBI. By the way, the output spy program is called @wd[OS]. Throughout the rest of computer science, and also at IBM, @wd[OS] means ``operating system'', but among @MIT hackers it almost always means ``output spy''. @Wordentry[PARSE] @verb @Begin[Defns] To determine the syntactic structure of a sentence or other utterance. (This is close to the standard English meaning). Example: ``That was the one I saw you.'' ``I can't parse that.'' 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.'' 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''. @End[Defns] [This term is derived from the technical use of the word in linguistics. Hackers know about it because some researchers in Artificial Intelligence work on the problem of writing computer programs that can understand and/or speak human languages.] @Wordentry[PATCH] @Begin[Defns] @noun 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. @verb To fix something temporarily; to insert a patch into a piece of code. @End[Defns] @Wordentry[PDL] (pid':l, pud':l) [acronym for Push Down List] @noun @Begin[Defns] A last-in/first-out (LIFO) queue, also known as a ``stack'' in computer science; more loosely, any ordered list of things; even more loosely, any set of things. 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'' (or the top of the stack). Examples: ``I'm afraid I've got real work to do, so this hack will have to be pushed way down on my pdl.'' ``I haven't done it yet because every time I pop my pdl something new gets pushed.'' If you are interrupted several times in the middle of a conversation, ``my pdl overflowed'' means ``I forget what we were talking about'' (the implication is that too many items were pushed onto the pdl than could be remembered, and so the least recent items were lost). See @wd[PUSH] and @wd[POP]. Hacker Dave Lebling (PDL@@DM). @Begin[Multiple] @word[OVERFLOW PDL] @noun The place where you put things when your pdl is full. If you don't have one and too many things get pushed, you forget something. The overflow pdl for a person's memory might be a memo pad. @Begin[Verse] Hey, diddle, diddle The overflow pdl To get a little more stack; If that's not enough Then you lose it all, And have to pop all the way back. --The Great Quux @End[Verse] @End[Multiple] @End[Defns] The term PDL is an acronym for Push-Down List, and in its technical sense rather than its slang meaning always means a stack. The best example of a stack is to be found in a cafeteria: a pile of plates sitting on a spring in a well in a cart, so that when you put a plate on the top they all sink down, and when you take one off the top the rest spring up a bit. @Wordentry[PESSIMAL] @adj Maximally bad. ``This is a pessimal situation.'' @word[PESSIMIZE]: @verb To make as bad as possible. @Word[PESSIMIZING COMPILER] @noun A compiler that produces object code that is @i[worse] than the straightforward or obvious translation. (The implication is that the compiler is actually trying to optimize the program, but through stupidity is doing the opposite. A few pessimizing compilers have been written on purpose, however, as pranks.) These words are the obvious Latin-based antonyms for ``optimal'' and ``optimize'', but for some reason they do not appear in most English dictionaries, although ``pessimize'' is listed in the Oxford English Dictionary. @Wordentry[PHASE] @noun 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. Examples: ``What's your phase?'' ``I've been getting in about 8 PM lately, but I'm going to phase around to the day schedule by Friday.'' A person who is roughly 12 hours out of phase is sometimes said to be in @wd[NIGHT MODE]. (The term @wd[DAY MODE] is also used, meaning you're working 9 to 5 (or more likely 10 to 6), but less frequently.) It is not uncommon to change one's phase by as much as six hours per day on a regular basis: for example, one can stay awake for twenty hours and then sleep for ten. This can be a bit of a strain on the metabolism when done for extended periods, however. One nice phase-changing schedule is to keep a 28-hour day: stay awake 18 hours and sleep for ten, for example. Six 28-hour days are equal to seven 24-hour days, so this schedule means you can be in day mode on weekends and in night mode (or close to it) for most weekdays; that way you get lots of cycles by being awake at night, and yet be reasonably synchronized with the real world on weekends. @word[CHANGE PHASE THE HARD WAY]: To stay awake for a very long time in order to get into a different phase. @word[CHANGE PHASE THE EASY WAY]: To stay asleep for a very long time in order to get into a different phase. The phenomenon of ``jet lag'' that afflicts travelers who cross many time-zone boundaries may be attributed to two distinct causes: the strain of travel @i[per se], and the strain of changing phase. Hackers who suddenly find that they must change phase drastically in a short period of time, particularly the hard way, experience something very like jet lag without travelling. @Wordentry[PHASE OF THE MOON] @noun A random parameter on which something is (humorously) said to depend. Something that depends on the phase of the moon is at best unpredictable, at worst unreliable. (Maybe it is predictable, but figuring it out is so complicated it isn't worth it.) Example: ``Whether the editor will save your file automatically when you exit depends on the phase of the moon.'' The @wd[PHASE OF THE MOON] is one example of @wd[RANDOMNESS]. Once a program written by Gerry Sussman (professor of Electrical Engineering at @mit) and Guy Steele had a bug that really did depend on the phase of the moon! There is a little subroutine that has traditionally been used in various programs at @mit to calculate an approximation to the moon's true phase; the phase is then printed out at the top of program listings, for example, along with the date and time, purely for fun. (Actually, since hackers spend a lot of time indoors, this might be the only way they would ever know what the moon's phase was!) Steele incorporated this routine into a LISP program that, when it wrote out a file, would print a `timestamp'' at the top that looked something like this: @Begin[Verbatim, font smallbodyfont] ;The moon is 1 day, 20 hours, 42 minutes, and 54 seconds past the first quarter. ;The sun is 41*44'1" north of east, 35*7'26" below the horizon. ;That means it is now 2:21 AM on Wednesday, March 23, 1983. @End[Verbatim] (A calculation of the position of the sun was also included for additional @wd[hack value]. The asterisk was used in lieu of a ``degrees'' symbol to indicate angles.) Very occasionally the first line of the message would be too long and would overflow onto the next line like this: @Begin[Verbatim, font smallbodyfont] ;The moon is 2 days, 17 hours, 20 minutes, and 45 seconds past the first quarter. ;The sun is 18*17'47" west of north, 44*56'42" below the horizon. ;That means it is now 10:59 PM on Wednesday, March 23, 1983. @End[Verbatim] When the file was later read back in the program would @wd[BARF]. The length of the first line depended on the precise time when the timestamp was printed, and so the bug literally depended on the phase of the moon! @Wordentry[POM] (pee-oh-em, pahm) @noun An abbreviation for @wd[PHASE OF THE MOON]. Thsi is usually used in the phrase ``POM-dependent'' to mean @wd[FLAKEY]. @Wordentry[POP] @Begin[defns] To remove something from a stack or @wd[PDL]. If a person says he has popped something from his pdl, he means he has finally finished working on it and can now remove it from the list of things hanging over his head. @verb To return from a digression. The term @wd[POPJ] (pop'jay) is also used in this sense. ``Popj?'' as a simple request means ``Have we finished with this digression? Shall we return to the previous subject of conversation?'' ``Popj!'' has more the force of ``Stop @wd[FLAMING] about that, you loser! Let's return to the main point.'' ``Popj, popj'' means roughly ``Now let's see, where were we?'' @End[defns] Antonyms: @wd[PUSH], @wd[PUSHJ]. [The PDP-10 has instructions named POP and POPJ; the former pops a single word from a stack, and the latter (POP and Jump always) is a subroutine return instruction.] @Wordentry[PPN] (pip':n) @Begin[Defns] A combination of a ``project identifier'' and ``programmer name'', used to identify a specific file directory belonging to that programmer. At @stanford, the term @wd[PPN] is often used loosely to refer to the programmer name alone. ``I want to send you some mail; what's your ppn?''. @End[Defns] [@mit uses an operating system called ITS that is completely unrelated to TOPS-10. ITS does not use PPN's. The closest approximation to a PPN on ITS is @wd[UNAME] (user name). The names @wd[JRN] and @wd[JRL] are sometimes used as example names when discussing ppn's; they are understood to be programmer names for (fictitious) programmers named ``J. Random Nurd'' and ``J. Random Loser'' (see @wd[J. RANDOM]). For example, one might say ``To log in, type log one comma jay are en'' (that is, ``@t[log 1,JRN]''), and the listener will understand that he should use his own computer id in place of ``@t[JRN]''. @Wordentry[PROTOCOL] See @wd[DO PROTOCOL]. @Wordentry[PSEUDOPRIME] (soo'doh-priem) @noun A backgammon prime (six consecutive occupied points) with one point missing; that is, only five out of six consecutive points are really occupied. [This term derives from a mathematical method that, rather than determining precisely whether a number is prime (has no divisors), uses a statistical technique to decide whether the number is ``probably'' prime. A number that passes this test is called a pseudoprime. The hacker backgammon usage stems from the idea that pseudoprime is almost as good as a prime: it does the job of a prime until proven otherwise, and that probably won't happen.] @Wordentry[PUNT] @verb To give up; to decide not to do. Typically there is no intention of trying again later. Examples: ``Let's punt the movie tonight.'' ``I was going to hack all night to get this feature in, but I decided to punt'' may mean that you've decided not to stay up all night, and may also mean you're not ever even going to put in the feature. [This doubtless comes from football: when you punt, you give up the offense.] @Wordentry[PUSH] @Begin[defns] To put something onto a stack or @wd[PDL]. If a person says something has been pushed onto his pdl, he means yet another thing has been added to the list of things hanging over his head for him to do. @verb To enter upon a digression; to save the current discussion for later. The term @wd[PUSHJ] (push'jay) is also used in this sense. ``Pushj?'' means ``May I interrupt for a moment?'' @End[defns] Antonyms: @wd[POP], @wd[POPJ]. [The PDP-10 has instructions named PUSH and PUSHJ; the former pushes a single word onto a stack, and the latter (PUSH and Jump always) is a subroutine call instruction.] @wordentry[QUADRUPLE BUCKY] @adj @begin[defns] Using all four of the shifting keys @i[control], @i[meta], @i[hyper], and @i[super] while typing a character key (on an @mit keyboard that has all these keys). This combination is very seldom used in practice, because when you invent a new command you usually assign it to some character that is easier to type than using all four shift keys. 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 all the tapes while whistling Beethoven's Fifth Symphony is quadruple bucky @wd[cokebottle].'' Using four shift keys while typing a fifth character, where the four shift keys are the @i[control] and @i[meta] keys on @i[both] sides of the (@mit or @stanford) keyboard. This is very difficult to do! One accepted technique is 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. Such hard-to-type commands are used for things that you want to be very sure can't happen accidentally, such as throwing away your entire program and starting all over. @end[defns] For a complete explanation, see @wd[BUCKY BITS]. @Wordentry[QUES] (kwess) @Begin[Defns] @noun The question mark character (``?''). @interj What? Also @wd[QUES QUES]? See @wd[WALL]. @End[Defns] @Wordentry[QUUX] (kwuhks) Originally, a meta-word like @wd[FOO]. This word was coined by Guy Steele for precisely this purpose when he was young and naive and not yet interacting with the real hacker community; had he known that @wd[FOO] was the standard, he would not have bothered. Many people invent such silly words; this one seems simply to have been lucky enough to have spread a little. In an eloquent display of poetic justice, it has returned to the originator in the form of a nickname as punishment for inventing this bletcherous word in the first place. @word[QUUXY]: (kwuhks'ee) @adj Of or pertaining to a @wd[QUUX]. @Wordentry[RANDOM] @adj @Begin[Defns] Unpredictable (closest to mathematical definition); weird. ``The system's been behaving pretty randomly.'' Assorted; various; undistinguished; uninteresting. ``Who was at the conference?'' ``Just a bunch of random business types.'' Frivolous; unproductive; undirected (pejorative). ``He's just a random loser.'' 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.'' Gratuitously wrong; poorly done and for no good apparent reason. ``This subroutine randomly uses six registers where two would have sufficed.'' In no particular order, though deterministic. ``The I/O channels are in a pool, and when a file is opened one is chosen randomly.'' @noun A random hacker. This is used particularly of high school students who soak up computer time and generally get in the way. The term @wd[HIGH SCHOOL RANDOM] is frequently heard. One who lives at Random Hall at @mit. @End[Defns] @wd[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''). It means roughly ``some particular'' or ``any specific one''. The most common uses are ``J. Random Loser'' and ``J. Random Nurd''. Example: ``Should J. Random Loser be allowed to delete system files without warning?'' @Wordentry[RANDOMNESS] @noun @Begin[defns] An unexplainable misfeature; gratuitous inelegance or inconsistency; failure to do @wd[the right thing]. A @wd[hack] or @wd[crock] that depends on a complex combination of coincidences; also, the combination upon which the hack or crock depends for its accidental failure to malfunction; a situation in which several @wd[BUGS] or @wd[MISFEATURES] happen to cancel each other. @End[defns] See also @wd[PHASE OF THE MOON]. @Wordentry[RAPE] @verb To (metaphorically) screw someone or something, violently; in particular, to destroy a program or information irrecoverably. [This term is usually used in describing damage to the file system (that portion of the computer system responsible for keeping track of all files and maintaining their integrity). Example: ``Some @wd[LOSER] ran a program that did direct output to the disk instead of going through the file system and ended up raping the master file directory.''] @wordentry[RAV] (rav) @noun A Chinese appetizer, known variously in the plural as Peking Ravioli, dumplings, and potstickers. The term ``rav'' is short for ``ravioli'', which among hackers always means the Chinese kind rather than the Italian kind. Both consist of a filling in a pasta shell, but the Chinese kind uses a thinner pasta and is cooked differently, either by steaming or frying. A rav or dumpling can be steamed or fried, but a potsticker is always the fried kind (so called because it sticks to the frying pot and has to be scraped off). ``Let's get hot-and-sour soup and three orders of ravs.'' @Wordentry[RAVE] @verb @Begin[Defns] To persist in discussing a specific subject. To speak authoritatively on a subject about which one knows very little. To complain (load and long) to a person who is not in a position to correct the difficulty. To purposely annoy another person verbally. To proselytize (in a loose or metaphorical sense). @End[Defns] Synonym: @wd[FLAME]. [This term was imported from @wpi. It differs slightly from @wd[FLAME] in that @wd[RAVE] implies that it is the manner or persistence of speaking that is annoying, while @wd[FLAME] implies somewhat more strongly that the subject matter is annoying as well.] @Wordentry[REAL USER] @noun @Begin[Defns] A commercial user; one who is paying ``real'' money for his computer usage. A non-hacker; someone using the system for an explicit purpose (such as a research project, academic coursework, etc.). See @wd[USER]. @End[Defns] It is possible for one person to play different roles at different times. This is especially true of hackers who are also students. ``I need this fixed so I can do a problem set. I'm not complaining out of randomness, but as a real user.'' @Wordentry[REAL WORLD, THE] @noun @Begin[Defns] Those institutions at which people might use the word ``programming'' in the same sentence as ``@c[FORTRAN]'', ``@c[COBOL]'', ``@wd[RPG]'', ``@wd[IBM]'', etc. Places where programs do such commercially necessary but intellectually uninspiring things as compute payroll checks and invoices. To programmers (especially hackers), the location of non-programmers and activities not related to programming. 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. The location of the status quo. Anywhere outside a university. Example: ``Poor fellow, he's left @MIT and gone into the real world.'' @End[Defns] This term is 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. @Wordentry[RIGHT THING, THE] @noun 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. Examples: ``Never let your conscience keep you from doing the right thing!'' ``What's the right thing for @c[LISP] to do when computing @i[a] mod 0? Should it return @i[a], or give a divide-by-zero error?'' @Wordentry[RUDE] @adj @Begin[Defns] Badly written (said of programs). Functionally poor, such as a program that is very difficult to use because of gratuitously poor (random?) design decisions. @End[Defns] Antonym: @wd[CUSPY]. @Wordentry[SACRED] @adj Reserved for the exclusive use of something (this is a metaphorical extension of the standard meaning). Often this means that anyone may look at the sacred object, but clobbering it will cause whatever it is sacred to to malfunction. Example: The comment ``Register 7 is sacred to the interrupt handler'' appearing in a program would be interpreted by a hacker to mean that one part of the program, the ``interrupt handler'', uses register 7, and if any other part of the program changes the contents of register 7 there will be dire consequences. (This information would be useful to him if he had to change a program someone else had written; it tells him that new code added to the program must avoid using register 7.) @Wordentry[SAGA] @noun A cuspy but bogus raving story dealing with N random broken people. Here is an example of a @wd[SAGA]: Jon L. White (login name @wd[JONL]) and I (@wd[GLS]) were office mates at @mit for many years, and worked together on the @c[lisp] language. One April we both flew from Boston to California for a week on research business, to consult face-to-face with some people at @stanford, particularly our mutual friend Richard P. Gabriel (@wd[RPG]; see @wd[GABRIEL]). @wd[RPG] picked us up at the San Francisco airport and drove us back to Palo Alto (going @wd[LOGICAL SOUTH] on route 101, parallel to @wd[EL CAMINO BIGNUM]). Palo Alto is adjacent to Stanford University, and about forty miles south of San Francisco. We ate at The Good Earth, a ``health food'' restaurant, very popular, the sort whose milkshakes all contain honey and protein powder. @wd[JONL] ordered such a shake--the waitress claimed the flavor of the day was ``lalaberry''. I still have no idea what that might be, but it became a running joke. It was the color of raspberry, and @wd[JONL] said it tasted rather bitter. I ate a better tostada there than I have vere had in a Mexican restaurant. After this we went to the local Uncle Gaylord's Old Fashioned Ice Cream Parlor. They make ice cream fresh daily, in a variety of intriguing flavors. It's a chain, and they have a slogan: ``If you don't live near an Uncle Gaylord's--MOVE!'' Also, Uncle Gaylord (a real person) wages a constant battle to force big-name ice cream makers to print their ingredients on the package (like air and plastic and other non-natural garbage). @wd[JONL] and I had first discovered Uncle Gaylord's the previous August, when we had flown to a computer science conference in Berkeley, California, the first time either of us had been on the West Coast. When not in the conference sessions, we had spent our time wandering the length of Telegraph Street, which, like Harvard Square in Cambridge, Massachusetts, in summer was lined with picturesque street vendors and interesting little shops. On that street we discovered Uncle Gaylord's Berkeley store. The ice cream there was very good. During that August visit @wd[JONL] went absolutely bananas (so to speak) over one particular flavor, ginger honey. Therefore, after eating at The Good Earth--indeed, after every lunch and dinner and before bed during our April visit--a trip to Uncle Gaylord's (the one in Palo Alto) was mandatory. We had arrived on a Wednesday, and by Thursday evening we had been there at least four times. Each time @wd[JONL] would get ginger honey ice cream, and proclaim to all bystanders that ``Ginger was the spice that drove the Europeans mad! That's why they sought a route to the East! They used it to preserve their otherwise off-taste meat.'' After the third or fourth repetition @wd[RPG] and I were getting a little tired of this spiel, and began to paraphrase him: ``Wow! Ginger! The spice that makes rotten meat taste good!'' ``Say! Why don't we find some dog that's been run over and sat in the sun for a week and put some @i[ginger] on it for dinner?!'' ``Right! With a lalaberry shake!'' And so on. This failed to faze @wd[JONL]; he took it in good humor, as long as we kept returning to Uncle Gaylord's. He loves ginger honey ice cream. Now @wd[RPG] and his wife @wd[KBT] (Kathy Tracy) were putting us up (putting up with us?) in their home for our visit, so to thank them @wd[JONL] and I took them out to a nice French restaurant of their choosing. I unadventurously chose the filet mignon, and @wd[KBT] had @i[je ne sais quoi du jour], but @wd[RPG] and @wd[JONL] had @i[lapin] (rabbit). (Waitress: ``@i[Oui], we have fresh rabbit, fresh today.'' @wd[RPG]: ``Well, @wd[JONL], I guess we won't need any @i[ginger]!'') We finished the meal late, about 11 @c[PM], which is 2 @wd[AM] Boston time, so @wd[JONL] and I were rather droopy. But it wasn't yet midnight. Off to Uncle Gaylord's! Now the French resturant was in Redwood City, north of Palo Alto. In leaving Redwood City, we somehow got onto route 101 going north instead of south. @wd[JONL] and I woudln't have known the difference had @wd[RPG] not mentioned it. We still knew very little of the local geography. I did figure out, however, that we were headed in the direction of Berkeley, and half-jokingly suggested that we continue north and go to Uncle Gaylord's in Berkeley. @wd[RPG] said ``Fine!'' and we drove on for a while and talked. I was drowsy, and @wd[JONL] actually dropped off to sleep for five minutes. When he awoke, @wd[RPG] said, ``Gee, @wd[JONL], you must have slept all the way over the bridge!'' referring to the one spanning San Francisco Bay. Just then we came to a sign that said ``University Avenue''. I mumbled something about working our way over to Telegraph Street; @wd[RPG] said ``Right!'' and maneuvered some more. Eventually we pulled up in front of an Uncle Gaylord's. Now I hadn't really been paying attention because I was so sleepy, and I didn't really understand what was happening until @wd[RPG] let me in on it a few moments later, but I was just alert enough to notice that we had somehow some to the Palo Alto Uncle Gaylord's after all. @wd[JONL] noticed the resemblance to the Palo Alto store, but hadn't caught on. (The place is lit with red and yellow lights at night, and looks much different from the way it does in daylight.) He said, ``This isn't the Uncle Gaylord's I went to in Berkeley! It looked like a barn! But this place looks @i[just like] the one back in Palo Alto!'' @wd[RPG] deadpanned, ``Well, this is the one @i[I] alwasy come to when I'm in Berkeley. They've got two in San Francisco, too. Remember, they're a chain.'' @wd[JONL] accepted this bit of wisdom. And he was not totally ignorant--he knew perfectly well that University Avenue was in Berkeley, not far from Telegraph Street. What he didn't know was that there is a completely different University Avenue in Palo Alto. @wd[JONL] went up to the counter and asked for ginger honey. The guy at the counter asked whether @wd[JONL] would like to taste it first, evidently their standard procedure with that flavor, as not too many people like it. @wd[JONL] said, ``I'm sure I like it. Just give me a cone.'' The guy behind the counter insisted that @wd[JONL] try just a taste first. ``Some people think it tastes like soap.'' @wd[JONL] insisted, ``Look, I @wd[love] ginger. I eat Chinese food. I eat raw ginger roots. I already went through this hassle with the guy back in Palo Alto. I @i[know] I like that flavor!'' At the words ``back in Palo Alto'' the guy behind the counter got a very strange look on his face, but said nothing. @wd[KBT] caught his eye and winked. Through my stupor I still hadn't quite grasped what was going on, and thought @wd[RPG] was rolling on the floor laughing and clutching his stomach just because @wd[JONL] had launched into his spiel (``makes rotten meat a dish for princes'') for the forty-third time. At this point @wd[RPG] clued me in fully. @wd[RPG], @wd[KBT], and I retreated to a table, trying to stifle our chuckles. @wd[JONL] remained at the counter, talking about ice cream with the guy b.t.c., comparing Uncle Gaylord's to other ice cream shops and generally having a good old time. At length the g.b.t.c@. said, ``How's the ginger honey?'' @wd[JONL] said, ``Fine! I wonder what exactly is in it?'' Now Uncle Gaylord publishes all his recipes and even teaches classes on how to make his ice cream at home. So the g.b.t.c@. got out the recipe, and he and @wd[JONL] pored over it for a while. But the g.b.t.c@. could contain his curiosity no longer, and asked again, ``You really like that stuff, huh?'' @wd[JONL] said, ``Yeah, I've been eating it constantly back in Palo Alto for the past two days. In fact, I think this batch is about as good as the cones I got back in Palo Alto!'' G.b.t.c@. looked him straight in the eye and said, ``You're @i[in] Palo Alto!'' @wd[JONL] turned slowly around, and saw the three of us collapse in a fit of giggles. He clapped a hand to his forehead and exclaimed, ``I've been @wd[HACKED]!'' @Wordentry[SEMI] @Begin[Defns] (sem'ee) @noun The semicolon character ``@f[;]''. Example: ``Commands to GRIND are prefixed by semi-semi-star'' means that GRIND commands (whatever they are) begin with ``@t[;;*]'', not with 1/4 of a star. (sem'ee, sem'ie) Prefix with words such as ``immediately'', as a qualifier meaning ``sort of'' or ``not really''. Example: ``When is the system coming up?'' ``Semi-immediately.'' @End[Defns] See @wd[CHARACTERS]. @Wordentry[SHIFT LEFT (RIGHT) LOGICAL] @verb To move oneself to the left (right). To move out of the way. As an imperative, this implies ``Get out of that (my) seat! You can move to that empty one to the left (right).'' [This term is used technically to describe the motions of information bits in a computer register. Most computers have specific instructions with these names to perform such motions. The slang usage asks the listener to imagine that he is a bit and to perform the appropriate motion. Other computer instructions, such as ``rotate left'' and @wd[EXCH], are also used in this way. The PDP-10 instruction that performs left-shifting is called @wd[LSH] (lish), and so that word is sometimes used too.) @Wordentry[SHRIEK] The exclamation point character ``@t[!]''. Synonyms: @wd[BANG], @wd[EXCL]. See @wd[CHARACTERS]. @wordentry[69] @adj A moderately large quantity. Example: ``Go away, I have 69 things to do before I @wd[gronk out].'' [Actually, any number less than 100 but large enough to have no obvious special properties will be recognized as a ``large number''. There is no denying that ``69'' is the local favorite. I don't know whether its origins are related to the obscene interpretation, but I do know that 69 decimal = 105 octal, and 69 hexadecimal = 105 decimal, which is a nice property.] @Wordentry[SLOP] @noun @Begin[Defns] A one-sided @wd[fudge factor], that is, an allowance for error but only in one of two directions. For example, if you need a piece of wire ten feet long and have to guess when you cut it, you make very sure to cut it too long, by a large amount if necessary, rather than too short by even a little bit, because you can always cut off the @wd[slop] but you can't paste it back on again. When discrete quantities are involved, slop is sometimes introduced to avoid the possibility of a @wd[fencepost error]. The ratio of the size or speed of code generated by a compiler to that of code carefully written by hand, minus 1. Suppose that you have the choice to write a program in a so-called ``high-level'' language such as @wd[LISP] or @wd[PASCAL], or to hand-craft it directly in machine language. (The advantage of the former is that you can write the program more easily; the advantage of the latter is that the program may be more efficient.) Then the @wd[SLOP], as defined by the formula given above, is the amount of inefficiency in the final program because you used a compiler instead of hand-crafting it. This number is often used as a measure of the goodness of a compiler; slop below 5% is very good, and 10% is usually acceptable for most purposes. @End[Defns] [The second definition of @wd[slop] is consonant with the first under the assumption that a compiler will never produce better code than a competent hacker. However, this assumption is not always valid; recent software technology has produced compilers that sometimes produce better code than a good hacker because the hacker will get bored hand-crafting mountains of code and therefore be less @wd[tense] than he could be. Compilers don't get bored.] @Wordentry[SLURP] @verb To read a large data file entirely into the computer's main memory before beginning to work on it. (This may be contrasted with the strategy of reading a small piece at a time, processing it, and then reading the next piece.) Example: ``This program slurps in a 1024-by-1024 matrix of numbers and then @wd[crunches] them using an FFT (Fast Fourier Transform).'' @Wordentry[SMART] @adj @Begin[defns] Said of a program of other object that does @wd[THE RIGHT THING] 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 (although some researchers in Artificial Intelligence are working toward that goal). @word[SMART TERMINAL]: @noun A terminal that has enough computing capability to perform useful work independently of the main computer. @End[defns] @Wordentry[SMOKING CLOVER] @noun A psychedelic color @wd[munch] due to Gosper. This is a display hack that produces a very strong optical illusion. A series of nested, wildly colored cloverleaf patterns appear on the screen and seem to expand in size indefinitely. When the program is stopped, the patterns are frozen; but because you have been watching them expand for a while, they seem to suddenly contract. The display changes with a speed that is awesome to anyone who is familiar with the computer hardware being used; this speed is made possible by a very clever programming technique. Also, the cloverleaf pattern is the non-obvious result of another program that is startlingly simple. For both of these reasons, as well as the illusion, Smoking Clover is a favorite @wd[hack]. @Wordentry[SMOP] (ess'em'oh'pee) @noun An acronym for ``a Small Matter Of Programming''. A piece of program code, not yet written, whose anticipated length is significantly greater than its intellectual complexity. [This term is used to refer to a program that could obviously be written, but is not worth the trouble. It is also used ironically to imply that a difficult problem can be easily solved because a program can be written to do it; the irony is that it is very clear that writing such a program will be a great deal of work. Example: ``It's easy to change a @c[FORTRAN] compiler to compile @wd[COBOL] as well; it's just a Small Matter of Programming.''] @wordentry[SNAIL MAIL] @noun Mail sent by the Postal Service rather than electronically; sometimes written as one word, ``SnailMail''. At its worst, electronic mail usually arrives within half an hour; compare that to the typical three days for SnailMail. If you ask a hacker for his mailing address, he will usually give you his network address for electronic mail. You have to say ``What's your SnailMail address?'' if you want to send him a package. @Wordentry[SNARF] (snahrf) @verb @Begin[defns] To grab, especially a large document or file for the purpose of using it either with or without the author's permission. Examples: ``I snarfed the DDT manual from your desk last night.'' ``This program snarfs all the file directories and searches for files named `@t[DELETE.ME]'.'' @word[SNARF DOWN]: to snarf, sometimes with the connotation of absorbing, processing, or understanding. ``I think I'll snarf down the list of DDT commands so I'll know what's changed recently.'' @End[defns] @Wordentry[SOFTWARE ROT] @noun A 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''. Synonym: @wd[BIT DECAY]. @Wordentry[SOFTWARILY] (sawft-war'-:l-ee) @adv In a way pertaining to software. ``The system is softwarily unreliable.'' Note: the adjective ``softwary'' is @i[not] used. See @wd[HARDWARILY]. @Wordentry[SOS] @Begin[Defns] (ess'oh-ess') @noun A @wd[losing] text editor. Once, back in the 1960's, when a text editor was needed for the PDP-6, a hacker @wd[CRUFTED TOGETHER] a quick-and-dirty ``stopgap editor'' to be used until a better one was written. Unfortunately, the old one was never really discarded when new ones came along. @wd[SOS] is a descendant of that editor; @wd[SOS] means ``Son of Stopgap''. [Since then other programs similar in style to @wd[SOS] have been written, notably @wd[BILOS] (bye'lohss) the Brother-In-Law Of Stopgap.] (sahss) @verb To subtract one from a number; to decrease the amount of something. This @wd[SOS] means ``Subtract One and do not Skip''; it is an antonym of @wd[AOS], named after a PDP-10 instruction. @End[Defns] @Wordentry[SPLAT] (splat) @noun @Begin[Defns] Name used in many places (DEC, IBM, and others) for the ASCII asterisk (``@f[*]'') character. Name used by some people for the ASCII pound-sign (``@f[#]'') character. Name used by some people for the extended ASCII circle-x character ``@#''. (This character is also called ``circle-x'', ``blobby'', and ``frob'', among other names.) Name for the semi-mythical extended ASCII circle-plus character ``@#''. The canonical name for an output routine that outputs whatever the the local interpretation of @wd[splat] is. @End[Defns] Nobody really agrees what character ``splat'' is, but the term is common. See @wd[CHARACTERS]. @Wordentry[STATE] @noun Condition, situation. Examples: ``What's the state of you latest hack?'' ``It's winning away.'' ``The system tried to read and write the disk simultaneously and got into a totally wedged state.'' A standard question is ``What's your state?'' which means ``What are you doing?'' or ``What are you about to do?'' Typical answers might be ``I'm about to @wd[gronk out]'' or ``I'm hungry''. Another standard question is ``What's the state of the world?'' meaning ``What's new?'' or ``What's going on?''. @Wordentry[STOPPAGE] (stahp':j) @noun Extreme @wd[lossage] resulting in something (usually vital) becoming completely unusable. Example: ``The recent system stoppage was caused by a @wd[fried] transformer.'' @Wordentry[SUPERPROGRAMMER] @noun A prolific programmer; one who can code exceedingly well and quickly. Not all hackers are superprogrammers, but many are. [Productivity can vary from one programmer to another by factors of as much as 1000. For example, programmer A might be able to write an average of 3 lines of working code in one day, while another, with the proper tools and skill, might be able to write 3,000 lines of working code in one day. This variance is astonishing, appearing in very few other areas of human endeavor. The term @wd[SUPERPROGRAMMER] is more commonly used within such places as IBM than in the hacker community. It tends to stress productivity rather than creativity or ingenuity. Hackers tend to prefer the terms @wd[HACKER] and @wd[WIZARD].] @Wordentry[SWAP] @Begin[defns] @verb To exchange; to trade places. See @wd[EXCH]. @verb To move information from a fast-access memory to a slow-access memory (@wd[SWAP OUT]), or vice versa (@wd[SWAP IN]). This is a technical term in computer science, and often specifically refers to the use of disks as ``virtual memory''. As pieces of data or program are needed, they are swapped into main memory for processing; when they are no longer needed for the nonce they are swapped out again. The slang use of these terms is as a fairly exact analogy referring to people's memories. Cramming for an exam might be spoken of as swapping in. If you temporarily forget someone's name, but then remember it, your excuse is that it was swapped out. To ``keep something swapped in'' means to keep it fresh in your memory: ``I reread the TECO manual every few months to keep it swapped in.'' If someone interrupts you just got a good idea, you might say, ``Wait a moment while I write this down so I can swap it out'', implying that if you don't write it down it will get swapped out (forgotten) as you talk. @End[defns] @Wordentry[SYSTEM] @noun @Begin[Defns] The supervisor program on the computer; the program that is responsible for coordinating the activities of the various users of the computer. The entire computer system, including input/output devices, the supervisor program, and possibly other software. Any large-scale program. Any method or methodology. The way things are usually done. The existing bureaucracy. ``You can't beat the system.'' @word[SYSTEM HACKER] @noun One who hacks the system (in sense 1 only; for sense 3 one mentions the particular program, as in @wd[LISP HACKER] or @wd[TECO HACKER]). @End[Defns] @Wordentry[T] (tee) @Begin[Defns] A particular time; see @wd[TIME T]. (The variable T is customarily used in physics to represent points in or quantities of time.) @Begin[Multiple] Yes. This word is used in reply to a question, particularly one asked using the ``-P'' convention. Example: ``Foodp?'' ``T.'' That simple interchange means, ``Do you want to come eat with us?'' ``Sure.'' See @wd[NIL]. [In the @c[LISP] language, the name T means ``true'', among other things. Some hackers use ``T'' and ``NIL'' instead of ``yes'' and ``no'' almost reflexively. This sometimes causes misunderstandings. When a waiter or flight attendant asks whether a hacker wants coffee, he may well respond ``T'', meaning that he wants coffee; but of course he will be brought a cup of tea instead. As it happens, most hackers like tea at least as well as coffee, particularly those who frequent Chinese restaurants, so it's not that big a problem.] @End[Multiple] @End[Defns] @Wordentry[TALK MODE] A situation in which two or more terminals are logically linked together so that whatever is typed on the keyboard of any one appears on the screens of all. This is used for conversation via computer. See @wd[COM MODE] and @wd[MODE]. @Wordentry[TASTE] @noun @Begin[defns] Aesthetic pleasance; the quality in programs which tends to be inversely proportional to the number of @wd[features], @wd[hacks], @wd[crocks], and @wd[kluges] programmed into it. @word[TASTY] @adj Aesthetically pleasing; @wd[FLAVORFUL]. Example: ``This feature comes in N tasty flavors.'' @End[defns] Although @wd[TASTEFUL] and @wd[FLAVORFUL] are essentially synonyms, @wd[TASTE] and @wd[FLAVOR] are not. @wd[TASTE] refers to sound judgement on the part of the creator; a program or feature can @i[exhibit] taste but cannot ``have'' taste. On the other hand, a feature can have @wd[FLAVOR]. Also, @wd[FLAVOR] has the additional meaning of ``kind'' or ``variety'' not shared by @wd[TASTE]. @wd[FLAVOR] is a more popular word among hackers than @wd[TASTE], though both are used. @Wordentry[TECO] (tee'koh) @Begin[Defns] @noun A text editor developed at @MIT, and modified by just about everybody. If all the dialects are included, TECO might well be the single most prolific editor in use. Noted for its powerful pseudo-programming features and its incredibly hairy syntax. As an example, here is a TECO program that takes a list of names like this: @Begin[Verbatim, leftmargin +1in] Loser, J. Random Quux, The Great Dick, Moby @End[Verbatim] sorts them alphabetically according to last name, and then puts the last name last, removing the comma, to produce this: @Begin[Verbatim, leftmargin +1in] Moby Dick J. Random Loser The Great Quux @End[Verbatim] The program is: @Begin[Verbatim, leftmargin +1in] [1 J ^P $ L $ $ J <.-Z; .,(S,$ -D .)FX1 @@F^B $K :L I $ G1 L>$$ @End[Verbatim] In fact, this very program was used to produce the second, sorted list from the first list! The manuscript for the book was produced using the EMACS editor, which is built on top of TECO and allows you to execute TECO programs. The first time I tried the program it had a @wd[bug]: I had accidentally omitted the ``@f[@@]'' in front of ``@f[F^B]'', which as anyone can see is clearly the wrong thing. It worked fine the second time. There is no space to describe all the features of TECO, but I will note that ``@f[^P]'' means ``sort'' and ``@f[J <.-Z; ... L>]'' is an idiomatic series of commands for ``do once for every line''. @verb To edit using the TECO editor in one of its infinite forms; sometimes used to mean ``to edit'' even when not using TECO! @End[Defns] @Wordentry[TENSE] @adj Of programs, very clever and efficient. A tense piece of code often got that way because it was highly @wd[bummed], but sometimes it was just based on a great idea. As an exmaple, this comment was found in a clever display routine by Mike Kazar, a student hacker at @cmu: ``This routine is so @wd[tense] it will bring tears to your eyes. Much thanks to Craig Everhart and James Gosling for inspiring this @wd[hack attack].'' A tense programmer is one who produces tense code. They say that PDP-10 code flows from the pencil of hacker Bill Gosper in a maximally tense state. I don't waste my time trying to bum even one instruction from a PDP-10 propram if I learn that Gosper wrote it. @Wordentry[TERPRI] (tur'pree, t:r'pree) @verb To output a @wd[CRLF]; to terminate a line of text and start the next line. This comes from the name of the @c[LISP] routine that performs this action; it is a contraction of ``TERminate PRInt line''. @Wordentry[THEORY] @noun Any idea, plan, story, policy, or set of rules. This is a generalization and abuse of the technical meaning. Examples: ``What's the theory on fixing this TECO loss?'' ``What's the theory on dinner tonight?'' (``Chinatown, I guess.'') ``What's the current theory on letting losers on during the day?'' ``The theory behind this change is to fix the following well-known screw...'' @wordentry[TENURED GRADUATE STUDENT] @noun One who has been in graduate school for ten years (the usual maximum is five or six): a ``ten-yeared'' student (get it?). Students don't really get tenure, of course, the way professors do, but a tenth-year graduate student has probably been around the university longer than any non-tenured professor. @Wordentry[THRASH] @verb To move wildly or violently, without accomplishing anything useful. The connotation is of a maximum of motion with a minimum of effectiveness. Computer systems that are overloaded waste most of their time @wd[SWAPPING] information between disk and memory rather than performing useful computation, and are therefore said to thrash. Someone who keeps changing his mind is said to be thrashing. @Wordentry[TIME T] @noun @Begin[Defns] A time or instant unspecified but understandable from context. Often used in conjunction with a later time ``T+1'' or ``T+N''. Example: ``We'll meet on campus at time T or at Louie's at time T plus one.'' means, in the context of going out for dinner, ``If we meet at Louie's directly, we can meet there a little later than if we meet on campus and then have to travel to Louie's.'' (Louie's is a Chinese restaurant in Palo Alto that is a favorite with hackers. Louie makes the best potstickers I've ever tasted. See @wd[RAV].) Had the number 30 been used instead of ``one'', it would have implied that the travel time from campus to Louie's is thirty minutes; whatever time T is (and that hasn't been decided on yet), you can meet half an hour later at Louie's than you could on campus and end up eating at the same time. @word[SINCE (OR AT) TIME T EQUALS MINUS INFINITY]: A long time ago; for as long as anyone can remember; at the time that some particular frob was first designed. ``That feature has been @wd[BROKEN] since time T equals minus infinity.'' @End[Defns] Sometimes the word ``time'' is omitted if there is no danger of confusing ``T'' as a time with ``T'' meaning ``yes''. See @wd[T]. @Wordentry[TOOL] @Begin[defns] @verb To work hard; to study; to ``cram'' for an exam. This is an antonym of sorts for @wd[HACK]: tooling is working without enjoying it. The distinction is useful to hackers who are also students: tooling is programming or other work done for courses. Example: ``I have to tool chemistry for a while before I @wd[gronk out].'' @noun A person who (seemingly) always tools and never hacks; a nurd (or nerd). This term is used throughout @MIT; students refer to themselves with more or less pride as ``Tech tools''. @End[defns] @Wordentry[TTY] (tit'ee) @noun @Begin[defns] A computer terminal of the Teletype variety, characterized by a noisy mechanical printer, a very limited character set, and poor print quality. This term is antiquated (like the TTY's themselves). The definition must be considered relative to modern terminals; in their heyday TTY's were useful and fairly reliable workhorses. Any computer terminal at all, especially the one is controlling a computer program under discussion, or that the program can display information on. Example: ``This program lists the current file directory on the TTY.'' @End[defns] See also @wd[GLASS TTY]. @wordentry[TOGGLE] @verb To change a @wd[bit] from whatever state it is in to the other state; to change from 1 to 0 or from 0 to 1. This probably comes from ``toggle switches'', such as standard light switches, though the word ``toggle'' apparently originally referred to the mechanism that keeps the switch in the position to which it is flipped, rather than to the fact that the switch has two positions. There are four things you can do to a bit: set it (force it to be 1), clear (or zero) it, leave it alone, or toggle it. (Mathematically, one would say that there are four distinct boolean-valued functions of one boolean argument, but saying that is @i[much] less fun than talking about toggling bits.) @Wordentry[TWEAK] @verb To change slightly, relative to some reference point; to adjust finely. If a program is almost correct, rather than figuring out the precise problem, you might just keep tweaking it until it works. Synonym: @wd[TWIDDLE]. See also @wd[FROBNICATE] and @wd[FUDGE FACTOR]. @Wordentry[TWENEX] (twen'eks) @noun The TOPS-20 operating system distributed by DEC for the DECsystem-20 computer, a sucessor to the PDP-10. There was an operating system for the PDP-10 called TOPS-10, so TOPS-20 is an obvious name for a DECsystem-20 operating system, even though TOPS-20 is nothing like TOPS-10. TOPS-10 was a typically @wd[crufty] operating system produced by DEC itself. The firm of Bolt, Beranek, and Newman (BBN) developed its own operating system, called TENEX (for ``TEN EXecutive system''). DEC created TOPS-20 by copying TENEX and adapting it for the -20. The term @wd[TWENEX] is therefore a contraction of ``twenty TENEX''. DEC people tend to cringe when they hear TOPS-20 referred to as ``Twenex'', but the term seems to be catching on nevertheless. The abbreviation ``20x'' is also used and also pronounced ``twenex''. @Wordentry[TWIDDLE] (twid':l) @noun @Begin[Defns] The tilde character ``~''. See @wd[CHARACTERS]. A small and insignificant change to a program. A twiddle usually fixes one bug and generates several new ones. @verb To change something in a small way. Bits, for example, are often twiddled. Twiddling a switch or knob implies much less sense of purpose than toggling or tweaking it; see @wd[FROBNICATE]. To speak of twiddling a bit connotes aimlessnes, and at best doesn't specify what you're doing to the bit; by contrast, @wd[TOGGLING] a bit has a more specific meaning. @End[Defns] @Wordentry[UP] @adj @Begin[Defns] Working, in order. Example: ``The down escalator is up.'' Antonym: @wd[DOWN]. @word[BRING UP] @verb To create a working version and start it. Examples: ``They just brought up the system.'' ``JONL is going to bring up a new LISP compiler tonight.'' Antonym: @wd[TAKE DOWN]. @End[Defns] @Wordentry[USER] @noun @Begin[defns] Someone doing ``real work'' with the computer, who uses a computer as a means rather than an end. Someone who pays to use a computer. See @wd[REAL USER]. A programmer who will believe anything you tell him. One who asks silly questions. See @wd[LUSER]. Someone who uses a program from the outside, however skillfully, without getting into the internals of the program. One who reports bugs instead of just going ahead and fixing them. @End[defns] Basically, there are two classes of people who work with a program: there are implementors (hackers) and users (losers). The users are looked down on by hackers to a mild degree because they don't understand the full ramifications of the system in all its glory. (The few users who do are known as @wd[real winners].) The term is a relative one: a consummate hacker may be a user with respect to some program he himself does not hack. A @c[LISP] hacker might be one who maintains @c[LISP] or one who uses @c[LISP] (but with the skill of a hacker). A @c[LISP] user is one who uses @c[LISP], whether skillfully or not. Thus there is some overlap between the two terms; the subtle distinctions must be resolved by context. It is true that users ask questions (of necessity). Sometimes they are thoughtful or deep. Very often they are annoying or downright stupid, apparently because the user failed to think for two seconds or look in the documentation before bothering the maintainer. @Wordentry[VANILLA] @adj Standard, usual, of ordinary @wd[flavor]. ``It's just a @wd[vanilla] terminal; it doesn't have any interesting @wd[features].'' When used of food, this term very often does not mean that the food is flavored with vanilla extract! For example, ``vanilla-flavored wonton soup'' (or simply ``vanilla wonton soup'') means ordinary wonton soup, as opposed to hot-and-sour wonton soup. This word differs from @wd[CANONICAL] in that the latter means ``the thing you always use (or the way you always do it) unless you have some strong reason to do otherwise'', whereas @wd[VANILLA] simply means ``ordinary''. For example, when @mit hackers go to Colleen's Chinese Cuisine, hot-and-sour wonton soup is the @wd[CANONICAL] wonton soup to get (because that is what most of them usually order) even though it isn't the @wd[VANILLA] wonton soup. @Wordentry[VAXEN] (vaks':n) The plural standardly used among hackers for the DEC VAX computers. ``Our installation has four PDP-10's and twenty VAXEN.'' The DEC operating system for the VAX is called VMS (for Virtual Memory System). It has its advantages, but sometimes it seems to run rather slowly. Hence this limerick: @Begin[Verse] There once was a system called VMS Of cycles by no means abstemious. It's chock-full of hacks And runs on a VAX And makes my poor stomach all squeamious. --The Great Quux @End[Verse] @Wordentry[VIRTUAL] @adj Performing the functions of. Virtual memory acts like real memory but isn't. (A virtual memory system uses a combination of a small main memory plus a magnetic disk to give the illusion that a computer has a large main memory. It does this by @wd[SWAPPING] information between the main mmeory and the disk as needed.) This term is synonymous with @wd[LOGICAL], exccept that @wd[VIRTUAL] is never used with compass directions. @Wordentry[VISIONARY] @noun One who hacks vision, in the sense of an Artificial Intelligence researcher working on the problem of getting computers to ``see'' things using TV cameras. (There isn't any problem in sending information from a TV camera to a computer. The problem is, how can the computer be programmed to make use of the camera information? See @wd[SMOP].) @Wordentry[WALL] @interj An indication of confusion, usually spoken with a quizzical tone. ``Wall??'' A request for further explication. This seems to be a shortened form of ``hello, wall'', apparently from the phrase ``up against a blank wall''. This term is used primarily at @wpi. @Wordentry[WALLPAPER] @Begin[defns] @noun A program listing or, especially, a a transcript of all or part of a login session, showing everything that ever appeared on the terminal. (The idea was that the @wd[LPT] paper for such listings was essentially good only for wallpaper, as evidenced at @stanford where it was in fact used as wallpaper to cover windows to keep the light out.) @word[WALLPAPER FILE] @noun The file that contains the wallpaper information before it is actually printed on paper. (Sometimes you don't intend ever to produce a real paper copy of the file, because you can look at the file directly on your terminal, but it is still called a ``wallpaper file''.) @End[defns] This term is used less nowadays, especially since other systems have developed other terms for the concept. PHOTO on TWENEX). The term possibly originated on the ITS system at @mit, where the commands to begin and end transcript files are still ``@f[:WALBEG]'' and ``@f[:WALEND]'', which produce a file named ``@f[WALL PAPER]''. @Wordentry[WEDGED] @adj @Begin[defns] To be stuck, incapable of proceeding without help. This is different from having @wd[crashed]. If the system has crashed, then it has become totally non-functioning. If the system is wedged, it is trying to do something but cannot make progress; it may be capable of doing a few things, but not be fully operational. For example, the system may become wedged if the disk controller fries; there are some things you can do without using the disks, but not many. Being wedged is slightly milder than being @wd[HUNG]. This term is sometimes used as a synonym for @wd[DEADLOCKED]. See also @wd[HANG], @wd[LOSING], @wd[CATATONIA], and @wd[BUZZ]. Of a person, suffering severely from misconceptions. Examples: ``He's totally wedged--he's convinced that he can levitate through meditation.'' ``I'm sorry. I had a bit set that you were responsible for TECO, but I was wedged.'' @word[WEDGITUDE] (wedj'i-tood) The quality or state of being wedged. @End[defns] @Wordentry[WHEEL] @noun @Begin[Defns] A ``privilege'' bit that, when set, canonically allows the possessor to perform any operation whatsoever on a timesharing system, such as read or write any file on the system regardless of protections, change or or look at any address in the running monitor, crash or reload the system, and kill/create jobs and user accounts. The term was invented on the TENEX operating system, and carried over to TOPS-20, Xerox-IFS, and others. See @wd[TWENEX]. A person who possesses a set wheel bit (and who therefore has great privilege and power on that system). ``We need to find a wheel to unwedge the hung tape drives.'' @Word[WHEEL WARS] A period during which student wheels hack each other by attempting to log each other out of the system, delete each other's files, or otherwise wreak havoc, usually at the expense of the lesser users. A battle of Titans (heh heh). @End[Defns] @Wordentry[WIN] @Begin[Defns] @verb To succeed. A program wins if no unexpected conditions arise. Antonym: @wd[LOSE]. @noun Success, or a specific instance thereof. A pleasing outcome. A @wd[FEATURE]. Emphatic forms: @wd[MOBY WIN], @wd[SUPER WIN], @wd[HYPER-WIN] For some reason @wd[SUITABLE WIN] is also common at @MIT, usually in reference to a satisfactory solution to a problem. Antonym: @wd[LOSS]. @wd[BIG WIN] @noun The results of serendipity. @wd[WIN BIG] @verb To experience serendipity. ``I went shopping and won big; there was a two-for-one sale.'' @wd[WIN WIN] @interj @Word[WINNER] @noun An unexpectedly good situation, program, programmer, or person. Albert Einstein was a winner. Antonym: @wd[LOSER]. @wd[REAL WINNER] @noun This term is often used sarcastically, but is also used as high praise. @Word[WINNAGE] (win':j) @noun The situation when a @wd[lossage] is corrected, or when something is winning. Quite rare. Usage: also quite rare. @Wordentry[WINNITUDE] (win':-tood) @noun The quality of winning (as opposed to @wd[WINNAGE], which is the result of winning). Example: ``That's really great! Boy, what winnitude!'' @End[Defns] @Wordentry[WIZARD] @noun @Begin[Defns] A person who knows how a complex piece of software or hardware works (that is, who @wd[GROKS] it); someone who can find and fix bugs quickly in an emergency. This term differs somewhat from @wd[HACKER]. Someone is a hacker is he has general having ability, but is only a wizard with respect to something if he has specific detailed knowledge of that thing. A good hacker could become a wizard for something given the time to study it. A person who is permitted to do things forbidden to ordinary people. For example, an Adventure wizard at @stanford may play the Adventure game during the day, which is forbidden (the program simply refuses to play) to most people because it uselessly consumes too many @wd[CYCLES]. @word[WIZARDLY] @adj Pertaining to wizards. A wizardly @wd[feature] is one that only a wizard could understand or use properly. @End[Defns] @Wordentry[WOW] The exclamation point character ``@f[!]''. Synonyms: @wd[BANG], @wd[EXCL], @wd[SHRIEK]. @wordentry[XOR] (eks'ohr) @conj Exclusive or. ``A xor B'' means ``A or B, but not both''. Example: ``I want to get cherry pie @wd[xor] a banana split.'' This derives from the technical use of the term as a function on truth-values that is true if either of two arguments is true but not both. @Wordentry[XYZZY] (eks'wie'zee'zee'wie, zi'zee) The @wd[CANONICAL] ``magic word''. This comes from the Adventure game, in which the idea is to explore an underground cave with many rooms to collect treasure. If you type @wd[XYZZY] at the appropriate time, you can move instantly between two otherwise distant points. If, therefore, you encounter some bit of @wd[MAGIC], you might remark on this quite succinctly by saying simply ``XYZZY''! Example: ``Ordinarily you can't look at someone else's screen if he has protected it, but if you type quadruple-bucky-CLEAR the system will let you do it anyway.'' ``XYZZY!'' @Wordentry[YOYO MODE] @noun A state in which the system is said to be when it rapidly alternates several times between being @wd[up] and being @wd[down]. @Wordentry[YU-SHIANG WHOLE FISH] (yoo'hsyang', yoo'shang') @noun The Greek letter lower-case gamma, when written with a loop in its tail ``@#'', making it look like a little fish swimming down the page. The term is actually the name of a Chinese dish in which a fish is cooked whole (not @wd[PARSED]) and covered with Yu Shiang sauce. This bit of slang is used primarily by people on the @MIT LISP Machine computers, which can display this character on their screens. The term also tends to elicit incredulity from people who hear about it second-hand. See @wd[CHARACTERS]. @wordentry[ZAP] @Begin[defns] @noun Spiciness. @verb To make food spicy. @verb To make someone ``suffer'' by making his food spicy. (Most hackers love spicy food. Hot-and-sour soup is wimpy unless it makes you blow your nose for the rest of the meal.) @word[ZAPPED] @adj Spicy. @End[defns] This term is used to distinguish between food that is hot (in temperature) and food that is ``hot'', that is, spicy. For example, the Chinese appetizer Bon Bon Chicken is a kind of chicken salad that is cold but zapped. @Wordentry[ZERO] @verb @Begin[Defns] To set to zero. Usually said of small pieces of data, such as bits or words. By extension, to erase; to discard all data from. Said of disks and directories, where ``zeroing'' need not involve actually writing zeroes throughout the area being zeroed. One may speak of something being @wd[LOGICALLY ZEROED] rather than being @wd[PHYSICALLY ZEROED]. @End[Defns] @end[cruft]