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.