[mailhist-discuss] Fwd: Re: The first email format "standard"?

Dave Crocker dcrocker at gmail.com
Fri Sep 7 11:50:44 PDT 2012

(methinks Jack posted under the wrong email address...)

-------- Original Message --------
Subject: 	Re: [mailhist-discuss] The first email format "standard"?
Date: 	Fri, 7 Sep 2012 11:24:42 -0700
From: 	Jack Haverty. <jack.haverty at gmail.com>
To: 	Dave Crocker <dcrocker at gmail.com>
CC: 	mailhist-discuss at emailhistory.org

Personally, I think of it as a standard.  But it really depends on your
own definition of "standard".   At one extreme is the
formal-approval-by-vote; at the other is the "rough consensus and
running code" mantra of the Internet.   Many such "standards" were
defined by emails passing around things like header formats within a
group of researchers trying to get their systems to interoperate, well
before the appearance of an RFC.

RFC561 as the "first" email standard?  Probably not - we were exchanging
email via FTP MAIL well before that.

While I still remember, I can provide some historical background for

In 1973, I was on staff at MIT in the Lab for Computer Science (aka
Project MAC), in Prof. Licklider's group.  Abhay Bhushan was in the same
group; his office was a few doors down the hall.  Ken Pogran was in the
Multics group, a few floors away.

My MS thesis adviser was Lick, and he was very interested in
human/machine synergy - "Libraries of the Future:, etc.  My thesis in
1971 had involved building "Lexicontext", which used a technique for
storing documents as sequences of dictionary references rather than
ascii text.  This opened up all sorts of possibilities for computer
manipulation of documents, ranging from faster searching to
"intelligent" search, e.g., being able to recognize that "mail" and
"message" might be the same concept.

So, when we needed to get our PDP-10 (MIT-DM) into the ARPANET world, I
guess I was the natural choice to do the email system - but using some
of the "Libraries of the Future" thinking, to make an email system that
could support experimentation in use of computer power for human

Within the ARPANET community, email at the time mostly involved just the
basic functions of sending some text, replying, etc.  The system I built
with Lick's guidance was much more ambitious, with a rather
unimaginative name - "COMSYS".   Mail messages were stored and handled
as structured data, which meant it was easy to write new functions.

Mail was used not only between humans, but also between programs - e.g.,
Mike Broos wrote a little package that allowed him to mail program files
to a compiler, which would take each email, compile it, and reply with
the resulting object code.   Others were experimenting with
functionality modelled on business interactions - e.g., documents that
had a workflow associated with them as they were created by multiple
authors, went through approval steps, etc.   Al Vezza coined the term
"communique" to distinguish such situations from the simpler "note"
usage of email, but the term never caught on.

At the same time, there were lots of other people developing mail
capability for their own computers.  E.G., Ken Pogran was doing work on
MIT-Multics, Ken Harrenstien on the MIT-AI machines, plus people at BBN,
ISI, etc.

This led to a conflict within the community concerning mail formats.
Essentially mail was being asked to do 2 things - support basic
human-human conversations akin to today's texting, and support
program-program conversations akin to remote procedure calls.

The human-human crowd wanted mail formats to be simple, short, and
sweet, and easily human readable.  The computer-processing crowd
(especially me) wanted a format that was precise and easily and reliably

This came to a head as I struggled to keep COMSYS abreast of everyone
else's mail behavior.    COMSYS tried very hard to disambiguate
information in each email so that subsequent processing did what you
expected it to do.

For example, many email programs took shortcuts to save space and make
mail look better to the recipient - such as omitting the <host> part of
addresses.   Instead of "JFH at MIT-DM", they would send "JFH".    But
different programs had different ideas about how to do that.  For some,
an omitted host was assumed to be the same as the sender of the email.
For others, it was assumed to be the same as the previous address on
that particular line.  This kind of variability caused a large pile of
complex code to grow within COMSYS, containing heuristics that tried to
figure out what the text in an incoming mail header actually meant,
depending on where it came from and even which program was used to send
it.  And since everyone else was also writing code, the heuristics broke
frequently when some other system changed.  This technique definitely
didn't scale.

All of this email interaction circa 1973 was over FTP using the MAIL
command, or preferably MLFL, and Abhay, who wrote the ARPANET FTP spec,
was down the hall.  So he was frequently the target of my discontent,
and I think Al Vezza and I successfully badgered him into doing
something about it.     Since I strongly preferred writing code to
writing documents, I was happy for him to take the problem and I think
RFC 561 was the result.

It wasn't perfect.  For example, it didn't solve the problem that
messages sent by the MAIL command had to be fully scanned to make sure
they didn't contain <CR>.<CR> anywhere in the text, since that would
cause premature termination of the message.  But it helped a lot with
making the header contents parseable and therefore usable by programs.

Later on, I finally wrote up RFC713 and RFC722 as a way of at least
capturing some of the notions of handling email as structured data.  If
I tackled this today, it would probably be XML.

/Jack Haverty

*As I Remember It

On Sep 7, 2012 8:40 AM, "Dave Crocker" <dcrocker at gmail.com
<mailto:dcrocker at gmail.com>> wrote:



     I'd like your thoughts on something that just came up...

     I recently saw a reference to RFC 561[1] as a 'standard' and it gave me
     pause.  I hadn't thought it held that position, but that was my first
     year of working on the Arpanet.  RFC 680[2] is sometimes cited with 
     status. Not surprisingly, I had thought RFC 733[3] held the status as
     the first format standard.

     After some discussion, I now have the impression that RFC 561 does
     qualify as the first email format standard.  It was a joint effort 
     colleagues at different organizations.  It sought to provide a common
     base for the email object.  It was implemented and deployed and used.

     It specified basic mail object syntax, basic header syntax, and syntax
     for From, Date and Subject.  That's quite a lot, IMO.

     That some quickly found it deficient and that that finding eventually
     led to RFC 733 does not seem, to me, to negate its relevance as a
     milestone in standardization.



     [1] Standardizing Network Mail Headers

     [2] Message Transmission Protocol

     [3] Standard for the Format of ARPA Netowork Text Messages

        Dave Crocker
     bbiw.net <http://bbiw.net>
     mailhist-discuss mailing list
     mailhist-discuss at emailhistory.org
     <mailto:mailhist-discuss at emailhistory.org>

  Dave Crocker

More information about the mailhist-discuss mailing list