Why we have stopped making cool protocols like this? It seems Internet had really cool protocols back in the day and we had so many possibilities. Now it seems we are stuck with HTTP.
Not saying HTTP is bad. It just seems like we have given up on possibilities. I remember, almost a decade ago, Nokia had a mobile web server for Symbian devices which basically hosted HTTP server on the phone[0]. You could message the owner of phone directly through a URL. The request would be handled by server on phone!
No one makes anything like that anymore. Everyone is just building on top of APIs and services provided by MANGA who would obviously not put any effort in such projects.
Finger is a silly protocol. It doesn't exist anymore because it is worse in every possible way than HTTP (or, at least, the tiny subset of compatible HTTP that replaces it).
I remember when I was earlier in my career and more specialized on implementing weirdo protocols hearing that HTTP was going to replace all the existing protocols. I was appalled; it seemed absurd, like suggesting Word .DOC was going to replace all text files.
But for the most part, the people saying that were right, and we are better off for it. The thing about a lot of those purpose-built protocols, even the "important" ones like DNS and most especially infrastructure stuff like SNMP, is that they are pretty dumb, the product of their time and thus, by construction, deprived of several decades of systems learning.
Something interesting about them though is that they were mostly simple, plaintext, protocols and you could learn a lot by popping open a telnet connection and playing around. At least I learned a lot that way when I was a kid. I figured out how to make HTTP GETs, use IRC, etc playing around with telnet.
You didn't make an argument for why it's a silly protocol. You didn't make an argument for why it is worse in every possible way than HTTP. You didn't make an argument for why we're better off having replaced everything with HTTP. You didn't make any arguments about they they are "pretty dumb."
Your entire post amounts to "I like HTTP" and "old stuff bad."
I agree the novelty of implementing these protocols wears off as soon as one looks into the security nightmare a poorly implemented protocol can cause.
But I still would like to see efforts happening in applications like Nokia's mobile web server. Another such effort from a decade ago was Opera Unite https://linkdekho.in/1e2vAy
It's the Windows vs Linux points of view. HTTP is a kitchen-sink, and extremely complex. I know, you're saying 'Wait, HTTP is simple.' Understanding basic HTTP use of GET and POST is simple, the implementation details of the spec needed to be HTTP compliant are complex. Think of features like proper MIME handling, compression handling, redirects, all the authentication options to handle, proxy support, caching, content-negotiation, headers to selectively GET, web sockets, etc. The spec for HTTP/1.1 weighs in at 176 pages.
Finger on the other hand does one thing, and does it well.
I would argue that we need more smaller protocols and less kitchen sink protocols.
The drivers for kitchen sink protocols are not necessarily technical, they could be financial. As a bigger protocol gets more name recognition it becomes a less risky pitch in the eyes of management to adapt the protocol instead of going with a smaller one, or inventing your own. This adaptation sometimes leads to the bigger protocol getting extensions and growing even larger. The other reason HTTP is often used is security policies - the port is open, so no additional ports are needed, and security is already set up to scan HTTP traffic.
it is a protocol for a specific purpose, and because it has that specific purpose, it was used for that, and desired for that. http can do it, but without the constraints, of course nobody will use it for reinventing finger.
I was messing around with servers that had a finger server running a few days ago. I think the university of Wisconsin has a finger server running that exposes the name/address for all their faculty and students
On the ARPANET (the original one running the NCP protocol), not only didn't you need a special protocol to have an online chat with somebody at the other end of the country, you didn't even need a host or a talk daemon running on a server!
Finger is much better than HTTP from a security point of view, because it’s incomparably less complex (does one thing only), which eg removes all the risks coming from scripting, and makes sandboxing trivial - on both ends of the connection.
HTTP does a lot of things right, but it’s almost completely oblivious to the contents of requests/responses. Things like DNS also have to specify what a query looks like, and the format for the response.
TLS was hard, the implementations kinda sucked, and it turned out that it was important.
So we went through a dark age where "Just open a socket and have at it" couldn't fly over WAN, which means there wasn't much point doing it at all.
QUIC will fix this. You can treat it like a bunch of TCP streams and UDP datagrams that are Just Encrypted.
I'm thinking about doing a toy IRC knock-off with QUIC. Having TLS standardized in the transport layer means less work for the app, and having multiple streams and datagrams means that odd stuff like file transfers or even voice chat could be tacked on without opening new ports or new TCP streams. Matrix is cool and all, but I want something you can just throw down for a few friends and some bots with a shared password. Matrix homeservers are too much work for one-off.
My old New Year's resolution was always "I'm finally gonna get into web dev". But I don't like web browsers. My new resolution will be "I'm gonna do web stuff, without web browsers."
I'm building a webrtc video based dungeons and dragons app so my sister can DM for my kids and I instead of using Skype/hangouts/discord etc.. which all suck because she's in . So all that to just say I did it in Electron and it was a cinch and I'm doing mobile versions with Ionic. Both are web dev without exactly using browsers, but still using browser engines. Could be fun.
Stupid security people set up stupid firewall rules that blocked everything else (they are mostly going away nowadays, finally). And then NAT and ISP port blocking happened too.
And the phone thing was that on modern processors listening to the network is a serious battery sink.
> You could message the owner of phone directly through a URL. The request would be handled by server on phone!
I know it's not like a web server on the phone or anything, and likely questionable to mention it at all (since I made it), but I made a thing that lets you send notifications to a phone (or desktop) via curl [0] via a simple PUT or POST. It's definitely not a cool protocol since it's simple HTTP, but it's in the spirit of other Unix tools since it's just one thing to do one job.
A. People do still come up with protocols. They've just moved up a level of abstraction. Why deal with the problems http already solves if you don't need to?
B. We now have big enough actors (corporations) that there is less incentive to unify, though even this isn't entirely clear cut. A lot of companies do seem to be trying to create standards for things like iot devices with some success
I think both of those are good reasons, but there's also:
C. Web applications are the way most applications are used on desktop nowadays. The creator already needs to eat the cost of hosting the servers, so you might as well go for control and monetization over delving into making peer to peer work.
It used to be the case that HTTP was used by web browsers (clients) and web servers to exchange mostly textual content. During those times, HTTP was used as a pure application-layer protocol, riding on-top of TCP (a transport-layer protocol).
These days HTTP is used for everything. Server-to-Server API calls, binary data transfer, IPC, etc. A lot of these things get implemented on-top of HTTP though. HTTP is used much more as a transport-layer protocol now, an abstraction layer on-top of TCP.
How did we end up here? It appears that there was an organic need to build an abstraction layer that's easier to work with than TCP, which is probably seen as too low level and much more difficult to work with. Browsers supporting HTTP out-of-the-box with AJAX made this a widespread practice.
I think the reason is because corporate firewalls allow http(s) out to the internet, so everyone just used that, negating the whole point of ports in the first place.
Does adding a header-only (C++) http server to projectM’s visualizer [0] count? I added a very basic http server to switch presets from any basic web browser (including a kindle paperwhite) using a static html page. [1]
It’s been great fun hosting parties and projecting visuals across the room onto an opposite wall. Then passing around a very old Android phone to go through the presets.
I highly encourage others to do the same with their favorite applications it’s fairly straightforward and makes it a pleasure to use.
More than finger, I so miss the times of USENET and the user experience of its hierarchical system of groups with threaded, text-only pull messages (I accessed it from gnus (the emacs newsreader) via my HP 9000 715 running HP-UX 9.03).
The Gemini protocol is an interesting re-imagining of Gopher: extremely simple text-only content, with client-side styling. Identification via client-side certs.
>Why we have stopped making cool protocols like this? It seems Internet had really cool protocols back in the day and we had so many possibilities. Now it seems we are stuck with HTTP.
Because of corporate network firewalls. Make no mistake, they would gladly break HTTP if they could, but it became too important, so now everything has to piggyback on top of HTTP.
Enforce the end-to-end principle and new protocols will flourish.
The Bitcoin wallet world is using Tor to tunnel from mobile apps back to full node software operating on home servers. Not necessarily an example of your first question, but definitely in the spirit of the HTTP server on phone.
I remember Nokia's MWS and if memory serves me it was powered by Apache and Python Server Pages (PSP). I thought it was crazy to port those things to mobile but somebody (reiner-keuchel.de IIRC) ported almost all open source tools to Windows Mobile long before Nokia.
> At her thoughtful suggestion, we are shipping a workstation out with us
He sure picked the right woman.
The Web being the Web, there's more, courtesy Wikipedia: "He met his wife, Katherine Anna Kang, at the 1997 QuakeCon when she visited id's offices. As a bet, Kang challenged Carmack to sponsor the first All Female Quake Tournament if she was able to produce a significant number of participants. Carmack predicted a maximum of 25 participants, but there were 1,500. Carmack and Kang married on January 1, 2000, and planned a ceremony in Hawaii. Steve Jobs requested that they would postpone the ceremony so he could attend the MacWorld Expo on January 5, 2000. Carmack declined and suggested making a video instead."
> Anna Kang left Id a couple weeks ago to found her own company - Fountainhead Entertainment.
> It wasn't generally discussed during her time at Id, but we had been going out when she joined the company, and we were engaged earlier this year. We are getting married next month, and honeymooning in Hawaii. At her thoughtful suggestion, we are shipping a workstation out with us, so I don't fall into some programming-deprivation state. How great is that? :)
Fun Fact: MIT still runs a finger server at mit.edu (no subdomain!) that lets you look up anyone with a registered account. Years ago it was publically accessible, but now you need to make your request from within the MIT network to get a response.
You could also get the schedule for movies shown on campus with `finger @lsc.mit.edu`. That finger server is actually still running but looks like it's not being updated.
Nope, I checked the LSC website and confirmed they are indeed showing movies! So it’s just that the finger server isn’t being updated: http://lsc.mit.edu/
(Note the HTTP link. The HTTPS cert is expired. But even if you bypass that warning I don’t think it’ll ever work due to other certificate errors. On almost all .mit.edu sites HTTPS is broken if you don’t have an affiliate client side very installed...)
Similarly, CMU's finger server is still publicly accessible, although almost no one except for professors in the CS department actually has a .plan file.
Seems to be a very basic social network based on concepts from an old protocol called finger. This website seems to replicate it as a bit of nostalgia.
As you might know, finger is an old protocol (actively used well before my time) which in essence showed information about the users on a server running a finger daemon (usually a Unix-like system).
As I understand it, when you queried for information about a user, a piece of the information you got back would be the contents of a ".plan" file in the user's home directory.
In this file a user could provide what we now call "status updates", which would then be promulgated by finger. You might have put your location, or what you were working on.
To avoid doubt, you can do all of this on the website and don't need to actually use the finger protocol at all. But for true nostalgia you'll need to use the finger command - which works!
.plan is the historic unix equivalent of todays status on social media.
you would write your status (or what you plan to do or whatever) into a .plan file in your home directory,
and you could use the finger command to query the contents of that .plan file from other users on the machine. or on any other accessible machine.
plan.cat appears to be an attempt to make that feature accessible through the web, complete with the ability to create an account and add your own .plan file.
not what i would go for. i would much rather prefer something similar that i put on my own webpage. (well, technically, all it would take is to agree on a standard url like https://my.home.page/plan or something like that.
Wow, it's one thing to read something and harken back to my early days at school and work, but actually running finger from a shell and seeing something real come back caused this deep wave of nostalgia to roll over me. Part of me really misses those days.
I haven't thought about .plan files in years. This takes me back to setting those on the HP-UX account I had at college, and fingering my friends' .plan files daily. That was my first real encounter with actual multi-user, family-tree Unix, though I had been horsing around with some of the various Linuxen available in the mid to late 90s and early 2000s.
Mine usually had snarky movie or TV quotes. Usually from MST3K, Babylon 5 or Army of Darkness.
We had a couple SGI machines (Indigos) for architectural modelling and rendering, would use plan for letting others know that we had a big project rendering; man those were the days!
That's a pretty pathetic offering (a copy of the Wikipedia article about Catalonia in Catalan). They could have at least tried to pick something the reader wouldn't already know about.
Afaik, it's up to the country to determine the rules for the tld. Some require strict rules (eg, .us requires making public a current mailing address, something making me consider getting rid of mine as I don't want that so public), and others (eg, .io and .fm) simply use it as a way to make some money.
My almamater, Grinnell College, has a still active social network Grinnell Plans, which extended from .plan usage for social networking on the college's Vax computer system.
Nice to see a another Grinnell alum in the wild! I want to try plans, but lost access to my @grinnell.edu email after I graduated. What do you think about it? Should I check it out?
Man, this takes me back. I had a .plan file that was an ever-growing list of quotations, often in dialogue with each other. The only one I still remember was one from a friend who said, "you should put more quotes in your finger file."
Let's call it pretty open... I couldn't find one either, years ago, so I kind of went with what works for me.
Note that plan files aren't exactly a micro-blogging platform like some people seem to refer it to as. To me anyway, it's a way to capture work and todos in a simple digital journal.
This is the standard I followed for myself...
This is a rolling plan file where things get moved on completion against a specific date (no backtracking, sliding tasks)
- is todo
* is done (for grepping)
bugs are tagged [bug]
other tags can be use as [tag]
~~is a cancelled~~ task or bug
// is a comment or thought
@next is upcoming work
@later is backlog
if it is not done, it's in next, later or ~~cancelled~~
date is YYYY-MM-DDD followed by a rough recorded timesheet
:0000-0000-XXm as in :start-end military time -minus XX mins of AFK.
timesheet that is parsable by another program to get time spent /week /month /total
For example...
### 2021-01-10-sun :0900-2100-50m
* ditched ~~passport~~ [wtf]
* auth via bcrypt and jwt tokens
* new vue app, trying water.css - nice [noteworthy]
* JSDoc is awesome, makes typescript a lot less needed [noteworthy]
* sign in with email / pass against db
* register against db (not in vue yet)
* validating jwt tokens properly
* clean up package.json
Note that none of this is a replacement for actually doing the work ;)
It was just text. There was no definitive markup format, just what people conventionally used in other text-based forums (like newsgroups) at the time. So you'd have a variety of potential bullets (*, +, -), things like *foo* or _foo_ for types of emphasis, and whatever plaintext formatting they wanted besides that.
We used to run a site at quakefinger.com that scanned all the quake and eventually gamedev plan .files. It was awesome. Sadly the wayback doesn't go back to the earliest days but you can get the flavor here:
I actually love finding simple, durable old sites that are still up. Sometimes the actual end product is still ghastly 90s graffiti art but the backend is usually so beautifully clean.
Times New Roman font on a white background. Everytime I come across a site like this, these adjectives come to mind – Robust, unadorned, resilient, pragmatic, resourceful, efficient, functional and fast.
When I was in college, (1991-1995) I use to enjoy running finger on the unix terminals at the library and reading everyone's .plan. It was popular to put ASCII art in your .plan which I always enjoyed. I collected all that ASCII art and, in 1994, made a website that featured all of it. It no longer has my college URL anymore, but it's still online and gets a respectable amount of daily traffic. (Although interest in ASCII art has steadily waned, since fixed width fonts aren't really a thing on mobile devices.)
If I remember correctly, you could also finger some of the soda machines on campus and check their inventory.
My first impression of this was: I thought it was some sort of doxxing site where people's online pseudonym was matched with their legal name. Oh how I was wrong.
Hmf. I wanted to cobble together a little thing that could update the plan from a shell. Using curl, I can't get anything other than a 500 reply when posting to /login, even after storing and sending the cookie from an initial get request, retrieving the csrf token for the form, and matching all the headers from a normal browser session.
If anybody manages to get a working login with curl, I'd love to see the magic incantation you used.
Even better on MacOS is that if you create a .plan file in your home directory then you can read the file using the finger command! (the port is blocked for external access)
MacOS finger also reads .forward, .project and .pubkey
Twitter's version of it, you might say, is putting the whole world in one flat namespace.
Naturally (as per Tobler's law), we care more about our direct environment, but Twitter never created a view like finger where you could only see the direct members of your own lab, all content is external/public. I think that's because Twitter wasn't planned, but happened as an accidental side project. A more careful design would have created a multi-tiered visibility level with ways to choose what visibility is best for a message (default: local).
It would be cool to create .plan files dynamically using content pulled from social media status updates for people who do not maintain their own .plan.
Much as I bemoan the loss of elegant text-based protocols like this, I am simultaneously thankful that I can interact on a platform that retains a great deal of the spare, text-heavy aesthetic and doesn't come riddled with various "social" integrations, analytics, and auto-playing video trash.
A social network(?) based on .plan files -- back in the day, this was how you let people know your status; you'd use the finger [0] command to get them for a user.
Why we have stopped making cool protocols like this? It seems Internet had really cool protocols back in the day and we had so many possibilities. Now it seems we are stuck with HTTP.
Not saying HTTP is bad. It just seems like we have given up on possibilities. I remember, almost a decade ago, Nokia had a mobile web server for Symbian devices which basically hosted HTTP server on the phone[0]. You could message the owner of phone directly through a URL. The request would be handled by server on phone!
No one makes anything like that anymore. Everyone is just building on top of APIs and services provided by MANGA who would obviously not put any effort in such projects.
[0]: https://linkdekho.in/254nl
Finger is a silly protocol. It doesn't exist anymore because it is worse in every possible way than HTTP (or, at least, the tiny subset of compatible HTTP that replaces it).
I remember when I was earlier in my career and more specialized on implementing weirdo protocols hearing that HTTP was going to replace all the existing protocols. I was appalled; it seemed absurd, like suggesting Word .DOC was going to replace all text files.
But for the most part, the people saying that were right, and we are better off for it. The thing about a lot of those purpose-built protocols, even the "important" ones like DNS and most especially infrastructure stuff like SNMP, is that they are pretty dumb, the product of their time and thus, by construction, deprived of several decades of systems learning.
Something interesting about them though is that they were mostly simple, plaintext, protocols and you could learn a lot by popping open a telnet connection and playing around. At least I learned a lot that way when I was a kid. I figured out how to make HTTP GETs, use IRC, etc playing around with telnet.
13 replies →
Fun trivia: iirc, John Carmack used his .plan as his then "blog" before Twitter came along.
2 replies →
You didn't make an argument for why it's a silly protocol. You didn't make an argument for why it is worse in every possible way than HTTP. You didn't make an argument for why we're better off having replaced everything with HTTP. You didn't make any arguments about they they are "pretty dumb."
Your entire post amounts to "I like HTTP" and "old stuff bad."
37 replies →
I agree the novelty of implementing these protocols wears off as soon as one looks into the security nightmare a poorly implemented protocol can cause.
But I still would like to see efforts happening in applications like Nokia's mobile web server. Another such effort from a decade ago was Opera Unite https://linkdekho.in/1e2vAy
> suggesting Word .DOC was going to replace all text files
Outside of the tech world, it pretty much did.
1 reply →
It's the Windows vs Linux points of view. HTTP is a kitchen-sink, and extremely complex. I know, you're saying 'Wait, HTTP is simple.' Understanding basic HTTP use of GET and POST is simple, the implementation details of the spec needed to be HTTP compliant are complex. Think of features like proper MIME handling, compression handling, redirects, all the authentication options to handle, proxy support, caching, content-negotiation, headers to selectively GET, web sockets, etc. The spec for HTTP/1.1 weighs in at 176 pages.
Finger on the other hand does one thing, and does it well.
I would argue that we need more smaller protocols and less kitchen sink protocols.
The drivers for kitchen sink protocols are not necessarily technical, they could be financial. As a bigger protocol gets more name recognition it becomes a less risky pitch in the eyes of management to adapt the protocol instead of going with a smaller one, or inventing your own. This adaptation sometimes leads to the bigger protocol getting extensions and growing even larger. The other reason HTTP is often used is security policies - the port is open, so no additional ports are needed, and security is already set up to scan HTTP traffic.
Is HTTP any better or is it just an old protocol ("product of its time") that happened to get lucky in its adoption?
8 replies →
worse is better.
it is a protocol for a specific purpose, and because it has that specific purpose, it was used for that, and desired for that. http can do it, but without the constraints, of course nobody will use it for reinventing finger.
I was messing around with servers that had a finger server running a few days ago. I think the university of Wisconsin has a finger server running that exposes the name/address for all their faculty and students
1 reply →
On the ARPANET (the original one running the NCP protocol), not only didn't you need a special protocol to have an online chat with somebody at the other end of the country, you didn't even need a host or a talk daemon running on a server!
From an earlier post:
https://www.youtube.com/watch?v=s3OMSMq9zPA
Finger is much better than HTTP from a security point of view, because it’s incomparably less complex (does one thing only), which eg removes all the risks coming from scripting, and makes sandboxing trivial - on both ends of the connection.
3 replies →
HTTP does a lot of things right, but it’s almost completely oblivious to the contents of requests/responses. Things like DNS also have to specify what a query looks like, and the format for the response.
Be glad you never got SOAP Fingered!
TLS was hard, the implementations kinda sucked, and it turned out that it was important.
So we went through a dark age where "Just open a socket and have at it" couldn't fly over WAN, which means there wasn't much point doing it at all.
QUIC will fix this. You can treat it like a bunch of TCP streams and UDP datagrams that are Just Encrypted.
I'm thinking about doing a toy IRC knock-off with QUIC. Having TLS standardized in the transport layer means less work for the app, and having multiple streams and datagrams means that odd stuff like file transfers or even voice chat could be tacked on without opening new ports or new TCP streams. Matrix is cool and all, but I want something you can just throw down for a few friends and some bots with a shared password. Matrix homeservers are too much work for one-off.
My old New Year's resolution was always "I'm finally gonna get into web dev". But I don't like web browsers. My new resolution will be "I'm gonna do web stuff, without web browsers."
I'm building a webrtc video based dungeons and dragons app so my sister can DM for my kids and I instead of using Skype/hangouts/discord etc.. which all suck because she's in . So all that to just say I did it in Electron and it was a cinch and I'm doing mobile versions with Ionic. Both are web dev without exactly using browsers, but still using browser engines. Could be fun.
So what's the current approach to use quic from C? All that pops up on a cursory google are repos untouched since 2014.
4 replies →
Interesting, as I went into webdev too some two years ago for a year and a half, it was a good experience.
What're your pain points in browsers?
4 replies →
Stupid security people set up stupid firewall rules that blocked everything else (they are mostly going away nowadays, finally). And then NAT and ISP port blocking happened too.
And the phone thing was that on modern processors listening to the network is a serious battery sink.
Not stupid at all: https://en.wikipedia.org/wiki/Morris_worm , brought to you in part by fingerd.
3 replies →
> And the phone thing was that on modern processors listening to the network is a serious battery sink.
Time to create IP over Push Notifications (:
> You could message the owner of phone directly through a URL. The request would be handled by server on phone!
I know it's not like a web server on the phone or anything, and likely questionable to mention it at all (since I made it), but I made a thing that lets you send notifications to a phone (or desktop) via curl [0] via a simple PUT or POST. It's definitely not a cool protocol since it's simple HTTP, but it's in the spirit of other Unix tools since it's just one thing to do one job.
[0] https://ntfy.sh
Missing in the FAQ: what happens when multiple clients have subscribed on a topic (ex: via SSE)?
In practice (2 SSE clients): all clients are notified.
1 reply →
Thanks, looks useful
I think two things have happened.
A. People do still come up with protocols. They've just moved up a level of abstraction. Why deal with the problems http already solves if you don't need to?
B. We now have big enough actors (corporations) that there is less incentive to unify, though even this isn't entirely clear cut. A lot of companies do seem to be trying to create standards for things like iot devices with some success
I think both of those are good reasons, but there's also:
C. Web applications are the way most applications are used on desktop nowadays. The creator already needs to eat the cost of hosting the servers, so you might as well go for control and monetization over delving into making peer to peer work.
It used to be the case that HTTP was used by web browsers (clients) and web servers to exchange mostly textual content. During those times, HTTP was used as a pure application-layer protocol, riding on-top of TCP (a transport-layer protocol).
These days HTTP is used for everything. Server-to-Server API calls, binary data transfer, IPC, etc. A lot of these things get implemented on-top of HTTP though. HTTP is used much more as a transport-layer protocol now, an abstraction layer on-top of TCP.
How did we end up here? It appears that there was an organic need to build an abstraction layer that's easier to work with than TCP, which is probably seen as too low level and much more difficult to work with. Browsers supporting HTTP out-of-the-box with AJAX made this a widespread practice.
These abstractions come at high costs though.
I think the reason is because corporate firewalls allow http(s) out to the internet, so everyone just used that, negating the whole point of ports in the first place.
As someone who works in a massive corporation, this is 100% true.
Does adding a header-only (C++) http server to projectM’s visualizer [0] count? I added a very basic http server to switch presets from any basic web browser (including a kindle paperwhite) using a static html page. [1]
It’s been great fun hosting parties and projecting visuals across the room onto an opposite wall. Then passing around a very old Android phone to go through the presets.
I highly encourage others to do the same with their favorite applications it’s fairly straightforward and makes it a pleasure to use.
[0] https://github.com/hashFactory/projectm
[1] https://github.com/hashFactory/projectm/blob/compression/src...
> Why we have stopped making cool protocols like this.
Eternal September and security concerns.
Any new ideas for missing protocols, HN?
More than finger, I so miss the times of USENET and the user experience of its hierarchical system of groups with threaded, text-only pull messages (I accessed it from gnus (the emacs newsreader) via my HP 9000 715 running HP-UX 9.03).
The Gemini protocol is an interesting re-imagining of Gopher: extremely simple text-only content, with client-side styling. Identification via client-side certs.
I’m sure you could write a Reddit client that emulates this. For better or worse, it’s the most like Usenet today.
4 replies →
Some kind of social media protocol, that broadcast your posts to those that are granted to receive it. Perhaps it is not possible.
1 reply →
Usenet isn't threaded. That's just something constructed client side.
1 reply →
>Why we have stopped making cool protocols like this? It seems Internet had really cool protocols back in the day and we had so many possibilities. Now it seems we are stuck with HTTP.
Because of corporate network firewalls. Make no mistake, they would gladly break HTTP if they could, but it became too important, so now everything has to piggyback on top of HTTP.
Enforce the end-to-end principle and new protocols will flourish.
The Bitcoin wallet world is using Tor to tunnel from mobile apps back to full node software operating on home servers. Not necessarily an example of your first question, but definitely in the spirit of the HTTP server on phone.
People still do:
https://mbays.sdf.org/htalkat/
> Why we have stopped making cool protocols like this?
Why aren't you doing it?
Same reason
This is how life works (biology). At every "explosion" many different solutions appear, and then fewer and fewer survive at each generation.
Gopher is still around! Get involved!
I remember Nokia's MWS and if memory serves me it was powered by Apache and Python Server Pages (PSP). I thought it was crazy to port those things to mobile but somebody (reiner-keuchel.de IIRC) ported almost all open source tools to Windows Mobile long before Nokia.
.plan files were a great way to follow Quake development.
https://github.com/ESWAT/john-carmack-plan-archive
> At her thoughtful suggestion, we are shipping a workstation out with us
He sure picked the right woman.
The Web being the Web, there's more, courtesy Wikipedia: "He met his wife, Katherine Anna Kang, at the 1997 QuakeCon when she visited id's offices. As a bet, Kang challenged Carmack to sponsor the first All Female Quake Tournament if she was able to produce a significant number of participants. Carmack predicted a maximum of 25 participants, but there were 1,500. Carmack and Kang married on January 1, 2000, and planned a ceremony in Hawaii. Steve Jobs requested that they would postpone the ceremony so he could attend the MacWorld Expo on January 5, 2000. Carmack declined and suggested making a video instead."
Wait, what?
I ran down the source for that. It's Carmack himself, and the full story makes Jobs look even worse: https://www.facebook.com/permalink.php?story_fbid=2146412825...
5 replies →
I randomly clicked on this one: https://github.com/ESWAT/john-carmack-plan-archive/blob/mast...
> Anna Kang left Id a couple weeks ago to found her own company - Fountainhead Entertainment.
> It wasn't generally discussed during her time at Id, but we had been going out when she joined the company, and we were engaged earlier this year. We are getting married next month, and honeymooning in Hawaii. At her thoughtful suggestion, we are shipping a workstation out with us, so I don't fall into some programming-deprivation state. How great is that? :)
I believe this was when Carmack ended up writing Doom RPG? Or the other RPG for phones they did
Fun Fact: MIT still runs a finger server at mit.edu (no subdomain!) that lets you look up anyone with a registered account. Years ago it was publically accessible, but now you need to make your request from within the MIT network to get a response.
You could also get the schedule for movies shown on campus with `finger @lsc.mit.edu`. That finger server is actually still running but looks like it's not being updated.
> That finger server is actually still running but looks like it's not being updated.
Or maybe they don't have any events right now due to COVID...
Nope, I checked the LSC website and confirmed they are indeed showing movies! So it’s just that the finger server isn’t being updated: http://lsc.mit.edu/
(Note the HTTP link. The HTTPS cert is expired. But even if you bypass that warning I don’t think it’ll ever work due to other certificate errors. On almost all .mit.edu sites HTTPS is broken if you don’t have an affiliate client side very installed...)
Similarly, CMU's finger server is still publicly accessible, although almost no one except for professors in the CS department actually has a .plan file.
LSC!
Can someone explain what this is?
Seems to be a very basic social network based on concepts from an old protocol called finger. This website seems to replicate it as a bit of nostalgia.
As you might know, finger is an old protocol (actively used well before my time) which in essence showed information about the users on a server running a finger daemon (usually a Unix-like system).
As I understand it, when you queried for information about a user, a piece of the information you got back would be the contents of a ".plan" file in the user's home directory.
In this file a user could provide what we now call "status updates", which would then be promulgated by finger. You might have put your location, or what you were working on.
To avoid doubt, you can do all of this on the website and don't need to actually use the finger protocol at all. But for true nostalgia you'll need to use the finger command - which works!
.plan is the historic unix equivalent of todays status on social media.
you would write your status (or what you plan to do or whatever) into a .plan file in your home directory,
and you could use the finger command to query the contents of that .plan file from other users on the machine. or on any other accessible machine.
plan.cat appears to be an attempt to make that feature accessible through the web, complete with the ability to create an account and add your own .plan file.
not what i would go for. i would much rather prefer something similar that i put on my own webpage. (well, technically, all it would take is to agree on a standard url like https://my.home.page/plan or something like that.
Check https://nownownow.com/about :-)
The digital equivalent of "Gaius was here"? I'm confused as well.
I'm appreciating some of the attempts of SQL injection
https://plan.cat/~yes
Little Bobby Tables is quite active in these corners of the internet.
https://xkcd.com/327/
Wow, it's one thing to read something and harken back to my early days at school and work, but actually running finger from a shell and seeing something real come back caused this deep wave of nostalgia to roll over me. Part of me really misses those days.
Very cool.
This was my somewhat dated .plan from "finger don@mimsy.umd.edu" around 1986 or so...
Through the Hacking Glass:
https://www.donhopkins.com/home/catalog/text/hacking-glass.h...
John Carmack's .plan was the first Twitter.
all the big corporations took one of the coreutils and made a it by translating the concept to 'the internet'. Twitter got finger ;-)
Microsoft got ed.
1 reply →
I haven't thought about .plan files in years. This takes me back to setting those on the HP-UX account I had at college, and fingering my friends' .plan files daily. That was my first real encounter with actual multi-user, family-tree Unix, though I had been horsing around with some of the various Linuxen available in the mid to late 90s and early 2000s.
Mine usually had snarky movie or TV quotes. Usually from MST3K, Babylon 5 or Army of Darkness.
We had a couple SGI machines (Indigos) for architectural modelling and rendering, would use plan for letting others know that we had a big project rendering; man those were the days!
>D. Zimmerman, The Finger User Information Protocol, RFC 1288, December, 1991
Almost 30 years old.
It goes back even further, to RFC 742 in 1977[1]!
[1]: https://datatracker.ietf.org/doc/html/rfc742
https://www.rfc-editor.org/rfc/rfc1288.html
Shouldn't this have content in Catalan to qualify for a .cat domain?
It actually has content in Catalan. "Crear compte" and "Iniciar sessió" are Catalan for "Create account" and "Log in".
Edit: fix typo and now I realize these texts are returned according to the browser's locale. I'm Catalan, so that's why I see them in Catalan :)
The non-user-generated content is returned in Catalan if your browser's language is set to it.
I think this rule has been softened. I’ve seen a bunch of sites with this TLD and no (discernible) catalan content.
For example: https://bongo.cat/
1 reply →
https://let.cat :) you only need to have one page in Catalan
https://let.cat/Landing/Catalan
That's a pretty pathetic offering (a copy of the Wikipedia article about Catalonia in Catalan). They could have at least tried to pick something the reader wouldn't already know about.
3 replies →
Afaik, it's up to the country to determine the rules for the tld. Some require strict rules (eg, .us requires making public a current mailing address, something making me consider getting rid of mine as I don't want that so public), and others (eg, .io and .fm) simply use it as a way to make some money.
Yes, and that is the rule for .cat domains. https://en.wikipedia.org/wiki/.cat
1 reply →
My almamater, Grinnell College, has a still active social network Grinnell Plans, which extended from .plan usage for social networking on the college's Vax computer system.
https://www.grinnellplans.com/documents/faq.html
Nice to see a another Grinnell alum in the wild! I want to try plans, but lost access to my @grinnell.edu email after I graduated. What do you think about it? Should I check it out?
Man, this takes me back. I had a .plan file that was an ever-growing list of quotations, often in dialogue with each other. The only one I still remember was one from a friend who said, "you should put more quotes in your finger file."
https://www.ietf.org/rfc/rfc742.txt
As a side note, I was capturing all my side projects via plan style files,
so I wrote a time tracker for it following a simple format that would calculate roughly how long I spent on each project.
https://github.com/keyle/mdtimesheet
I'm having trouble finding a canonical definition of .plan style files. From Carmack it seems like:
* complete
+ new task
notes
Is that it? Is there somewhere the file format is defined?
Let's call it pretty open... I couldn't find one either, years ago, so I kind of went with what works for me.
Note that plan files aren't exactly a micro-blogging platform like some people seem to refer it to as. To me anyway, it's a way to capture work and todos in a simple digital journal.
This is the standard I followed for myself...
For example...
Note that none of this is a replacement for actually doing the work ;)
http://programming-motherfucker.com
It was just text. There was no definitive markup format, just what people conventionally used in other text-based forums (like newsgroups) at the time. So you'd have a variety of potential bullets (*, +, -), things like *foo* or _foo_ for types of emphasis, and whatever plaintext formatting they wanted besides that.
I still have a .plan file, for nostalgia's sake:
Just wait until the day you cat it and someone has added "same same" or "me too".
Honestly I think every website should respond to a finger request with some information about its users.
Doubtful the domestic violence victims support forum website will gladly implement that functionality.
Few minutes in and, yep, someone is brute-forcing the forgot password.
We used to run a site at quakefinger.com that scanned all the quake and eventually gamedev plan .files. It was awesome. Sadly the wayback doesn't go back to the earliest days but you can get the flavor here:
https://web.archive.org/web/20000520015354/http://quakefinge...
Some clever and funny stuff. Also actually found something useful.
https://plan.cat/~wasabis
I just typed finger @plan.cat and windows 11 responded, my mind is blown away by the fact they included finger in it.
was finger in windows 10 as well?
Yes.
https://i.imgur.com/dJHmPAw.png
Count registered users
one html file, one css file. very nice.
I actually love finding simple, durable old sites that are still up. Sometimes the actual end product is still ghastly 90s graffiti art but the backend is usually so beautifully clean.
Times New Roman font on a white background. Everytime I come across a site like this, these adjectives come to mind – Robust, unadorned, resilient, pragmatic, resourceful, efficient, functional and fast.
1 reply →
When I was in college, (1991-1995) I use to enjoy running finger on the unix terminals at the library and reading everyone's .plan. It was popular to put ASCII art in your .plan which I always enjoyed. I collected all that ASCII art and, in 1994, made a website that featured all of it. It no longer has my college URL anymore, but it's still online and gets a respectable amount of daily traffic. (Although interest in ASCII art has steadily waned, since fixed width fonts aren't really a thing on mobile devices.)
If I remember correctly, you could also finger some of the soda machines on campus and check their inventory.
Who made this? Is the source available somewhere? It's very cool
The author is Joshua Stein (https://jcs.org/projects). I couldn't find the source.
He's the guy who made Lobsters[1]!
[1] https://lobste.rs/
If you look at... https://plan.cat/motd
points to... https://plan.cat/~jcs
Login: jcs Name: Joshua stein
Directory: /jcs Shell: /bin/plan.cat
Last login Wed Nov 17 03:15:42 2021 UTC
Mail forwarded to jcs@jcs.org.
Plan:
Creating an IMAP client for and on a System 6 Mac, recording videos of its development at https://jcs.org/system6c
Working on a WiFi RS232 modem thing with integrated PPP and an SSL-stripping SOCKS5 proxy embedded for my Mac
My first impression of this was: I thought it was some sort of doxxing site where people's online pseudonym was matched with their legal name. Oh how I was wrong.
Hmf. I wanted to cobble together a little thing that could update the plan from a shell. Using curl, I can't get anything other than a 500 reply when posting to /login, even after storing and sending the cookie from an initial get request, retrieving the csrf token for the form, and matching all the headers from a normal browser session.
If anybody manages to get a working login with curl, I'd love to see the magic incantation you used.
On plan.cat/stdin it shows just such an incantation:
It worked for me ¯\_(ツ)_/¯
facepalm I missed that. Nice. Thanks.
On a MacOS Terminal window:
finger tony@plan.cat
It works in Ubuntu 20.04 after a `sudo apt install finger`. The suggested `nc plan.cat 79` also works.
echo tony | nc plan.cat 79
Also works in windows 10
This could be something. Tagline: "If you have to ask, you'll never know." Hat tip RHCP.
Welp. I ruined emojis for everyone.
¯\\_(ツ)_/¯
`finger` always made me uneasy.
finger superluminal@plan.cat
No .project files?
Related: https://finger.farm
This is neat. I am more surprised however that the `finger` utility is still shipped with macOS!
Even better on MacOS is that if you create a .plan file in your home directory then you can read the file using the finger command! (the port is blocked for external access)
MacOS finger also reads .forward, .project and .pubkey
Twitter has replaced it.
Twitter's version of it, you might say, is putting the whole world in one flat namespace.
Naturally (as per Tobler's law), we care more about our direct environment, but Twitter never created a view like finger where you could only see the direct members of your own lab, all content is external/public. I think that's because Twitter wasn't planned, but happened as an accidental side project. A more careful design would have created a multi-tiered visibility level with ways to choose what visibility is best for a message (default: local).
It would be cool to create .plan files dynamically using content pulled from social media status updates for people who do not maintain their own .plan.
You can use the "Lists" feature to zero in on, for example, just your team.
Much as I bemoan the loss of elegant text-based protocols like this, I am simultaneously thankful that I can interact on a platform that retains a great deal of the spare, text-heavy aesthetic and doesn't come riddled with various "social" integrations, analytics, and auto-playing video trash.
Simple is beautiful.
I love it
What is this?
A social network(?) based on .plan files -- back in the day, this was how you let people know your status; you'd use the finger [0] command to get them for a user.
[0]: https://en.wikipedia.org/wiki/Finger_protocol#Finger_user_in...
I think this was the original meaning of fingering.
2 replies →