"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.
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.
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.
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^\
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?
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!
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.
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.
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.
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.
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:
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.
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!
>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 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.
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.
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.
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.
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
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.
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.
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)
"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."
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.
