Computer mail and messaging have probably been independently invented many times. I do not know who first invented these applications; I haven't found any documented versions of computer mail that precede the one I helped create in 1965. This note describes my knowledge of the history of electronic mail and instant messaging.
(I don't really like to use the term "e-mail" or "email." I usually just call it "mail." The use of electrons for mail may someday become quaint, replaced by photons or quarks; should we prepare to speak of "p-mail" or "q-mail"?)
The Compatible Time-Sharing System (CTSS) was begun at the MIT Computation Center in 1961. By 1965, there were hundreds of registered users from MIT and other New England colleges, and CTSS service was provided every day to up to 30 simultaneous users on each of the Computation Center and Project MAC IBM 7094s.
CTSS allowed users to log into MIT's IBM 7094 from remote dial-up terminals, and to store files online on disk. This new ability encouraged users to share information in new ways. When geographically separated CTSS users wanted to pass messages to each other, they sometimes created files with names like TO TOM and put them in "common file" directories, e.g. M1416 CMFL03. The recipient could log into CTSS later, from any terminal, and look for the file, and print it out if it was there.
A proposed CTSS MAIL command was described in an undated Programming Staff Note 39, "Minimum System Documentation" by Pat Crisman, Glenda Schroeder, and Louis Pouzin. Numerical sequence places the note in either Dec 64 or Jan 65. PSN 39 proposed a plan for documenting the CTSS system as many of its developers transitioned to the Multics development project. Among other topics, PSN 39 suggested creation of a facility that would allow any CTSS user to send a message to any other. The proposed uses were communication from "the system" to users informing them that files had been backed up, communication to the authors of commands with criticisms, and communication from command authors to the CTSS manual editor.
My colleague Noel Morris and I were new members of the MIT sponsored research staff in spring 1965, working for the Political Science department. When we read the PSN document about the proposed CTSS MAIL command, we asked "where is it?" and were told there was nobody available to write it. Noel and I wrote a version of MAIL for CTSS in the summer of 1965 and contributed it to the system. Noel saw how to use the features of the new CTSS file system to send the messages, and I wrote the actual code that interfaced with the user. (We made a few changes from the proposal during the course of implementation: e.g. to read one's mail, users just used the PRINT command instead of a special argument to MAIL.)
The CTSS manual writeup and the source code of MAIL are available online.
The idea of sending "letters" using CTSS was initially resisted by management, as a waste of resources. However, CTSS Operations did need a facility to inform users when a request to retrieve a file from tape had been completed, and we proposed MAIL as a solution for this need. (Users who had lost a file due to system or user error, or had it deleted for inactivity, had to submit a request form to Operations, who ran the RETRIEVE program to reload them from tape.) Since the blue 7094 installation in Building 26 had no CTSS terminal available for the operators, one proposal for sending such messages was to invoke a program from the 7094 console switches, inputting a code followed by the problem number and programmer number in BCD. I argued that this was much too complex and error prone, and that a facility that let any user send arbitrary messages to any other would have more general uses, which we would discover after it was implemented. MAIL was added as a CTSS command in August 1965 and announced in Comp Center CTSS BULLETIN 88.
MAIL was a privileged command, that could do things normal user programs could not: it used the call (shown in MAD)
to switch to the recipient's file directory, and then added the message to the user's PRIVATE mode mailbox file on disk. CTSS supported file locking so that readers and writers did not interfere with each other. Users could not read each others' mailboxes, and MAIL was soon used for personal communication as well as work related messages.
The CTSS MAIL command took the file name to be sent and then pairs of arguments, the problem and programmer numbers of the recipients:
MAIL F1 F2 M1416 2962
would send a mail message containing the contents of file F1 F2 to my mailbox. You had to know the problem and programmer numbers for the recipients. You could also send mail to a list of recipients stored in a disk file:
MAIL F1 F2 (LIST) ADDR FILE
You could send mail to everybody on your project by typing
MAIL F1 F2 M1416 *
You couldn't send mail to * * (that is, all users on all projects) unless your programmer number or problem number was canned into the MAIL program. Dick Mills's (assistant director, Project MAC), Bill Bierstadt's (system administrator, MIT Comp Center), and my programmer numbers were baked into the code. We, and any user on the problem number M1416, used for CTSS system programming, could send messages to all users. Because MAIL was privileged, users could trust that messages were sent by the person named in the header, unless their password had been compromised.
The MAIL command created or inserted messages into a file called MAIL BOX in the recipient's home directory. Privileged users could send URGENT MAIL instead, and could send mail even if the user's disk quota was exhausted. The LOGIN command was modified to print
YOU HAVE MAIL BOX
YOU HAVE URGENT MAIL
at login if these files existed and had nonzero length.
Since it uses the ATTACH. call, I believe MAIL could not have been implemented until after the CTSS New File System, which was put up for users on 8/9/65.
While we were implementing MAIL, Noel and I wrote the absolute minimum program that would work. There were many suggested features, options, etc. We left them out. Our idea being to get it working, and put features in later after community discussion.
The essential features of MAIL messages were
Each mail message was
We didn't send between computers because we had only one computer. We didn't send graphics because nobody had a graphics terminal. We didn't have SUBJECT, or other mail headers; but conventions rapidly sprang up. We limited messages in size because disk space was very scarce and expensive.
The full source of the CTSS supervisor and its commands is available in Jerry Saltzer's files at CSAIL. The MAD language source of MAIL is the first file in file COM5. Authors are not listed, but the code is recognizably mine, by comments, style, and indentation.
Errol Morris (Noel's brother) blogged about the creation of CTSS MAIL in five postings on his New York Times blog in June 2011, after some very pleasant telephone conversations with me and a lot of thorough research and fact checking. Errol was also interviewed on NPR about his article on June 20, 2011. Errol's blog was discussed, and his and my voices appear, in a Reply All Podcast on January 28, 2015. Here is Jason Kottke's comment on the postings, quoting professors Corbató and Fano.
Errol's posting is in five parts. But part one doesn't point to part two, and so on. The link above is to part five, which lists all the parts. To read the story, open part five, and then use its links to read the parts in order. Also, sometimes the NY Times web site will not show Errol's postings. Try the Wayback Machine's copy if that happens.
Brad Templeton wrote a nice article on the history of spam on the occasion of the 25th anniversary of the DEC salesman ARPANet spam.
There was an earlier mass electronic mail message sent to a large community of unwilling readers [my definition of spam] that predates the 1978 DEC spam. This message was sent using CTSS MAIL about 1971, at a time of campus unrest and anti-war rallies.
By the start of the 70s, there were over a thousand users of MIT's CTSS system, using the system by dial-up from the MIT campus and from other, mostly academic, locations. They used MAIL to coordinate, share information on all kinds of topics, etc, just as now. In those days I led the system programming group for some of MIT's computing services including CTSS, and I was mighty displeased one day, probably about 1971, to discover that one of my team had abused his privilege to send a long anti-war message to every user of CTSS that began
THERE IS NO WAY TO PEACE. PEACE IS THE WAY.
I pointed out to him that this was inappropriate and possibly unwelcome, and he said, "but this is important!"
Noel Morris and I had foreseen the possibility of inappropriate mass mailing in the original MAIL command, and put in code to prevent it. Then, as now, anti-spam measures were not always effective, and then, as now, the spammer thought that his behavior shouldn't be subject to the rules.
(This story was in Wired Magazine in April 1998. It is no longer online. The author got my name wrong and thought that the story had something to do with mailing lists. The programmer who sent the message, and Noel, are both gone.)
Now we all have to filter spam. I wrote up how I deal with over fifteen thousand spam messages a day.
There was a lot of nervousness in the mid 60s about ticking off the US Post Office. Calling our facility MAIL was thought by some to be a Bad Idea, because they feared the Post Office would require the destruction of a first class stamp for each message sent. If you put a personal note in a parcel, the rule then was that you were supposed to cancel and attach first class postage, because the US Post Office had a monopoly on mail transmission.
We cautiously tried to find out who to ask. We didn't want to ask any low-level people who could only say "no." Finally an MIT professor met someone fairly high up in the Postal Service, who said forget it, don't worry.
Noel Morris and I also wrote a tool for CTSS in spring 1965 called . SAVED (dot saved), inspired by the design for the future Multics shell. . SAVED provided, among other features, a user interface that allowed users to do "instant messaging." There were entry points to the CTSS supervisor that supported such messaging (written by Bob Fenichel and described in Programming Staff Note 27, Jun 1964 and Programming Staff Note 30, Aug 1964) but no user-level way to use them: our program provided a user interface to Bob's code that allowed users to insert lines of text into the terminal output buffer of other logged-in users, and managed deferring and allowing communication so that program output would not be interrupted by messages. Noel did most of the programming on this feature, all in FAP. . SAVED was a user-contributed program that was described in the 1969 edition of the CTSS manual. (Multics was still in the design phase then, so . SAVED was an example of a successor system influencing its predecessor.) FAP source for this program is also available in the Saltzer source collection.
I think a feature was also added to to . SAVED to announce mail if it arrived while you were logged in, by checking the length of MAIL BOX after every command.
SDC's Q32 operating system had inter-user messages (the DIAL, LINK and JOIN commands) in 1963, as described in Prof. David Hemmendinger's paper Messaging in the Early SDC Time-Sharing System. According to him, there was no MAIL facility on the Q32 system. We probably knew about the messaging features; the timesharing world was very small in those days, and system developers knew each other and borrowed ideas freely. I visited a friend at SDC in 1967 and saw an informal demo of the Q32 that included sending a message to the operator with DIAL.
BBN was working on a project named "Mercury" in 1965 which was described as "electronic mail." We knew that it existed but nothing about its features or audience. I don't know if the project was ever completed.
Tom Watson posted a message to alt.folklore.computers remarking that the SDS 940 had local inter-user mail in the mid-60s. Bob Frankston reminds me that the 940 also had inter-user messaging.
This military messaging system was begun in 1962 (Philco-Ford was the contractor) and deployed starting in 1966. Its messages were something like electronic mail. SAGE may have had something similar.
The first Multics mail command was a direct re-implementation of CTSS MAIL, by me, in summer 1969, because once again there was nobody available to do it right. At the time, we were under pressure to make Multics a complete replacement for CTSS, and one of the difficult features to replace was MAIL: Multics did not have the concept of a "privileged" command that could do things the user could not. Designs that used a daemon process to write the user's mailbox were complex and would increase load on an already loaded system. The only design I could find was one that depended on the good behavior of the users.
Original Multics mail lacked privacy, authentication, and security, since it simply opened the user's mailbox as a shared memory segment and added the message to the bottom. There was a lock word at the first location of the mailbox, which was stored into with the STAC (Store A Conditional) instruction to coordinate writers of the mailbox. All users' mailboxes had read and write permissions to all users by default. Since at that time, most Multics users were system developers, we chose to provide a facility for coordination among geographically distributed people, even though it could not provide privacy for the messages.
The user interface was quite similar to CTSS MAIL: the user typed
and the command, by convention, appended messages to the mailbox >user_dir_dir>Multics>VanVleck>VanVleck.mbx. Once again, you had to know the user's registered name and project in order to send mail. To read mail, a user couldn't just print the mailbox, since the lock word at the beginning was binary, not ASCII, and because the Multics virtual memory system did not support file-locking semantics. Instead, the user typed
to read mail. I thought it was a good idea to have one command do two things. I regret this non-intuitive interface now.
The Multics mail facility was reimplemented to use Multics message segments in ring 1 sometime in the early 70s. This made the mail private, authenticated, and reliable, by moving the mailbox segment into an inner protection ring. The inner-ring program coordinated access to the mailbox, preventing destruction and overwriting, and applied extended access control to the mailbox: message segment access permissions were adroswu, for Add, Delete, Read, Own, Status, Wakeup, and Urgent. The extended permission flags allowed us to specify more complex access rules than supported by the Multics virtual memory: for example, that a mail sender could add a message to a mailbox segment but not read its contents, and a user could read messages he or she had written but not those created by others in the same mailbox. (Info segment for the Multics mail command)
Bob Frankston wrote the send_message and allied commands for Multics about 1970, to provide Multics with instant messaging similar to that in CTSS and the SDS-940. The accept_messages command established an event-call channel in the user's process and wrote its ID into a shareable segment in the user's home directory. The command
send_message VanVleck.Multics Want to go to the F&T?
would place the message in the shared segment and send a wakeup. The process that had accepted messages would execute the event-call channel's handler, type out the message, and remove it. Once again, these messages were forgeable and trashable.
With Bob's permission, I adapted his code into the library of standard Multics commands and a subroutine interface for message sending, when I was making improvements to the I/O daemon in the early 70s. When you printed a file on Multics, the print daemon could be asked to send you an instant message when the job printed, showing the physical printer and the print job sequence number. This message helped you track down missing output and saved trips to the printer looking for output that hadn't been printed yet. My version of the accept_messages command allowed the user to specify a command to be executed on each arriving message: some users used this to silently save the print daemon messages in a file, while printing out all other messages.
The messaging facility's internals were also re-written about 1974 to use message segments, and integrated with the mail facility. The Wakeup and Urgent extended access control permissions allowed each user to specify which other users could cause an interrupt.
In the 1970s, Multics was used to create an extremely useful on-line meeting facility, which was used as another means of electronic communication. USGS employee Pat Doherty wrote continuum, a bulletin board program that supported threaded discussions on multiple topics, like the later USENET. Continuum was rewritten and hosted on the Honeywell Phoenix Multics machine to coordinate benchmarks, and then became an internal tool for developers to discuss proposed software changes. When continuum was made part of the Multics product in the 1980s, it was renamed forum. forum was used by other Multics sites for online discussions: one extensive use was by the US National Security Agency to coordinate discussions of security certification by the users of the DOCKMASTER system. Noah Davids wrote a paper in 1983 describing the features and use of forum.
Here is an advertisement titled "What the Heck is Electronic Mail?" that Honeywell ran in computer magazines from 1977 to the early 80s. I think this campaign referred to the Honeywell Level 6 operating system, which had many features inspired by Multics. Honeywell also marketed a Multics "Executive Mail" interface to the mail system in the 70s and 80s.
IBM CP/CMS had electronic mail as early as 1966, and was widely used within IBM in the 1970s. Eventually this facility evolved into the PROFS product in the 1980s.
The man page for V1 AT&T Unix mail suggests that it worked like CTSS mail, by appending to a file in a specified user's home directory. The c source for V5 AT&T Unix mail is also available online, with a date of 1974-11-27. (Presumably Unix mail ran as setuid, so it could write into a destination mailbox owned by some other user.)
J.C.R. Licklider mentioned inter-computer mail to me in a conversation about 1968, when he asked me if I was interested in a project he had in mind, "to connect all the ARPA-funded machines together, and see what they said to each other." He was recruiting folks for what became the Project MAC networking group. By that time, many time-sharing systems had some kind of internal mail. Discussion of linking the mail systems on various computers was one of the earliest applications proposed for the ARPANet.
A series of ARPANet RFCs discuss the "Mail Box Protocol," which was a way of sending messages to an ARPANet host preceded by a user ID. What the site did with such mail afterward was its problem. The first was RFC 196, "Mail Box Protocol," by R. W. Watson, dated Jul-20-1971. It is not clear this protocol was ever implemented.
Multics was connected to the ARPANet in October 1971, and a method of sending mail to other machines on the net and receiving mail from them was done in early 1972 by the MAC networking group, led by Mike Padlipsky; see his "And They Argued All Night...", and RFC 491. Because the @ was a line kill character in Multics, sending mail from Multics to other hosts used the control argument -at instead.
In late 1971, the late Ray Tomlinson of BBN modified the TENEX system's mail program SNDMSG to send messages over the ARPANet to users on other TENEX systems, according to Ray's page, " The First Network Email." This feature was included in the next release of TENEX to user sites in early 1972. Many ARPANet sites used TENEX, and users of these sites could send mail to each other beginning in 1972. Besides sending the first network email, Ray chose the @ sign to separate user name from host name in mail addresses.
Mail software that could send messages between ARPANet hosts with different operating systems was developed step by step, by many researchers at many sites, in the following years. By 1973, e-mail constituted 75 percent of ARPANet traffic, according to Wikipedia.
At first, inter-computer mail was seen as a matter of sending file contents, as CTSS and TENEX had done. RFC 385 "Comments on the File Transfer Protocol," by Abhay Bhushan of the MAC networking group, dated Aug-18-1972, proposed adding MLFL and MAIL commands to FTP, as a way of sending mail. Several further RFCs discussed variations on the idea of sending mail inside the File Transfer Protocol (FTP). A meeting in Feb 1973 agreed on the use of the @ sign in the proposed FTP TO command so that address had the format user@host, as documented in RFC 469.
As more systems connected to the ARPANet, with different ideas of what "mail" was, treating mail as transferring files became more and more of a stretch. It was proposed that mail could be sent from one "mail transfer agent" to another and get delivered when the recipient's machine was connected to the ARPANet. RFC 498 mentions that the TENEX SNDMSG command could send mail to users at remote hosts using the user@host syntax without requiring an FTP login; this was Ray Tomlinson's code. In November 1975, Jon Postel wrote RFC 706, "On the junk mail problem," suggesting that the problem of junk electronic mail had been at least contemplated, if not experienced. RFC 772, "Mail Transfer Protocol," by S. Sluizer and J. Postel, dated Sep-01-1980, inaugurated a series of RFCs which described the features of the Internet mail protocols, leading eventually to the SMTP protocol used for mail today.
Craig Partridge wrote a thorough and illuminating article on Internet mail: "The Technical Development of Internet Email", IEEE Annals of the History of Computing, vol. 30, no. 2, 2008, pp. 3-29.
Dave Crocker wrote an article in the Washington Post Web site on Internet mail: "A history of e-mail: Collaboration, innovation and the birth of a system", March 20, 2012. He has also created a Web page with pointers to email history and a mail discussion list.
Dave Walden also created a Web page with pointers to email history on his site.
You may also be interested in my note on The Risks of Electronic Communication.
Posted 01 Feb 2001
updated 06 Oct 2002, 30 Apr 2003, 29 Oct 2003, 10 Sep 2004, 25 May 2008, 20 Dec 2010, 20 Mar 2012, 08 Aug 2013, 06 Jul 2018
thanks to Bob Frankston, Jerry Saltzer, Quinn DuPont, and Larry Roberts for corrections, to Prof. David Hemmendinger for information on the Q32 TSS, and to Roger Roach for CTSS BULLETIN 88.
Peter Salus interviewed me on this subject in 1998 for the.
An article by me based on this web page was published as "Electronic Mail and Text Messaging in CTSS, 1965-1973", in the IEEE Annals of the History of Computing Vol. 34, No. 1: January-March 2012, pp. 4-6. It is available from IEEE as DOI 10.1109/MAHC.2012.6. My profound thanks to Dave Walden, editor of the Anecdotes department, and another pioneer of electronic mail.
Copyright (c) 2001-2013 by Tom Van Vleck