Thinking of the things that we've lost in the dustbin of history, and tools for keyboard-to-keyboard communication come to mind.

Unix has had a `write` command pretty much forever (`man 1 write` on my Mac says since 1st Edition, though my Linux machine says since 6th Ed): this was pretty simple; open a user's terminal device and write text to it. The command was kind enough to send a little preamble: "Message from cross@chandra on ttys019 at 08:26 ..." so you knew someone was writing to you. On the sending side, it relied on the terminal driver to accumulate a line of text before sending it to the destination terminal. Of course, this is strictly one-way and implicitly half-duplex: people developed conventions for bidirectional "write" sessions by doing things like typing a little bit and then sending an, "o" by itself (to mean "over", as on a radio) or a double blank line or something. Of course, it was restricted to running only on the local machine, and you had to have write permission to the receiver's terminal device, but it worked well enough on timeshared computers. Moreover, it hasn't been "lost" in any real sense; many systems still ship `write` with the base system image. TOPS-20 had a similar mechanism, as did Multics and, I presume, most similar timesharing systems.

Once networks started getting popular, and people moved out of crowded timesharing machines and into the suburbs of networked workstations, this didn't work as well (since users would have to be logged into the same machine). So networked alternatives appeared... Unix had `talk`, which allowed user-to-user communication over a network, and had a split-screen interface so users could type simultaneously without intermingling text.

VMS had the `phone` utility that was similar to `talk`, but supported multiple users and worked over DECnet.

The IBM mainframe was, remarkably, a pioneer here. Running the VM/CMS operating system, each user session was really a virtual machine: you logged into a VM instance that then booted a small, single-user, single-tasking operating system called CMS. The interesting bit here was that CMS (and the underlying "Control Program" in the hypervisor) had a facility for sending short text messages between virtual machines. When augmented with the SNA (System Network Architecture) protocols and RSCS (Remote Spooling Communications Subsystem) you could send messages between machines. The BITNET exploited this to create inter-machine "relays", similar to IRC on the Internet (indeed, BITNET relays were a bit of an inspiration for IRC).

I briefly used VM/ESA on a 3090 in the early 90s, and one could share "minidisks" between virtual machines. CP had an interface for querying who was actively connected to a disk and locally, clever programmers used this to build a simple "chat-room" kind of interface. They wrote an "EXEC" (basically shell script, but in REXX) that queried who was connected to a particular disk, and then made a request to RSCS to send each of those users a message. Users who wished to participate just connected to the relevant disk when they logged in; it was kind of neat to see relay messages appear on your 3270 terminal as folks chatted. Sadly, the mechanism was never extended beyond the local machine.

And of course there was the `finger` command on the Internet, which was useful for querying who was logged into a machine, or get information about a user. Incidentally, the name supposedly derives from the act of running one's finger down the page of a telephone directory to get information about someone. Anyway, users could create a couple of small text files (.project and .plan) that included information about them, what they were up to, etc. Some of these were quite creative. Some folks also extended the `finger` server to provide general information about a network or site (system uptimes, etc).

I don't suspect any of this is regularly used anymore. I miss `finger` and `talk` in particular; they were cool ways to interact with other people.

However, the `talk` protocol was weird (it used a UDP server to "post" a `struct sockaddr_in` on a remote machine; the remote user then connected to their local server and retrieved that and used it to establish a TCP connection somehwere!).

Then there was Zephyr, the Internet Message Send Protocol, SMTP's terminal write, etc....

I suspect approximately none of this is in regular use anymore.

Oh, and there were multiuser variants of `talk`, too! `ytalk` was the one I remember the most, but there were others. The idea was that the `ytalk` client connected to multiple other users, splitting the screen $n$ ways.

It would be mildly interesting to resurrect something like `talk` in the modern age. A strawman design would be to discard the UDP side of it, and instead of talk servers connect directly to one another via TCP connections; a user on one end would use a Unix domain socket to connect to the local talk daemon, that would connect to the remote system on the user's behalf. The remote talk daemon would ring the remote user. The remote user's client would use a Unix domain socket to talk to it's local server and then both sides would use file-descriptor passing to transfer the TCP connection out of the servers and directly to the clients, which would then communicate.

Once the connection is established between clients, it's pretty simple: just copy bytes back and forth. One can imagine adding TLS for encryption, doing all sorts of authentication tricks, using proxies, and so on.

Back in the day we had visions of federated networks, cross-realm Kerberos authentication everywhere, etc. Then the web came and swept all before it.

@cross There was a very, very brief window there when keyboard-mouse pairs could be set up in X-Windows, and multi user systems could share a single large desktop, handing programs back and forth to each other just by claiming focus with the mouse.

@mhoye I remember being pretty blown away the first time I saw the multicast IP services a la the mbone running on a SPARCstation. I remember thinking, "This is the future!"

@cross Seriously. "Multicast Fought Copyright And The Copyright Won" - most of the traffic on the internet is redundancy that exists only because every endpoint needs to be authenticated as a paying recipient.