#fingerprotocol — Public Fediverse posts
Live and recent posts from across the Fediverse tagged #fingerprotocol, aggregated by home.social.
-
RE: https://social.lol/@brennan/116640822237311953
🖥️ Three protocols that have their own ecosystems, their own communities, and their own aesthetics:
finger://
gopher://
gemini://🗓️ Two predate the World Wide Web entirely, but one was created in 2019
🚫 None of them require a GUI
🚫 None of them require JavaScript
🖥️ All three of them run in a terminal
#gemini #gopher #finger #GeminiProtocol #GopherProtocol #FingerProtocol #internet #protocol #terminal #NoGUI #NoJavaScript #NoJS
-
Três protocolos com seus próprios ecossistemas, comunidades e estéticas:
finger://
gopher://
gemini://Dois precedem a World Wide Web, mas um foi criado em 2019
Nenhum deles requer interface gráfica
Nenhum deles requer JavaScript
Todos os três funcionam num terminal
https://brennan.day/gemini-gophers-and-fingers-oh-my-alternative-internets-beyond-https/
#gemini #gopher #finger #GeminiProtocol #GopherProtocol #FingerProtocol #internet #protocol #terminal #NoGUI #NoJavaScript #NoJS
-
Three protocols that have their own ecosystems, their own communities, and their own aesthetics:
finger://
gopher://
gemini://Two predate the World Wide Web entirely, but one was created in 2019
None of them require a GUI
None of them require JavaScript
All three of them run in a terminal
https://brennan.day/gemini-gophers-and-fingers-oh-my-alternative-internets-beyond-https/
#gemini #gopher #finger #GeminiProtocol #GopherProtocol #FingerProtocol #internet #protocol #terminal #NoGUI #NoJavaScript #NoJS
-
Gemini, Gophers, and Fingers. Oh My! Alternative Internets Beyond HTTPS
https://brennan.day/gemini-gophers-and-fingers-oh-my-alternative-internets-beyond-https/
-
The Finger Protocol seems to have had an alternative unofficial TCP-port, other than TCP-port 79.
TCP-port 2003
It was used by GNU cfinger.
TCP-port 2003 would not typically require 'root' privileges — in systems that require 'root' privileges for TCP-ports less-than 1024.
#FingerProtocol #Fingerverse #FingerHole #smallNet #smallWeb #smolNet #smolWeb
-
The Finger Protocol seems to have had an alternative unofficial TCP-port, other than TCP-port 79.
TCP-port 2003
It was used by GNU cfinger.
TCP-port 2003 would not typically require 'root' privileges — in systems that require 'root' privileges for TCP-ports less-than 1024.
#FingerProtocol #Fingerverse #FingerHole #smallNet #smallWeb #smolNet #smolWeb
-
The Finger Protocol seems to have had an alternative unofficial TCP-port, other than TCP-port 79.
TCP-port 2003
It was used by GNU cfinger.
TCP-port 2003 would not typically require 'root' privileges — in systems that require 'root' privileges for TCP-ports less-than 1024.
#FingerProtocol #Fingerverse #FingerHole #smallNet #smallWeb #smolNet #smolWeb
-
The Finger Protocol seems to have had an alternative unofficial TCP-port, other than TCP-port 79.
TCP-port 2003
It was used by GNU cfinger.
TCP-port 2003 would not typically require 'root' privileges — in systems that require 'root' privileges for TCP-ports less-than 1024.
#FingerProtocol #Fingerverse #FingerHole #smallNet #smallWeb #smolNet #smolWeb
-
The Finger Protocol seems to have had an alternative unofficial TCP-port, other than TCP-port 79.
TCP-port 2003
It was used by GNU cfinger.
TCP-port 2003 would not typically require 'root' privileges — in systems that require 'root' privileges for TCP-ports less-than 1024.
#FingerProtocol #Fingerverse #FingerHole #smallNet #smallWeb #smolNet #smolWeb
-
I’m tinkering with #geminiprotocol. I’ve installed #Amfora so I can use sites that require identity certs. The whole trust first on use (tofu) is batshit (says the idiot who always blindly trusts ssh host verification), but it’s kinda neat. #lagrange definitely has the whole ergonomics of identity certs lock down not a whiff of openssl command line magicks. Would’ve preferred to stick with bombadillo (it’s suports #GopherProtocol and #fingerprotocol), but can’t do certs). I would love to see a tui that can renders images using #sixel
-
I’m tinkering with #geminiprotocol. I’ve installed #Amfora so I can use sites that require identity certs. The whole trust first on use (tofu) is batshit (says the idiot who always blindly trusts ssh host verification), but it’s kinda neat. #lagrange definitely has the whole ergonomics of identity certs lock down not a whiff of openssl command line magicks. Would’ve preferred to stick with bombadillo (it’s suports #GopherProtocol and #fingerprotocol), but can’t do certs). I would love to see a tui that can renders images using #sixel
-
I’m tinkering with #geminiprotocol. I’ve installed #Amfora so I can use sites that require identity certs. The whole trust first on use (tofu) is batshit (says the idiot who always blindly trusts ssh host verification), but it’s kinda neat. #lagrange definitely has the whole ergonomics of identity certs lock down not a whiff of openssl command line magicks. Would’ve preferred to stick with bombadillo (it’s suports #GopherProtocol and #fingerprotocol), but can’t do certs). I would love to see a tui that can renders images using #sixel
-
I’m tinkering with #geminiprotocol. I’ve installed #Amfora so I can use sites that require identity certs. The whole trust first on use (tofu) is batshit (says the idiot who always blindly trusts ssh host verification), but it’s kinda neat. #lagrange definitely has the whole ergonomics of identity certs lock down not a whiff of openssl command line magicks. Would’ve preferred to stick with bombadillo (it’s suports #GopherProtocol and #fingerprotocol), but can’t do certs). I would love to see a tui that can renders images using #sixel
-
Simple and excellent #asciiArt from the #FingerProtocol.
-
🚨 Attention Gemini, Gopher, & Finger fans —
Adële ( @adele ) has something to show you:
Adële joins others who argue that — we shouldn't throw out all of the HTML "baby" with the broken-web "bath water" — but that instead —
We should use a restricted subset of HTML — and in particular XHTML.
https://mastodon.tetaneutral.net/@adele/110984755396680624
#smolWeb #smallWeb #smolNet #smallNet #smolInternet #smallInternet #WorldWideWeb #xhtml #gemini #geminiProtocol #gemtext #gopher #finger #fingerProtocol
-
I have been on the Fediverse long enough to remember when the #finger hash-tag was primarily about the #FingerProtocol
Now, it has been taken over by porn.
I think I'll start using #FingerProticol rather than #finger
-
2/
#acctURI has a way of representing user accounts on other hosts — sort of similar to the #fingerProtocol
For example —
acct:reiver%[email protected]
(Notice that the "@" in "[email protected]" gets percent-encoded as "%40".)
#WebFinger uses acct-URIs.
And the #Fediverse used WebFinger.
This is how you could represent a user on one Fediverse instance being used on another Fediverse instance without necessarily having to create a new account.
-
Using a DNS SRV record instead of a DNS TXT record —
To make it so you can change the TCP-port and host of a finger-protocol request —
Seems like a reasonable modification to what I was proposing.
( #finger #fingerHole #fingerProtocol #fingerverse )
-
1/
The finger-protocol could make use of DNS TXT records.
You could use it to change the TCP-port connected to for a finger-request.
You could use it to change the host connected to for a finger-request.
This has a lot of potential!
🧵
( #finger #fingerHole #fingerProtocol #fingerverse )
-
The way you are talking — I suspect you didn't #finger see when it was popular —
(Maybe you were too young. Or you are old enough, but just didn't get exposed to it for some reason.)
So — I can add some information — as not only was I on the Internet when #fingerProtocol was popular — I was a heavy finger user back in the 1990s —
-
One big difference between #finger and #webFinger is —
The output from a #fingerProtocol response is human-legible.
The output from a WebFinger response is — NOT human-legible.
The output from a WebFinger response is — programmer-legible and machine-legible (but not human legible).
-
Some other relevant tags for your thread:
https://fosstodon.org/@orangeacme/109483350342825311
#finger #fingerHole #fingerProtocol #fingerverse
-
#finger has an origin at least going back to 1971.
#IETF #RFC742 was written to document the existing #fingerProtocol , as it was (implicitly) defined by software.
I.e., finger had been around and was evolving AT LEAST 6 years before RFC-742 was published.
-
3/
This quotation from the GNU #finger documentation suggests that —
Image support had already (historically) been added to the #fingerProtocol .
And keep in mind that GNU finger is one of the historic finger-protocol clients — and that it was last updated October 15th, 1992. But that the GNU finger code-base is way older than that.
-
2/
Quotation continued —
(GNU #finger is one of the historic #fingerProtocol clients — last updated October 15th, 1992.)
“[…] The conversion of graphic data from one format to another is done through GNU Finger; no site need know where or how such images are stored on any other site to be able to display those images. You should ask your system administrator to find out whether he has chose to include this functionality on your network.”
https://www.gnu.org/software/finger/manual/html_mono/finger.html
-
1/
A quotation from the GNU finger documentation —
(GNU #finger is one of the historic #fingerProtocol clients — last updated October 15th, 1992.)
“An optional and currently unsupported feature is passing of graphic images. This is built on the new protocol. A user at site A (e.g. MIT) may see the picture of a user at site B (e.g. UCSB), by typing a finger request. […]”
https://www.gnu.org/software/finger/manual/html_mono/finger.html
-
3/
If a concept of files & directories were added to the #fingerProtocol then — it would need to be attached to the user, not the host.
I.e.,:
"joeblow/a/b/c.txt" + "\r\n""joeblow/a/b/[email protected]" + "\r\n"
Or from the command line:
finger joeblow/a/b/[email protected]
finger joeblow/a/b/[email protected]@changelog.ca
-
2/
But (unlike #HTTP) with the #fingerProtocol — you can actually make a request on a user.
Ex:
"joeblow" + "\r\n"And:
"[email protected]" + "\r\n"So, what if you wanted to extend the finger-protocol, and add a concept of files & directories‽ —
-
1/
With #HTTP files & directories are part of the host (and not a user).
Ex:
http.//[email protected]/a/b/c.txt(For the path "/a/b/c.txt")
Users exist in HTTP, but they are more for authentication; rather a target for requests.
(In HTTP you cannot make a request on the user with no path, file, or directory.)
And yes, there a tidle paths. But the HTTP protocol doesn't actually understand them as users — it is just a convention.
-
13/
Now consider this English sentence that can be expressed in #fingerProtocol but not HTTP:
"Charles eats bread."
In finger-protocol this is:
"/EATS bread@charles" + "\r\n"
There is no way to say this in HTTP!
In HTTP you cannot talk about “Charles”
In HTTP you cannot talk about anything except for “I”
That is very important!
It is a limit on the expressiveness of HTTP as a #language
And it is limit that #finger does not have!
-
12/
First consider this English sentence that can be expressed in both the #fingerProtocol and HTTP:
"I eat bread."
In the finger-protocol this would be:
"/EAT bread" + "\r\n"
(In #finger the “I” is implicit.)
And in HTTP this would be:
"EAT /bread" + "\r\n"
(In HTTP the “I” is also implicit.)
OK, great. Now let's look at a rather simple English sentence that finger can express but HTTP cannot —
-
11/
We just covered our first two results.
And we are now going to cover the third result:
“(and this matters because HTTP doesn't have this) — the #fingerProtocol has an explicit Subject, while HTTP only has an implicit Subject that is the HTTP-server itself, and can never be anything else.”
So let's do this —
-
10/
Look at these #fingerProtocol requests:
"/W [email protected]" + "\r\n"
"/W [email protected]@twice.net" + "\r\n"
"/W [email protected]@[email protected]" + "\r\n"
"/W [email protected]@[email protected]@fource.dev" + "\r\n"
Etc
We can just keep on doing this recursion (i.e., nesting) forever!
#finger has infinite recursion (i.e., nesting) ability!
This is a very big deal, from a #linguistics point-of-view. And HTTP cannot do this.So now what —
( #language )
-
9/
Now look at this #fingerProtocol request:
"/W [email protected]@example.com" + "\r\n"
It is similar to the previous one, but has "@example.com" appended to the end..
The Verb is “/W”.
The Object is “[email protected]”.
The Subject is “example.com”.
The Object has recursion (nesting)!
That nesting is a very very big deal. HTTP cannot do this.
In fact, #finger has infinite nesting ability. And I will show you —
-
8/
Here is a (raw) #fingerProtocol request:
"/W [email protected]" + "\r\n"
This is a Verb-Object-Subject (V-O-S).
The Verb is “/W”.
The Object is “charles”.
The Subject is “reiver.link”.
(Just a caveat — some who know the #finger protocol well are probably going to point out at least a couple technicalities. To them I say — yes, I know, but I am trying to keep this simple to communicate my point.)
Now watch this —
-
7/
But before we look at that (raw) #fingerProtocol request, let's just note that —
We just covered the first result:
“the finger-protocol has a — Verb-Object-Subject (V-O-S) grammar order”
And we are now going to cover the second result:
“the finger-protocol has a (limited) type of #language recursion (i.e., nesting). (HTTP cannot do this)”
So let's look at a (raw) #finger protocol request to see this —
( #linguistics )
-
6/
English's grammer has a Subject-Verb-Object (S-V-O) grammar
“Charles ate strawberries.”
But if English was Verb-Object-Subject (V-O-S) like the #fingerProtocol that sentence would be:
“Ate strawberries Charles.”
That probably sounds weird to you
And although some human languages have V-O-S natural grammar ordering — it is rare
But the #fingerProtocol is a V-O-S language — look at this (raw) #finger protocol request to see this —
-
2/
Two specifications were created for the #fingerProtocol:
• #IETF #RFC742 (published in 1977)
• #IETF #RFC1288 (published in 1991)Neither of them were about creating the finger-protocol.
The finger-protocol existed and was evolving AT LEAST 6 YEARS BEFORE the IETF RFC-742 specification was written!
.
.( #finger #fingerHole #fingerverse )
-
The #fingerProtocol — except without any 7-bit ASCII restrictions — that were (from a specification(s) point-of-view) added in #IETF #RFC1288 , but didn't exist in #IETF #RFC742 .
-
5/
“Verb-Object-Subject” (V-O-S) grammar order —
Rather than Verb-Object-Subject (V-O-S) (like the #fingerProtocol ) — English has a Subject-Verb-Object (S-V-O) grammer.
For example, with the English sentence:
“Charles ate strawberries.”
The Subject is “Charles”.
The Verb is “ate”.
The Object is “strawberries”.
OK, so what about V-O-S (like the #fingerProtocol ) rather than S-O-V like English —
-
4/
First — the finger-protocol has a — Verb-Object-Subject (V-O-S) grammar order.
Second — the finger-protocol has a (limited) type of #language recursion (i.e., nesting). (HTTP cannot do this)
And Third (and this matters because HTTP doesn't have this) — the #fingerProtocol has an explicit Subject, while HTTP only has an implicit Subject that is the HTTP-server itself, and can never be anything else.
But what does that actually mean —
( #finger #fingerHole #fingerverse )
( #linguistics )
-
3/
What would happen if you analyzed the #fingerProtocol like a human #language ‽ —
(And note — I'll explain, with examples, what each of the following means, and why they matter.)
( #finger #fingerHole #fingerverse )
( #linguistics )
-
2/
Here is what I am claiming —
THE FINGER-PROTOCOL IS (IN A WAY) MORE POWERFUL THAN HTTP!
I will be more specific with my claim —
A finger-protocol request is MORE EXPRESSIVE (as a language) than an HTTP protocol request.
But you need to anaylze the #fingerProtocol like you would analyze a human-lanauge to see it.
I.e., use the same tools we use to analyze human-languages to analyze the finger-protocol.
So let's do that —
-
1/
The #FingerProtocol —
The #finger protocol is an old Internet protocol that was popular in the 1970s to mid-2000s
Today the finger-protocol is going through a revival. With a small but growing number of us on the #fingerverse
What if I told you that —
THE FINGER-PROTOCOL IS (IN A WAY) MORE POWERFUL THAN HTTP!
HTTP is the most popular application-layer protocol today — so that is a very strong statement
But it is true, and I'll explain —
🧵
( #fingerHole )