Internet messaging

It has been a busy year here at Trustica and while typically people use the occasion of the beginning of a new year to reflect on what has happened in the last one, I would like to look further back in time and write about some highlights in the history of Internet messaging. It turns out, the history of communication over interconnected data networks has a lot to do with what we have been up to for almost a year now and we have learned a lot and I think some parts are really worth sharing.

Local systems communication

From the very beginnings of the ARPANET[1] project, the ability to conveniently work on remote systems from an office or from home raised the logical question - how to leverage this ability to collaborate with other people. In the very first days, there was only user messaging on shared systems. You logged into a system, looked around to see who else is logged as well and if you wanted to write them, you just typed "write username Hi there, can I ...?". Single command, single message. If the user wanted to reply, the procedure would be exactly the same - just using your username as the first argument of the write command. If you did not want to be disturbed, you just typed "mesg n" - meaning "no messages" and any attempt to send you a message would just fail.

This worked well, but you can easily notice the drawback. Just to engage in a reasonably fluent conversation you had to type the write command all over again and to add to the mess the messages from the other side were just written on your terminal screen right in the middle of the sentence you were composing. The best way to use this functionality was always for the superuser to tell all logged users something is about to happen - like system restart or planned software update. To mitigate the problems of the write command for casual conversation, talk[2] was created. If the system was running a talk service - a talk daemon - you could just type "talk username" and the user got notified (by the way - the notification was actually an aforementioned "write" message) and if the other side just typed "talk yourusername" a talk session started. You can see such example session in picture 1.

Picture 1: example of a talk session between two users on NetBSD system.

Electronic mail

Although the talk system was written with networking on programmers' minds, you could only use it if both parties engaged in the communication simultaneously and - that was probably the biggest obstacle - started it roughly at the same time. Although you could wait for hours and hours before the other party answers your talk request, you probably would not. Like if you call somebody and nobody picks up the call for some time - you just give up and maybe try it later. Also the system was not designed for exchanging larger amounts of text like you could do by sending a letter. And that is just how electronic mail got started.

The electronic mail has a lot in common with typical snail mail as you know it. You write a message, put it into an envelope, write the recipient's (recipients') address (addresses) on it and throw it into a mail transfer agent. Sounds familiar, does it? But here the "envelope" is rather virtual one and the whole thing looks more like a big postcard - as anyone who sees it passing through any intermediate mail transport system can read it as whole. This is a feature of email which has plagued it ever since and only nowadays we can get reasonable confidentiality when it comes to sending messages this way. But we will get back to this topic later in this series.

Another disadvantage of the original electronic mail system was the inability to transfer anything but plain text. And to make things worse, only an English plain text without any special characters using only a restricted set of characters from the original ASCII[3] table. In order to counter this fact, MIME[4] (Multipurpose Internet Mail Extensions) specification was proposed and standardized. The rest is just a history where mail user agents learned how to handle different types of content and either displayed them or allowed saving them to separate file on disk for later processing by appropriate software.

Network news - Usenet

Communication between sender and recipient (or optionally multiple recipients) was basically a solved issue with the rise of email infrastructure. Announcing changes in network infrastructure or releases of new software was kind of clunky as the number of email recipients had to grow and it eventually reached some hard implementation limits. For example even after the year 2000, people were using Microsoft Outlook which could not handle larger email headers than 65535 characters and crashed if it tried to read an email with so many recipients that the "To" header field was longer. This is why Usenet[5] was born and the Network News Transfer Protocol[6] (NNTP) designed.

NNTP is used to synchronize new messages between news servers and also allows news clients (many email clients can read news as well) to fetch only the index of messages and download only those the user wants to read. Nowadays, the users are familiar with web-based forums where discussions can take place, there are various discussion board on a single server and people can reply specifically to other users' messages paving way for a simple threaded communication. Usenet offers the same - but without the hassle of handling web front-end to it. The topics form a logical hierarchical (tree) structure and the messages may contain reference to another message they are a reply to.

It is kind of funny to learn that long time before web forums and those so-called social networks the communication on the Internet was pretty much the same? Or maybe better? We are going to dig into that next week!

References

1. ARPANET. (2017, December 20). In Wikipedia, The Free Encyclopedia. Retrieved 09:02, December 31, 2017, from https://en.wikipedia.org/w/index.php?title=ARPANET&oldid=816367222

2. Talk (software). (2017, August 4). In Wikipedia, The Free Encyclopedia. Retrieved 09:03, December 31, 2017, from https://en.wikipedia.org/w/index.php?title=Talk_(software)&oldid=793902867

3. ASCII: American Standard Code for Information Interchange, American Standards Association, standard X3.4-1963, June 17, 1963

4. MIME: Multipurpose Internet Mail Extensions, RFC 2045 and following, Network Working Group, November, 1996, available online from https://tools.ietf.org/html/rfc2045

5. Usenet. (2017, November 16). In Wikipedia, The Free Encyclopedia. Retrieved 09:13, December 31, 2017, from https://en.wikipedia.org/w/index.php?title=Usenet&oldid=810639721

6. NNTP: Network News Transfer Protocol, RFC 977, Network working Group, February, 1986, available online from https://tools.ietf.org/html/rfc977