The Hacker's Dictionary | Hacker News Reader

The Hacker's Dictionary

hackersdictionary.com

174 pointsderealized55 comments

The original version of this dictionary: https://www.dourish.com/goodies/jargon.html

  "This file, jargon.txt, was maintained on MIT-AI for many years, before being published by Guy Steele and others as the Hacker's Dictionary. Many years after the original book went out of print, Eric Raymond picked it up, updated it and republished it as the New Hacker's Dictionary. Unfortunately, in the process, he essentially destroyed what held it together, in various ways: first, by changing its emphasis from Lisp-based to UNIX-based (blithely ignoring the distinctly anti-UNIX aspects of the LISP culture celebrated in the original); second, by watering down what was otherwise the fairly undiluted record of a single cultural group through this kind of mixing; and third, by adding in all sorts of terms which are "jargon" only in the sense that they're technical. This page, however, is pretty much the original, snarfed from MIT-AI around 1988."

  The -P convention: turning a word into a question by appending the syllable "P"; from the LISP convention of appending the letter "P" to denote a predicate (a Boolean-values function). The question should expect a yes/no answer, though it needn't. (See T and NIL.) At dinnertime: "Foodp?"

I'm old enough to have been active in this era, and to have sent messages on teletypes using the "P" suffix. But for us, it had nothing to do with LISP. Our machines weren't that cool.

In fact, they were so lame that many of the printing terminals lacked a question mark character. The P was used as a substitute for a ? because it was the closest visual substitution. And naturally, most of our messages were one or two words for economy. "FOODP" would print correctly on machines that couldn't print "FOOD?" Not everyone had a fancy glass terminal, so you had to assume the worst case scenario, and use "P" in case someone was on paper.

On a related note, to make it easier to count spaces in indented code, we would use a "b" character with a slash through it. So the teletype was print b, then back up a space by sending ^H, and then put a / through it.

It looked terrible, but got the job done. It used up a lot of ink, but the bosses were watching paper use, not ink.

Reminds me of "ye", pronounced and meaning "the", in English, because medieval printers imported from Germany didn't have that letter "Þ' and 'Y' was the closest substitute.

It's worth noting that "ye" also existed as the second person plural pronoun while "þe" simultaneously existed as a second person singular. These are now merged in most English dialects. Getting the unrelated definite article "þe" mixed up in this and substituting a "y" was more than just a matter of misguided font substitution because some forms of the handwritten thorn look very similar to a "y". Two words pronounced "the", one of which is easily conflated with another spelled and pronounced "ye" leads to the inevitable result.

"Splitp soup?" "T"

We used to even use this in speech sometimes, especially when funny (say, agreeing to share Hot and Sour soup at Mary's, for which the conversation above would work well).

Note the amusing pointlessness of p in this case since when speaking you'd pronounce a question anyway.

Wirth silver(?) Pascal book used 'b' overstruck with a backslash when spaces needed to be shown explicitly.

I wonder if there's a unicode for that.

There is U+2422 Blank Symbol (␢).

This is the problem with the Hacker's Dictionary. Some of the stuff in it turned out to be just plain not what the people involved were actually doing.

Here are two versions of the original jargon file from AI:HUMOR; free of ESR's pollution:

AI:HUMOR;MITSAI JARGON (25.3 KB):

https://github.com/PDP-10/its/blob/master/doc/humor/mitsai.j...

AI:HUMOR;JARGON > (85.3 KB):

https://github.com/PDP-10/its/blob/master/doc/humor/jargon.6...

Also NASA jargon:

https://github.com/PDP-10/its/blob/master/doc/humor/nasa.jar...

Alice's PDP-10 is also a classic:

https://github.com/PDP-10/its/blob/master/doc/humor/alices.p...

    There was all kinds of mean nasty ugly people there on the bench...
    Chaosnet designers... Lisp hackers... TECO hackers.  TECO hackers
    right there on the bench with me!  And the meanest one of them, the
    hairiest TECO hacker of them all was coming over to me.  And he was
    mean and nasty and horrible and undocumented and all kinds of stuff.
    And he sat down next to me and said:

    [1:i\*^Yu14<q1&377.f"nir'q1/400.u1>^[[8
    .-z(1702117120m81869946983m8w660873337m8w1466458484m8
    )+z,.f^@fx\*[0:ft^]0^[w^\

    And I said "I didn't get nothing, I had to rebuild the bittable in
    queue six" and he said:

    [1:i\*^Yu16<q1&77.+32iq1f"l#-1/100.#-1&7777777777.'"#/100.'u1r>6c^[[6
    .(675041640067.m6w416300715765.m6w004445675045.m6
    455445440046.m6w576200535144.m6w370000000000.m6),.fx\*[0:ft^]0^[w^\

> Alice's PDP-10 is also a classic

Reminds me, some fortunes on LAMBDA.TXT[1] seem to hint at the existence of an "Alice's LispM", seemingly a parody on the PDP-10 version, but a quick search for it doesn't seem to come up with much (I haven't looked very hard). Does anybody know anything about this?

[1]: http://www.gotlisp.com/lambda/lambda.txt

Oh yes, I love that one -- it inspired me to become a Window System Hacker, and write the ugly and nasty and horrible and kludgy "Bouncy pushy window mixin", which made the windows bounce all around the screen!

https://donhopkins.com/home/archive/lisp/bounce-and-push.lis...

ALICE'S LISP MACHINE: Chris Stacy, Alan Wecsler, and Noel Chiappa

https://web.archive.org/web/20110403000600/http://allegedly....

              There was all kinds of  mean, nasty, ugly-lookin' people  on
    the bench there ...  there was Microcoders,  DPL hackers, File  System
    hackers, and  Window System  Hackers!!  Window System  hacker  sittin'
    right there  on  the bench  next  to  me! And  the  meanest,  ugliest,
    nastiest one... the kludgiest Window System hacker of them all...  was
    comin' over to me, and he was mean and ugly and nasty and horrible and
    all kinds of things, and  he sat down next to  me. He said, "Kid,  you
    get a new copy of the sources?"  I said, "I didn't get nothin'. I  had
    to rebuild the world load."

              He said,  "What were  you arrested  for, kid?"  and I  said,
    "Littering..." And they  all moved away  from me on  the bench  there,
    with the hairy  eyeball and all  kinds of mean,  nasty things, 'til  I
    said, "And making  gratuitous modifications to  LMIO; sources..."  And
    they all came  back, shook my  hand, and we  had a great  time on  the
    bench talkin' about microcoding, DPL designing, file-system hacking,
    ... and all kinds of groovy things that we was talkin' about on the
    bench, and everything was fine.

              We was drinking Coke smoking all kinds of things, until  the
    RA came over, had some paper in his hand, held it up and said:

         "KIDS-THIS-EXAM-S-GOT-FOURTY
         SEVEN-WORDS-THIRTY-SEVEN-MULTIPLE-CHOICE-QUESTIONS
         FIFTY-EIGHT-WORDS-WE-WANT-TO-KNOW-THE-DETAILS
         OF-THE-HACK-THE-TIME-OF-THE-HACK-AND-ANY
         OTHER-KIND-OF-THING-YOU-GOT-TO-SAY
         PERTAINING-TO-AND-ABOUT-THE-HACK-ANY-OTHER
         KIND-OF-THING-YOU-GOT-TO-SAY-WE-WANT-TO-KNOW
         THE-ARRESTED-PROCESS'-NAME-AND-ANY
         OTHER-KIND-OF-THING..."

    And he talked for forty-five minutes and nobody understood a word that
    he said. But we had  fun rolling the mice  around and clickin' on  the
    buttons.

Reminds me of Poppyfields filk archive. http://www.poppyfields.net/filks/bandindex.html

I'm a fan of the two renditions of Piano Man and the Berkelian Rhapsody - http://www.poppyfields.net/filks/00034.html

Are these meant to just be incomprehensible, or is there some translation possible?

Haven't heard the song for awhile.

Here's what GPT-4 had to say about the TECO code in the song:

Explain every detail of this TECO code that you can, and speculate on what it does.

    [1:i\*^Yu14<q1&377.f"nir'q1/400.u1>^[[8
    .-z(1702117120m81869946983m8w660873337m8w1466458484m8
    )+z,.f^@fx\*[0:ft^]0^[w^\

    [1:i\*^Yu16<q1&77.+32iq1f"l#-1/100.#-1&7777777777.'"#/100.'u1r>6c^[[6
    .(675041640067.m6w416300715765.m6w004445675045.m6
    455445440046.m6w576200535144.m6w370000000000.m6),.fx\*[0:ft^]0^[w^\

ChatGPT:

TECO (Text Editor and COrrector) is a primitive text editor from the early days of computer programming. TECO code is notoriously difficult to read, as it's a sort of "write-only" language with many commands being single punctuation characters and having different meanings depending on context. Its language is an esoteric one, with little resemblance to most modern programming languages.

Let's try to break down the given TECO code line by line:

[1:i\*^Yu14<q1&377.f"nir'q1/400.u1>^[[8

Here, [1 is saving the current buffer's contents to Q-register 1 (a kind of temporary storage). i\*^Y is inserting the character with ASCII code 25 (^Y stands for decimal 25, \* is for output). u14 is storing the value 14 in Q-register 4.

<q1&377.f"nir'q1/400.u1> is a conditional loop that executes while the value in Q-register 1 (the contents of the buffer) ANDed with 377 (octal, or 255 decimal) is not 0. Inside the loop, it's reading one character from the buffer (.f), if it's not end of file ("n), it's returning the pointer back to the character just read (ir'), otherwise it's storing the value of Q-register 1 divided by 400 in Q-register 1 (q1/400.u1).

>^[[8 at the end is somewhat unclear without context. ^[[ is often a prefix for terminal control sequences (also called escape sequences), but 8 doesn't correspond to a typical terminal control sequence. This might be a TECO-specific sequence.

.-z(1702117120m81869946983m8w660873337m8w1466458484m8)+z,.f^@fx\*[0:ft^]0^[w^\

Here, .-z( to )+z, is calculating a range in the buffer. .-z is the difference between the current pointer position and the end of the buffer, and z is the length of the buffer. 1702117120m81869946983m8w660873337m8w1466458484m8 are arithmetic operations involving multiply (m) and bitwise OR (w), but without the context it's hard to say exactly what this line is doing.

.f^@ reads one character from the buffer and replaces it with ASCII null (^@ stands for decimal 0, and f is for fetching). fx exchanges the Q-register and the buffer, meaning that the contents of the buffer are now in the Q-register and the previous Q-register contents are now in the buffer. \*[0:ft^]0^[w^\ are performing a series of operations involving Q-register 0, fetching and type commands but, without context, it's hard to say exactly what this is doing.

[1:i\*^Yu16<q1&77.+32iq1f"l#-1/100.#-1&7777777777.'"#/100.'u1r>6c^[[6

This is similar to the first line but with a few differences. u16 is storing the value 16 in Q-register 6. <q1&77.+32i is a conditional loop that executes while the value in Q-register 1 ANDed with 77 (octal, or 63 decimal) is not 0. Inside the loop, it's adding 32 to the character in the buffer, essentially converting uppercase ASCII characters to lowercase.

q1f"l#-1/100.#-1&7777777777.'"#/100.'u1r is a series of commands inside the loop. If the fetched character is less than -1, it's performing a series of operations involving division and bitwise AND, and storing the result in Q-register 1. The exact purpose of these operations isn't clear without context.

>6c^[[6 at the end is also unclear. It could be storing the character with ASCII code 6 in Q-register 6, but without context, it's hard to say for sure.

.(675041640067.m6w416300715765.m6w004445675045.m6455444046.m6w576200535144.m6w370000000000.m6),.fx\*[0:ft^]0^[w^\\

Similar to the second line, this line is performing a series of arithmetic operations with the contents of Q-register 6. After that, it's again exchanging the buffer with a Q-register (presumably the Q-register with the result of the arithmetic operations).

In terms of what this code does, it's difficult to determine without context. It's performing a series of operations on the contents of the buffer, and these operations involve arithmetic, bitwise, and possibly character manipulation. But the exact purpose of these operations isn't clear from the code alone. For example, we can see that the code is interacting with the contents of the buffer and Q-registers, but it's not clear what these contents are or what the desired outcome is.

TECO's complex syntax and the lack of modern programming conventions makes it very difficult to determine what a specific piece of TECO code does without additional context or comments.

TECO really is that incomprehensible. I don't understand it myself, but here's another example that I remember seeing in Marvin Minsky's home directory on MIT-AI, which I'm glad I asked about years ago on HN, because Harold Ancel just happened to save a copy of it:

https://news.ycombinator.com/item?id=10161002

DonHopkins on Sept 2, 2015 | parent | context | favorite | on: The most obsolete infrastructure money could buy –...

I remember running across a Turing machine emulator implemented in TECO in Minsky's home directory that I'd REALLY love to get ahold of.

hga on Sept 2, 2015 [–]

Ask and yea shall receive:

  MSG: APL    1     
  DISTRIB:  *BBOARD
  EXPIRES: 03/17/81 23:08:54
  MINSKY@MIT-MC 03/11/81 23:08:54 Re: too-short programs
  APL is compact, I suppose.  So is TECO.  When I wrote the following
  Universal Turing Machine, which works, I actually understood it.

[ I've interpolated the non-printing characters as displayed by (Gnu) EMACS, escape is ^], ^^ is one character, as is \356: ]

  i1Aul qq+^^0:iqm^[29iiq\356y0L1 00L1 11L2 A1L1
  y0L1 0yR2 1AR2 AyR6 yyL3 00L0 1AL3 A1L4 yyL4 0yR5 11L7 A1L4
  yyR5 0yL3 1AR5 A1R5 yyR6 0AL3 1AR6 A1R6 y0R7 0yR6 11R7 A0R2
  ^[j<sR^[;-d-2ciql-^^^[ci"ed^^^[cii^[ciuq'^[>
  j<sL^[;-d-2ciql-^^^[ci"ed^^^[cii-2c^[ciuq'^[>jxblx1lx2lx3lx4lx5lx6lx7hk
  iyyAyyAyy^[32<i0^[>ji110101110000010011011^[ 1uq<htmbqq=>

  I do not advise attempting to understand this code, which is
  almost as bad as that for the Universal Turing machine.

ADDED: or http://ancell-ent.com/share/minsky-TECO-turing-machine.txt

Please ack receipt of this and/or send me email (in my HN info); for others, note this is ITS TECO, which I was told was by far the most powerful version of it (fortunately, by the time I showed up learning it was no longer really necessary).

DonHopkins on Sept 3, 2015 | parent [–]

OOP ACK! It was a shot in the dark, but I am SO GLAD I asked!!! Thank you Harold!

It looks just like I remember. ;)

https://news.ycombinator.com/item?id=33356932

>I deeply appreciate and am greatly privileged to benefit from the MIT AI Lab's "Tourist Policy" and general openness, generosity, and encouragement of education, which allowed me to use the lab's PDP-10s over the ARPANET as a high school student. [...]

I asked GPT-4 to take a whack at it:

ChatGPT:

I see that you've posted a TECO program, a Universal Turing Machine emulator, from Marvin Minsky's directory, shared via Hacker News.

TECO (Text Editor and COrrector) is a text editor that was very popular and widely used in the 1960s and 1970s, especially on DEC computers. It's an extremely powerful and flexible editor, but also notoriously difficult to understand and use. In fact, it's often used as an example of a "write-only" language, because its programs can be extremely hard to read and understand, even for people who are familiar with TECO.

This TECO program is indeed cryptic. Its syntax involves lots of non-alphanumeric symbols and control characters, which are typical of TECO. Reading and understanding this code would require a deep understanding of TECO's syntax and commands.

TECO code is composed of commands that are read and executed one after the other. Each command can have an optional numeric argument, and can also have another command as an argument. This allows for complex, powerful operations, but also makes the code difficult to read.

If you're interested in understanding how this TECO program works, I'd recommend starting by learning more about TECO's syntax and commands. Be aware, though, that this is not a trivial task; even experienced programmers often find TECO challenging to understand.

As the Hacker News comments note, this program is written in ITS TECO, a version of TECO used on the Incompatible Timesharing System (ITS) developed at MIT. This version of TECO has some differences from other versions, so you would need to find documentation specifically for ITS TECO in order to fully understand the program.

User:

How much of it can you understand? Explain what you can.

ChatGPT:

I must point out that while I'm able to provide explanations on many topics, TECO is one of the most cryptic and complex programming languages ever created. TECO programs are notoriously difficult to read, and even people who are experienced with TECO often struggle to understand non-trivial programs written in it. Therefore, please take the following explanation with a grain of salt as it may be simplified or not entirely accurate due to the complexity of TECO.

Here's a breakdown of a few commands, as far as I can understand:

i1Aul qq+^^0:iqm^[29iiq\356y0L1 00L1 11L2 A1L1: This line initializes several variables. The i command inserts text, A assigns the value of the last text string searched for to a variable (qq in this case), ul is probably used to move the cursor to the left. There are other commands to move around the buffer and do arithmetic operations. The line ends with assigning a string to variable qy and the insertion of several pairs of numbers and letters.

y0L1 0yR2 1AR2 AyR6 yyL3 00L0 1AL3 A1L4 yyL4 0yR5 11L7 A1L4...: This line continues with similar commands, modifying the state of the buffer and several variables.

^[j<sR^[;-d-2ciql-^^^[ci"ed^^^[cii^[ciuq'^[>: This part seems to be a conditional jump loop, a fundamental structure in TECO. The j command moves to the beginning of the buffer. The < and > delimit a loop, and s searches for a string. The ; command conditionally terminates the loop.

jxblx1lx2lx3lx4lx5lx6lx7hk: This line seems to be doing various operations on buffers, possibly saving or loading state. x executes a macro, l loads a file into a buffer, h moves to the top of the current buffer, and k kills the current buffer.

iyyAyyAyy^[32<i0^[>ji110101110000010011011^[ 1uq<htmbqq=>: This line again modifies buffers and variables and includes another loop structure. The long string of numbers seems to be data for the Turing machine, and the uq command updates a Q-register.

Please note that this is a high-level interpretation and might contain inaccuracies. Fully understanding this program would require a deep understanding of TECO and possibly access to its original documentation. As such, this program is a great example of the complexity and cryptic nature of TECO.

Here's the ITS TECO manual and primer that ChatGPT probably read:

LIST OF TECO COMMANDS, TECO VERSION 1132. Last updated 5 August 1981:

https://github.com/PDP-10/its/blob/master/doc/_teco_/tecord....

TECO PRIMER: AN ANNOTATED OUTLINE OF TECO COMMANDS:

https://github.com/PDP-10/its/blob/master/doc/_teco_/teco.pr...

TECO Info Manual:

https://github.com/PDP-10/its/blob/master/doc/info/tecman.20

TECO Programming in Emacs Info Manual:

https://github.com/PDP-10/its/blob/master/doc/info/conv.85

EMACS LORE:

https://github.com/PDP-10/its/blob/master/doc/eak/emacs.lore

Lots of TECO code in the ITS Emacs sources, like KMP's Doctor:

https://github.com/PDP-10/its/tree/master/src/emacs1

https://github.com/PDP-10/its/blob/master/src/emacs1/doctor....

Prompt:

Implement Fizz Buzz in TECO.

ChatGPT:

Fizz Buzz is a simple programming task often used in coding interviews. The task is to print the numbers from 1 to 100, but for multiples of 3 print "Fizz" instead of the number, and for multiples of 5 print "Buzz". For numbers which are multiples of both 3 and 5 print "FizzBuzz".

Implementing Fizz Buzz in TECO would be quite a challenge due to the language's design and constraints. TECO is not really meant for such tasks, as it is a text editor and correction programming language. However, I'll provide a rough example of how you might implement FizzBuzz in TECO, although it's somewhat complex and involves a few workarounds:

    0uz                    ! Store 0 in register Z (counter) !
    <qz+1uz                ! Increment Z !
    qz:<                   ! Inner loop, executes while Z is less than or equal to 100 !
    qz\3%<iFizz$>          ! If Z is divisible by 3, insert "Fizz" !
    qz\5%<iBuzz$>          ! If Z is divisible by 5, insert "Buzz" !
    qz\3%qz\5%"nqz\*A$'    ! If Z is not divisible by 3 or 5, insert Z (as a character) !
    ia                     ! Insert a newline !
    >'                     ! End of inner loop !
    >                      ! End of outer loop !

This is a very rough, and not perfect, implementation. It doesn't properly handle numbers over 9, because TECO doesn't really support integer arithmetic in the way modern languages do. When we print a number, we're actually printing a character with the corresponding ASCII code, so numbers over 9 would turn into non-digit characters. Implementing FizzBuzz properly would likely involve manually converting numbers to digit strings, which would make the program quite a bit more complex.

In practice, you would rarely if ever use TECO for this sort of task. TECO was designed for editing text, not for general-purpose programming, and it lacks many of the features that make modern languages suitable for tasks like FizzBuzz. But, this does demonstrate some of the ways you can use TECO's unique features to solve problems.

> in the process, he essentially destroyed what held it together

Not only that, but the man's disgusting political and social views tarnished everything he touched.

He definitely grabbed headlines. Once I looked I found nothing there. I wondered about his community because he always seemed isolated and or armed.

Seems probable seeing the kind of attacks of his political views in this thread. I'd too keep a firearm for voicing social justice opinions in a country fubar:ed by grief.

Many responsible gun owners never publicly state their ownership. Talking about guns in belligerent fashion is one form of gun ownership.

I haven’t seen any threats of violence just the acustaion of being a knucklehead that owns firearms.

Wow, thanks for the clarification. I try be scholarly in my cultural understanding of computing development and I hadnt heard this perspective.

This is such an interesting group dynamic where a work product of one group gets twisted by another group and claims ownership.

The embrace and extend method.

I didn't realize there was another version of this. I will look at both and get my own personal comparison

Perhaps the thing to do is put it in a git repository, so people can retrieve the version they want.

Related threads below. Have I missed one? Surprisingly little over the years.

Newer cohorts don't always know the classics/perennials*, so the occasional thread is a good thing - but should we change the link to one of these?

https://www.dourish.com/goodies/jargon.html

http://jargon-file.org/archive/jargon-4.4.7.dos.txt

http://catb.org/jargon/html/index.html

* https://hn.algolia.com/?dateRange=all&page=0&prefix=false&qu...

The Jargon File - https://news.ycombinator.com/item?id=33259797 - Oct 2022 (1 comment)

The Jargon File - https://news.ycombinator.com/item?id=31574352 - May 2022 (1 comment)

The Jargon File - https://news.ycombinator.com/item?id=24658797 - Oct 2020 (4 comments)

The Jargon File - https://news.ycombinator.com/item?id=23331642 - May 2020 (2 comments)

The Jargon File - https://news.ycombinator.com/item?id=16424833 - Feb 2018 (1 comment)

Jargon File moved to github - https://news.ycombinator.com/item?id=6887903 - Dec 2013 (10 comments)

Jargon File moved to github - https://news.ycombinator.com/item?id=6884756 - Dec 2013 (3 comments)

The Original Hacker's Dictionary (1988) - https://news.ycombinator.com/item?id=5269170 - Feb 2013 (24 comments)

The Jargon File - https://news.ycombinator.com/item?id=1469112 - June 2010 (4 comments)

The Jargon File - https://news.ycombinator.com/item?id=1295076 - April 2010 (3 comments)

On ESR's continual changing of the Jargon File.. - https://news.ycombinator.com/item?id=239168 - July 2008 (1 comment)

The Jargon File - https://news.ycombinator.com/item?id=148423 - March 2008 (1 comment)

Superb site Moderating and Content Curation.

So fun. Some favorites:

Big Room: http://www.hackersdictionary.com/html/entry/Big-Room.html

Bogo-Sort: http://www.hackersdictionary.com/html/entry/bogo-sort.html

Bug-For-Bug Compatible: http://www.hackersdictionary.com/html/entry/bug-for-bug-comp...

Fence-post Error: http://www.hackersdictionary.com/html/entry/fencepost-error....

Magic Smoke: http://www.hackersdictionary.com/html/entry/magic-smoke.html

One-Banana Problem http://www.hackersdictionary.com/html/entry/one-banana-probl...

Tail Recursion: http://www.hackersdictionary.com/html/entry/tail-recursion.h...

Bogosort is going to be the best algorithm once quantum computing is fully available. It will be the only algorithm that will be used for the rest of humanity's existence since is the only one that can be 100% parallelized, so it will have the last laugh.

tail recursion reminds me of the "how to keep an ______ occupied" rock. being from texas, the blank is usually "aggie".

It would be great if someone with appropriate "back in the day" credentials would take over membership of this document and powerwash the gratuitous Eric Raymond edits and insertions off of it.

Better solution: Just make your own for whatever project you're working with. AIWORD was originally a product of Stanford's AI community. Let it rest and make a dictionary that reflects the usage of your own group.

..........and mercilessly mock Eric Raymond for his pretensions. :D

1) these people are not young and getting older every day, so priorities might change too

2) after a while if person A takes this on, there will be a request to powerwash the gratuitous A’s edits and insertions off of it

3) if the purpose is to have it in pristine state and do no edits, it’s not like old versions have disappeared, just mirror them away

So in order for the document to evolve, we need a system to determine consensus. Everyone who cares runs a program on their computer that joins the network and registers their intent. With each proposed change, a query goes out to the network, and it's up to everyone on the network to say yea or nay to the proposal. With enough "yea"s, the document is updated.

...this is starting to sound like a blockchain, isn't it.

Not enough people born after 1980 have read either version of the dictionary, which is a shame in having a unified vocabulary across more of the internet. A companion volume with new terms, events, and foci would help.

I am glad Monty Python, at least, remains popular across old hackers and new.

Without having a real opinion on Esr’s eedits, a snapshot of earlyish hacker culture (whether or not conflating LISP and UNIX) is historically interesting. With tech today so mainstream and with so many subcultures and branches one could of course a glossary but it wouldn’t be the same.

even when it is written down, things don't stick across the internet. we're still having gif vs jif pronunciation debates

Well concerning GIF it’s obviously soft G because it stands for Giraffics Interchange Format. Does it not?

It's a soft G, like the peanut butter brand, because that's what the inventor says.

His algo, his rules.

There's a terrible/great genre thriller by Jeffery Deaver called 'The Blue Nowhere'. Whoever ghost wrote it seems to have set themselves the goal of using every word from the jargon file. Unintentionally hilarious.

At my book club (mostly us old farts from SU-AI and MIT-AI) someone mentioned that Harry Harrison had read the jargon file when spending time at the MIT AI lab and made a point of using them in conversation. Unfortunately by learning them that way he didn't get any of the context (and wasn't a hacker anyway) so he never used them correctly.

(The person who related this anecdote wasn't mocking him, it was just an example while talking about something else, using amusing examples that all of us would know. I don't remember Harrison, but I think I remember Robert Sheckley doing this, not that it matters).

If the spirit of the original Jargon file was to be a living document, alas, it failed to keep with the times.

Hackers at large have moved away from Lisp despite Paul Graham and other evangelists, Linux ate Unix, and there have been several bright subcultures which have no meaningful presence in either edition of the Jargon file. Considering self-professed tribalism of the original authors, it’s hardly surprising.

Hackers also have moved away from academia at large, and 9-5 jobs at tech behemoths are more natural habitats for them, which also shaped the lingo. I mean, there’s a whole layer of slang usually pertinent to outsourcing agencies and to cubicle farms.

It would be interesting to have a compilation of jargon as it evolved through the 1990s and 2000s too.

Originally it was a document for MIT and Stanford University's AI labs, it was not supposed to keep up with the "hackers at large". Eric Raymond, who was not one of the original authors of the jargon file, decided to appropriate it as his definition of the whole existing hackerdom, which is rather controversial. People from later communities could have written their own jargon files.

> People from later communities could have written their own jargon files.

There is the IBM Jargon File compiled by Mike Cowlishaw at the IBM UK Laboratories in Hursley. The most recent edition is from 1990. As you might expect, it has more about company traditions and workplace politics than the Guy Steele jargon file or its successors.

https://comlay.net/ibmjarg.pdf

I haven't seen it before, and it's quite interesting and fun. I chuckled at the "lion food" entry. Thank you for sharing it!

I suspect that he has not been involved in this project for a long time, but early on, Eric had the help and support of Guy Steele.

http://catb.org/jargon/html/online-preface.html

Hacker Writing Style > Quotations and punctuation. That part hits hard because it really shows up in my writing (I didn’t know that it was incorrect English grammar until my teacher told me)

I remember discovering this in the early 90s and gleefully reading out the COBOL definition to my COBOL lecturer.

Just search Jargon File on here for the many similar/related posts.

Created a new account just to submit this? Welcome.

Interesting stuff. Perhaps add an alias hashbang for shebang.

No true hacker will say hashbang.

"As for the name: probably something descriptive like "hash-bang" though this has a specifically British flavor, but in any event I don't recall particularly using a pet name for the construction."

‐ Dennis Ritchie

https://en.m.wikipedia.org/wiki/Shebang_(Unix)

In the UK ! was (maybe still is) pronounced as "pling". I know I've definitely said hashpling.

Actually surprised the American's weren't calling # "pound" then, but maybe that evilness showed up later. But whatever, it's never been a pound symbol in any country that uses pounds!

Another interesting fact about # is that in the late 90s or early 2000s, British Telecom tried to gaslight the British public into thinking that # was pronounced "octothorpe". Fortunately, everybody realised this was idiocy, and we all carried on calling it "hash" like we always had.

here here. "hashbang that script will ya?" is something no self respecting hacker would ever say.

Reply on news.ycombinator.com