Dan's Mail Format Site:

Body: Half-Assed HTML

In the last article, I talked about HTML-format e-mail, and the debate about whether to use it or plain text. Whichever you choose, your messages are clearly marked (via the MIME headers) with the type they are (or multiple types in the case of a multipart message), so that the receiving program can properly render it -- if it's HTML, the tags are rendered, while if it's plain text, everything is displayed as-is (even if some of it resembles HTML tags). However, there was one mail program out there which didn't do things this way. Instead of displaying either HTML or plain text, this program treated all messages (regardless of MIME header) as if they were in a peculiar, dumbed-down version of HTML, where only a small subset of the tags were recognized, and they were rendered as markup even in messages intended to be displayed as plain text. This is "HTML Lite", and it was used by old versions of the AOL mail program, and still (though to a lessening extent) influences the behavior even of current versions of that thing.

AOL: A Brief History

There's a good reason why AOL and Internet standards don't always see eye-to-eye; AOL started out as a completely proprietary service with no connection at all to the Internet. AOL's direct ancestor was QuantumLink, a service for Commodore 64 users that flourished in the mid-to-late 1980s (which in fact licensed its technology from an earlier service called PlayNet). This was pretty cool in its day, an online service with a fully graphical interface in a time when other services were plain-text and command-line-based. Also, the Internet of the time (still known as the ARPAnet back then) was restricted to users with some connection to government-sponsored research, so there was a need for proprietary online services to bring the benefits of computer networking to the general public.

The company behind QuantumLink, originally named Quantum Computer Services, later began sister services AppleLink (for Apple computers) and PC-Link (for IBM PCs and compatibles). These services used the same back-end technology as QuantumLink, with platform-specific front-end programs. Then, by the end of the 1980s, they brought PC and Apple platforms together (leaving out the Commodores, causing some anger in C-64 circles; the original QuantumLink service limped on for a few more years into the '90s before being terminated) in their next-generation service dubbed America Online (AOL). This was still a closed, proprietary service, but in 1989 the beginnings of Internet connection came when AOL (along with various other online services) began to support sending and receiving of Internet e-mail, due to a liberalization of Internet policy to allow for some degree of commercial use in what had formerly been a strictly academic network. Access to newsgroups followed in September, 1993 (dubbed by Usenet fans as "The September That Never Ended" due to the influx of AOL "newbies" unfamiliar with netiquette guidelines, causing an effect similar to the usual annual crop of ignorant freshmen on the academic network, but much larger in size and not subsiding by October). The Web began to be accessible on AOL in 1995, though with a cruddy proprietary browser that didn't follow standards very well.

Still, although by the late '90s AOL offered access, in some manner, to most Internet features, neither the management nor the users of AOL considered it to be an "Internet service". It was still a proprietary online service, that just happened to have some connections to the Internet. All its features, both native and Internet-related, were built on top of an interface originally devised for an early-'80s multi-player game service for Commodore computers. Compliance with Internet standards was likely to be close to the last thing on the mind of the developers who were expanding the functionality of AOL's software, including the part that sent and received e-mail. (To this day, both the people who develop AOL and the people who use it still have a good deal of this attitude, even though the popularity of the Internet has forced AOL to market itself as an ISP and expand its Internet functionality until it almost gives its users true, standards-based access.)

Most of the "geek community", including myself, fully expected all the proprietary online services to fade off into the sunset in the late '90s, now that true Internet access was available to the masses. To me, at least, an ISP is just a "pipe" connecting my computer with the Internet via standard protocols; I neither want nor need special proprietary software from my ISP to do online stuff that I can do with the Internet programs of my own choice. It's similar to how the electric company sends power to me, complying with all the relevant standards, so that I can plug in appliances of my own choice that didn't have to be purchased from the same company I get the power from. But the geeks were only partly right; the proprietary online services did fade away, either going out of business, shrinking into insignificance, or getting bought out... all except for AOL, which kept growing until it was the monolith that was doing the buying-out of other online companies. It had found a large market among the computer-illiterate and computer-semiliterate masses as "the Internet with training wheels", but I still have trouble understanding why its users, many of whom now have years of online experience, still refuse to take the damn training wheels off and use a real ISP!

HTML Lite

So, anyway, when they decided to introduce some "enhancements" beyond plain text in their e-mail, such as emphasised text and hyperlinks, they based it on HTML but felt no need to implement HTML completely or correctly, or to recognize MIME headers that indicate what format a message is in so it can be displayed appropriately. Instead, they created a subset of HTML tags called "HTML Lite", and proceeded to render them if it found any within a message, while ignoring any other HTML tags that might occur. Supported tags include hyperlinks (<A HREF="...">) and a few simple formatting tags like <B> and <I>. You'd better not try using anything fancy like tables or stylesheets, and you'd better not nest tags in a complex way; AOL's mail display program will get lost and do weird things.

As long as you were just using AOL's mail program to send mail to other AOLers, nobody noticed anything wrong, as the software used by this captive audience was designed to play nicey-nicey with other AOL software; even though there have been a number of different versions, they all recognize one another's variants of "HTML Lite" and display them the way the sender intended. However, sending or receiving e-mail between AOL and the "real Internet" is another story. These are some of the problems that occur:

If you send a plain text message containing sample HTML code, intended to be displayed literally (e.g., in discussions about HTML syntax among Web developers), AOL is likely to treat whatever parts of that code are within "HTML Lite" as tags to be rendered instead of plain text to be displayed. In some Web development discussions with lots of AOLers, people end up pandering to this by writing code with square brackets instead of angle brackets, or otherwise mangling the syntax, to get around this AOL behavior, at the expense of making the code harder to understand for AOLers and non-AOLers alike.
If you send an HTML-formatted message from the Internet to an AOLer, it was likely to come out as garbage in early AOL versions, with only selected tags interpreted, perhaps incorrectly if they were nested too complexly. A multipart message with text and HTML parts might come out with bits and pieces of both versions splattered randomly on the screen (despite the fact that newer versions of the AOL software actually generate multipart messages of this sort themselves when sending out to the Internet). The exact behavior varied a great deal between the many different versions of the AOL software, making testing difficult.
On the other hand, AOLers are likely to include raw code in plain-text messages sent to Internet users (individually or on mailing lists), because their software lets them drag, drop, cut, and paste to their hearts' content (e.g., to put in a hyperlink) without informing them that this is in fact creating nonstandard code. Because the outbound messages are sent with a text/plain content type (except in newer versions of the AOL software, which default to multipart MIME messages with plain text and HTML versions, but still insist on putting "HTML Lite" tags in the plain text version!), no non-AOL mail reader actually renders them, so you get ugly code like this (taken from an actual message on a mailing list where an AOLer wanted to helpfully provide a few Web links):

E-Newsletters and AOLers

These problems were particularly troublesome for senders of e-mailed newsletters. As I discussed in the last article, this is one case where the use of HTML e-mail is often justified, to present structured and formatted articles with illustrations. The problem is that if there were AOLers on the list receiving the newsletter, at least back in the (not so long-ago) days when earlier AOL software versions were in wide use, they probably wouldn't see the nice formatting correctly. Even if it was sent in multipart form with a plain text version accompanying the HTML, you couldn't count on AOL's software to display the plain text if it couldn't support the HTML; when I tested this a while back, it screwed up royally. Later on, newer AOL versions "fixed" it (to some extent), but lots of users were still using older software, so it was best to assume that anything fancy will make a mess for AOLers. So what do you do?

Many e-newsletter publishers adopted the technique of creating a different version of their newsletter and sending it to anybody with aol.com in their e-mail address. This dumbed-down version could be just plain text, or an attempt at simplistic formatting using the few tags AOL can be counted on to understand. Any URLs in the text should be explicitly hyperlinked in the AOL version (unlike the plain text version of a multipart message), since (unlike practically all other mail programs) AOL's mail program does not automatically link URLs; it needs to be spoon-fed the <A HREF...> tags. While AOL doesn't seem to care what MIME type you announce such a bastardized part-plaintext, part-HTML message as, the "official" correct MIME type is, apparently, text/x-aol.

Of course, some of your users may have non-AOL addresses that actually forward to an AOL mailbox, so you'll still end up sending some AOLers messages they can't read correctly.

Furthermore, by doing this "e-mail address sniffing", you helped to encourage AOL never to fix their mail program to be completely standards compliant... because if they ever did do such a fix, the new version could make a mess of any AOL-tailored mail created around the quirks of earlier versions. Because AOL software has tended to ignore MIME headers, newsletter mailers are sending "HTML-lite" versions with a random assortment of headers, from text/plain to text/html to text/x-aol to something more exotic, or with no MIME header at all. A future, fully standards-compliant, AOL mail reader (if one ever existed) would show raw ugly tags if it received the message as text/plain, would ignore line breaks in the message if received as text/html, or would have no idea what to make of it if some other bizarre MIME type were used. Thus, AOL has painted itself into a corner, where it has to keep its software quirk-compatible with its earlier, more inept, attempts to implement e-mail.

Update

As I've alluded to a few times, different versions of AOL software vary to a great extent both in what they generate (outbound) and what they render (inbound). Newer versions are much closer to "normal" behavior for mail clients, though still with a few quirks. However, conservative senders who want to be sure all AOLers can read their messages sometimes still feel compelled to "dumb them down" to the worst, oldest AOL software's level.

Fortunately, newer, somewhat-more-compliant AOL versions seem to be sufficiently widespread these days that massive dumbing-down is no longer necessary; ordinary HTML-format or multipart MIME messages will come out OK for the vast majority of AOLers. If you're sending plain text messages, however, you suffer more of the AOL quirks due to the fact that some HTML tags are still rendered in such messages, while URLs included as plain text aren't automatically hyperlinked unlike most other mail programs.

The big question for plain-text messages, then, would be: Do I put in <A HREF> tags or not? A lot of commercial mailers do; "AOL Users Click Here" sections are commonplace in e-newsletters, e-commerce sale confirmations, and the like. I don't favor doing this, though, since this stuff is an ugly mess for non-AOLers, and I don't like doing anything ugly to pander to the users of broken software. As far as I'm concerned, AOLers can use copy-and-paste to bring URLs from e-mail to their browser, until either AOL finally comes out with a mail reader that automatically hyperlinks URLs, or the user wises up and quits that crappy service and gets a real ISP account!

Links

Next: How long are lines supposed to be in e-mail messages, and do the popular programs follow the standards in this regard? See what problems occur when they don't.

[<== Previous] | [Up] | [Next ==>]