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

a larger class (this is straight from

[125]BNF). Examples like the following are common:

So this walks into a bar one day...

There is also an accepted convention for `writing under erasure'; the

text

Be nice to this fool^H^H^H^Hgentleman,

he's visiting from corporate HQ.

reads roughly as "Be nice to this fool, er, gentleman...", with irony

emphasized. The digraph ^H is often used as a print representation for

a backspace, and was actually very visible on old-style printing

terminals. As the text was being composed the characters would be

echoed and printed immediately, and when a correction was made the

backspace keystrokes would be echoed with the string '^H'. Of course,

the final composed text would have no trace of the backspace

characters (or the original erroneous text).

This convention parallels (and may have been influenced by) the ironic

use of `slashouts' in science-fiction fanzines.

A related habit uses editor commands to signify corrections to

previous text. This custom faded in email as more mailers got good

editing capabilities, only to tale on new life on IRCs and other

line-based chat systems.

I've seen that term used on alt.foobar often.

Send it to Erik for the File.

Oops...s/Erik/Eric/.

The s/Erik/Eric/ says "change Erik to Eric in the preceding". This

syntax is borrowed from the Unix editing tools ed and sed, but is

widely recognized by non-Unix hackers as well.

In a formula, * signifies multiplication but two asterisks in a row

are a shorthand for exponentiation (this derives from FORTRAN). Thus,

one might write 2 ** 8 = 256.

Another notation for exponentiation one sees more frequently uses the

caret (^, ASCII 1011110); one might write instead 2^8 = 256. This goes

all the way back to Algol-60, which used the archaic ASCII `up-arrow'

that later became the caret; this was picked up by Kemeny and Kurtz's

original BASIC, which in turn influenced the design of the bc(1) and

dc(1) Unix tools, which have probably done most to reinforce the

convention on Usenet. (TeX math mode also uses ^ for exponention.) The

notation is mildly confusing to C programmers, because ^ means bitwise

exclusive-or in C. Despite this, it was favored 3:1 over ** in a

late-1990 snapshot of Usenet. It is used consistently in this lexicon.

In on-line exchanges, hackers tend to use decimal forms or improper

fractions (3.5' or7/2') rather than `typewriter style' mixed

fractions (`3-1/2'). The major motive here is probably that the former

are more readable in a monospaced font, together with a desire to

avoid the risk that the latter might be read as `three minus

one-half'. The decimal form is definitely preferred for fractions with

a terminating decimal representation; there may be some cultural

influence here from the high status of scientific notation.

Another on-line convention, used especially for very large or very

small numbers, is taken from C (which derived it from FORTRAN). This

is a form of scientific notation' usinge' to replace `*10^'; for

example, one year is about 3e7 seconds long.

The tilde (~) is commonly used in a quantifying sense of

approximately'; that is, ~50 meansabout fifty'.

On Usenet and in the [126]MUD world, common C boolean, logical, and

relational operators such as |, &, ||, &&, !, ==, !=, >, <, >=, and =<

are often combined with English. The Pascal not-equals, <>, is also

recognized, and occasionally one sees /= for not-equals (from Ada,

Common Lisp, and Fortran 90). The use of prefix `!' as a loose synonym

for not-' orno-' is particularly common; thus, `!clue' is read

no-clue' orclueless'.

A related practice borrows syntax from preferred programming languages

to express ideas in a natural-language text. For example, one might

see the following:

In jrh578689@thudpucker.com J. R. Hacker wrote:

I recently had occasion to field-test the Snafu

Systems 2300E adaptive gonkulator. The price was

right, and the racing stripe on the case looked

kind of neat, but its performance left something

to be desired.

Yeah, I tried one out too.

ifdef FLAME

Hasn't anyone told those idiots that you can't get

decent bogon suppression with AFJ filters at today's

net volumes?

endif / FLAME /

I guess they figured the price premium for true

frame-based semantic analysis was too high.

Unfortunately, it's also the only workable approach.

I wouldn't recommend purchase of this product unless

you're on a very tight budget.

include

--

== Frank Foonly (Fubarco Systems)

In the above, the #ifdef/#endif pair is a conditional compilation

syntax from C; here, it implies that the text between (which is a

[127]flame) should be evaluated only if you have turned on (or defined

on) the switch FLAME. The #include at the end is C for "include

standard disclaimer here"; the `standard disclaimer' is understood to

read, roughly, "These are my personal opinions and not to be construed

as the official position of my employer."

The top section in the example, with > at the left margin, is an

example of an inclusion convention we'll discuss below.

More recently, following on the huge popularity of the World Wide Web,

pseudo-HTML markup has become popular for similar purposes:

Your father was a hamster and your mother smelt of elderberries!

You'll even see this with an HTML-style modifier:

You seem well-suited for a career in government.

Another recent (late 1990s) construction now common on USENET seems to

be borrowed from Perl. It consists of using a dollar sign before an

uppercased form of a word or acronym to suggest any [128]random member

of the class indicated by the word. Thus: `$PHB' means "any random

member of the class `Pointy-Haired Boss'".

Hackers also mix letters and numbers more freely than in mainstream

usage. In particular, it is good hackish style to write a digit

sequence where you intend the reader to understand the text string

that names that number in English. So, hackers prefer to write `1970s'

rather than nineteen-seventies' or1970's' (the latter looks like a

possessive).

It should also be noted that hackers exhibit much less reluctance to

use multiply-nested parentheses than is normal in English. Part of

this is almost certainly due to influence from LISP (which uses deeply

nested parentheses (like this (see?)) in its syntax a lot), but it has

also been suggested that a more basic hacker trait of enjoying playing

with complexity and pushing systems to their limits is in operation.

Finally, it is worth mentioning that many studies of on-line

communication have shown that electronic links have a de-inhibiting

effect on people. Deprived of the body-language cues through which

emotional state is expressed, people tend to forget everything about

other parties except what is presented over that ASCII link. This has

both good and bad effects. A good one is that it encourages honesty

and tends to break down hierarchical authority relationships; a bad

one is that it may encourage depersonalization and gratuitous

rudeness. Perhaps in response to this, experienced netters often

display a sort of conscious formal politesse in their writing that has

passed out of fashion in other spoken and written media (for example,

the phrase "Well said, sir!" is not uncommon).

Many introverted hackers who are next to inarticulate in person

communicate with considerable fluency over the net, perhaps precisely

because they can forget on an unconscious level that they are dealing

with people and thus don't feel stressed and anxious as they would

face to face.

Though it is considered gauche to publicly criticize posters for poor

spelling or grammar, the network places a premium on literacy and

clarity of expression. It may well be that future historians of

literature will see in it a revival of the great tradition of personal

letters as art.

Node:Email Quotes, Next:[129]Hacker Speech Style, Previous:[130]Hacker

Writing Style, Up:[131]Top

Email Quotes and Inclusion Conventions

One area where conventions for on-line writing are still in some flux

is the marking of included material from earlier messages -- what

would be called `block quotations' in ordinary English. From the usual

typographic convention employed for these (smaller font at an extra

indent), there derived a practice of included text being indented by

one ASCII TAB (0001001) character, which under Unix and many other

environments gives the appearance of an 8-space indent.

Early mail and netnews readers had no facility for including messages

this way, so people had to paste in copy manually. BSD Mail(1) was the

first message agent to support inclusion, and early Usenetters

emulated its style. But the TAB character tended to push included text

too far to the right (especially in multiply nested inclusions),

leading to ugly wraparounds. After a brief period of confusion (during

which an inclusion leader consisting of three or four spaces became

established in EMACS and a few mailers), the use of leading > or >

became standard, perhaps owing to its use in ed(1) to display tabs

(alternatively, it may derive from the > that some early Unix mailers

used to quote lines starting with "From" in text, so they wouldn't

look like the beginnings of new message headers). Inclusions within

inclusions keep their > leaders, so the `nesting level' of a quotation

is visually apparent.

The practice of including text from the parent article when posting a

followup helped solve what had been a major nuisance on Usenet: the

fact that articles do not arrive at different sites in the same order.

Careless posters used to post articles that would begin with, or even

consist entirely of, "No, that's wrong" or "I agree" or the like. It

was hard to see who was responding to what. Consequently, around 1984,

new news-posting software evolved a facility to automatically include

the text of a previous article, marked with "> " or whatever the

poster chose. The poster was expected to delete all but the relevant

lines. The result has been that, now, careless posters post articles

containing the entire text of a preceding article, followed only by

"No, that's wrong" or "I agree".

Many people feel that this cure is worse than the original disease,

and there soon appeared newsreader software designed to let the reader

skip over included text if desired. Today, some posting software

rejects articles containing too high a proportion of lines beginning

with `>' -- but this too has led to undesirable workarounds, such as

the deliberate inclusion of zero-content filler lines which aren't

quoted and thus pull the message below the rejection threshold.

Because the default mailers supplied with Unix and other operating

systems haven't evolved as quickly as human usage, the older

conventions using a leading TAB or three or four spaces are still

alive; however, >-inclusion is now clearly the prevalent form in both

netnews and mail.

Inclusion practice is still evolving, and disputes over the `correct'

inclusion style occasionally lead to [132]holy wars.

Most netters view an inclusion as a promise that comment on it will

immediately follow. The preferred, conversational style looks like

this,

relevant excerpt 1

response to excerpt

relevant excerpt 2

response to excerpt

relevant excerpt 3

response to excerpt

or for short messages like this:

entire message

response to message

Thanks to poor design of some PC-based mail agents, one will

occasionally see the entire quoted message after the response, like

this

response to message

entire message

but this practice is strongly deprecated.

Though > remains the standard inclusion leader, | is occasionally used

for extended quotations where original variations in indentation are

being retained (one mailer even combines these and uses |>). One also

sees different styles of quoting a number of authors in the same

message: one (deprecated because it loses information) uses a leader

of > for everyone, another (the most common) is > > > > , > > > ,

etc. (or >>>> , >>>, etc., depending on line length and nesting depth)

reflecting the original