Today in Tedium: There’s a certain problem I’ve noticed with social media recently, and it has something to do with the last issue I wrote, regarding Threads. Basically, there are so many emerging social networks right now because Loud Annoying Space Man gave us all a reason to leave Twitter. But the problem is that some of your friends went to Threads. Some of them went to Bluesky. Some went to Mastodon. Some went to T2. Some are still on Twitter. None of these services have compatible APIs at this point. And all of your friends want to read that witty thing you said. So, as an end user, you’re ultimately stuck messaging to people on every single network. This is a solvable problem—and one that we’ve had plenty of practice with in the instant messenger era. Today’s Tedium talks instant messaging protocols, both open and closed, and what they could teach us about this current moment. — Ernie @ Tedium
I took today’s GIF from a Taylor Swift lyric video, a first for me.
Join over 4 million people who read Morning Brew—the daily email covering the latest news across business, finance, and tech. It’s free & only takes 5 minutes to read so that you can get all of the most relevant updates and move on with your day.
The year that ICQ, the early messenger client for Windows, first saw release. Developed originally but the Israeli company Mirabilis in 1996, it was one of many services of its kind in the early days of the internet. (We covered another, the John McAfee-developed PowWow, a few years ago.) For its first couple of years of existence, it competed directly with AOL’s Instant Messenger, which came out in 1997 and served as a bridge between the proprietary America Online and the broader internet. But AOL bought out ICQ in 1998, consolidating the two major IM players under one roof.
For full nostalgia effect, I recommend this LGR retrospective on AIM.
AOL was legally required to open up the AOL Instant Messenger protocol because of its merger with Time Warner … though it kinda got lazy about it
In the late 1990s, instant messaging was all the rage, and for various reasons familiar to anyone who has seen the emergence of Threads over the past week, AOL was the winner by default.
A fully proprietary tool that was originally only designed to work with AOL’s own clients, the service became a phenomenon that solved a key issue for early internet users—it made it possible to communicate with the popular proprietary service if you’re just using a standard issue ISP—or, perhaps, you’re going to college, where AOL isn’t necessary, but you still want to keep in touch with your friends.
The goal was not to turn AOL Instant Messenger into a product that other companies could latch onto, but AOL did some steps to allow for this because it needed to serve one specific audience with its software—Linux users. To help serve that audience, AOL shared information that allowed Linux developers to plug into the company’s proprietary Open System for CommunicAtion in Realtime (OSCAR) protocol.
However, AOL was not alone in the market, and that information was available to noncommercial players and competitors alike.
Not only was it competing with startups like ICQ and Tribal Voice’s PowWow, it was also seeing direct competitors, like Microsoft and Yahoo, attempt to get into this territory. In a 2014 piece for n+1, fellow writer and former Microsoft developer David Auerbach recalled the steps that the company used to attempt to reverse-engineer compatibility between AIM and Microsoft’s own MSN Messenger:
One of the problems Microsoft foresaw was getting new users to join Messenger when so many people already used the other chat programs. The trouble was that the programs, then as now, didn’t talk to one another; AOL didn’t talk to Yahoo, which didn’t talk to ICQ, and none of them, of course, would talk to Messenger. AOL had the largest user base, so we discussed the possibility of adding code to allow Messenger to log in to two servers simultaneously, Microsoft’s and AOL’s, so that you could see your Messenger and AIM buddies on a single list and talk to AIM buddies via Messenger. We called it “interop.”
This wasn’t elegant, but it wasn’t that complicated, either. A program talks to a server using a well-defined protocol, which is a set of coded instructions sent to and from the server. HTTP (hypertext transfer protocol), used to request and transmit web pages, is one of the most common protocols in existence. It is built on top of TCP/IP (transmission control protocol/internet protocol), the underlying protocol of the internet itself. Internet companies run servers that speak these and other protocols. Some protocols, like HTTP and TCP/IP, are public, documented, and spoken by everyone, but some are private/proprietary and undocumented. AIM’s protocol, known as OSCAR (for Open System for CommunicAtion in Realtime), was in the latter group. I didn’t have the “key” to decode it. But what my boss and I could do was sign up for an AIM account and then watch the communications between the AIM client and the server using a network monitor, a development tool used to track network communications in and out of a computer. That way we could see the protocol that AIM was using.
MSN Messenger, which came out in 1999, immediately proved controversial with the AOL camp, which took steps to block the tool. Also in AOL’s crosshairs was Tribal Voice’s PowWow, which had a deal with AT&T to use its software in part because it could guarantee compatibility with AIM.
Fortunately, something happened that required AOL to try and change this terrible, utterly anticompetitive state of affairs, at least for a short while: The company announced plans to merge with Time Warner in early 2000.
This was a famously awful deal that harmed the long-term trajectories of every single giant involved in the deal. AOL, an emerging megacorp at the time of the deal, is a shell of its former self; Time’s once dominant magazine empire has been split up; and I don’t know if you’ve seen the trash fire that is Warner Bros. Discovery, but let’s just say that the roots of that terrible deal started the day AOL and Time Warner decided to join forces. (As this is not GQ, we can talk about it.)
It was a massive agreement, one that survived as a result of industry deregulation that made said agreement look way less unusual than it actually was. And there weren’t many conditions on the merger, considering, but one of those conditions proved important to this battle: AOL would have to take steps to open up its instant messenger protocol.
(They can thank Tribal Voice for that one, even though the service was dead by the time the merger was announced—as the company lobbied heavily for AIM to be regulated.)
There were many skeptics of this idea in the press. Speaking to CNET, Seamus McAteer of Jupiter Media Metrix, said that, with a lack of strict conditions, “The FCC has gifted AOL the market.”
The FCC’s records of attempting to enforce the plan suggest AOL giving it the college try on the standards front, but then kind of throwing up its hands after a couple of years. In part, this is because AOL insisted on building a server-to-server approach to protocol communication around open standards, which, based on its documents to the FCC, it found difficult to implement:
A viable interoperability approach must adequately address these concerns if it is to enhance the user experience rather than undermine IM’s basic appeal. Moreover, if all of these concerns are not fully addressed from day one, there is no way to resolve them at a later date: once a flawed protocol has been implemented, it is virtually impossible—witness email—to undo the damage.
By early 2003, AOL had essentially given up on the endeavor—despite significant pressure to build a protocol from Microsoft, which had tied MSN Messenger directly into Windows XP by this point.
One notable development that came of the FCC’s agreement with AOL, however, was a collaboration with Apple on iChat, the predecessor application to iMessage, which arguably became AIM’s de facto replacement. The FCC reports state that iChat was a “hosted” application, rather than one that relied on an open protocol, and the company seemed to feel that was enough.
The situation—further brought into light by the fact that its competitors were taking steps of their own to rein in third-party applications—shows that there was little appetite for one instant messenger protocol to rule them all.
But no worries, as an open-source solution would show itself.
Five popular instant messenger clients that were designed to work with third-party services
- Adium. An excellent example of an app as famous for its use case as its icon, this tool—in some ways a Mac-specific variant of the popular Pidgin app mentioned below—was hugely popular among Mac users, especially in the PowerPC days. Development, sadly, has slowed in recent years.
- gaim/Pidgin. This tool, developed with the help of AOL’s publicly released documentation on the AIM protocol in 1998, created some legal headaches after AOL decided to trademark the AIM name … after the client had come into wide use. One reason for that might come down to this fact pointed out by Forbes in 2002: “The interface resembles AOL’s Instant Messenger, but it is far smoother and more fun than any of the major IM programs.” Eventually, gaim’s developers came to an agreement with AOL to change the name to Pidgin, and the client has long outlasted its proprietary competition.
- Trillian. Still in active development today, this commercial multiprotocol client dates to the early 2000s. However, over time, the service has stopped developing efforts to support newer third-party protocols to replace the older networks that have gradually shut down over time. It now favors its own solution.
- iChat. AOL’s solution for getting the FCC off its back, just as Microsoft tried with the Justice Department, was to team with Apple. But iChat was more than just an excuse to appease regulators—it was also a pretty good messaging tool in its own right, and it later gained support for protocols beyond AOL. The later Messages app is essentially iChat with the addition of iMessage.
- Jitsi. While best known an open-source video chat protocol and app, Jitsi also is well-known for its wide support of various text-chat protocols. If you hate corporations, you should use this instead of Zoom.
The year that AOL decided to shut down the AIM protocol, a move the company announced on a nostalgia-driven Tumblr. Despite AIM going away, the open-source variants inspired by it have very much not.
The open-source tool that broke through the AOL Instant Messenger monopoly
The state of affairs that led to AOL dominating the instant messenger market and most of its competitors trying to support AOL’s service while blocking external implementations of their own created a situation in which the only true way to break a disruptive market of this nature was through the creation of open-source tools.
We can thank a guy named Jeremie Miller for this. In 1998 or so, Miller made the realization before nearly everyone else that trying to communicate with users across networks was going to be a total pain in the ass, so he decided to do something about it. As he recalled in a 2001 interview with Linux Magazine:
I remember playing with ICQ a couple of months after it hit the streets in 1995 or 1996, and I didn’t know anybody on it, so I dropped it. Then about a year later, people I knew started using it. So I fired it up again. I gradually started having more friends and co-workers using it, and I could use it from home and from work.
Then I had a friend pop up who was on AIM (AOL Instant Messaging). All of a sudden I realized that this was a completely separate network from ICQ, with separate software. I didn’t like AOL anyway. I’ve always thought that AOL makes their users dumb. They’ve got such a dumb interface and they prevent users from accessing anything other than what AOL presents. This seems like a bad thing—users are paying for a simple interface, but there’s nowhere to go from there.
Miller, a talented programmer who had created one of the first XML parsers, put two and two together and made the realization that some of his friends were using handmade scripts to communicate across platforms. The Eureka moment: If he built a tool that could take the information around one proprietary client and convert it to the parsable XML format, it could make it possible to communicate across clients.
And even better, you didn’t actually need the other clients to make this into a unique protocol of its own.
Soon, this work evolved into a protocol named Jabber, and that protocol became formalized over time. It is now known as XMPP, and while instant messaging isn’t what it once was, this protocol is very much still with us, used in mediums far beyond trying to translate AIM messages for ICQ users. The internet of things uses it, for instance.
XMPP was, at least for a few years, a total net positive for instant messengers. It allowed people to communicate between platforms as diverse as AIM, MSN, Google, and Facebook without the need for additional software.
It was effectively the solution that AOL told the FCC it could not figure out how to implement, but lo and behold, here it was.
But it was not perfect, and nor were many of the implementations, which meant that from an end-user standpoint, it was at times a mixed bag, and that made it easy to let go of it when newer protocols were developed—for example, when Google decided to ditch its Talk protocol for Hangouts around 2013.
Over time, other major services peeled off, or never used it in the first place—as was the case with iMessage, which, as I mentioned above, became AIM’s de facto replacement in the U.S.
XMPP, now joined by similar protocols like the Matrix protocol system, is still with us. But the services it supported all either disappeared or started to drop support for the protocol within just a few years. XMPP, like many open-source implementations, outlived them all.
The problem is, the instant messenger had basically become irrelevant over that time.
“Indeed, cannibalizing a federated application-layer protocol into a centralized service is almost a sure recipe for a successful consumer product today. It’s what Slack did with IRC, what Facebook did with email, and what WhatsApp has done with XMPP. In each case, the federated service is stuck in time, while the centralized service is able to iterate into the modern world and beyond.”
— Moxie Marlinspike, the creator of Signal, offering a useful counterpoint to the discussion on standardization and federation in a 2016 blog post. It gets at a tension that often arises with a lot of technologies built around open ecosystems—which is that the standards force the end result to be placed in amber. It makes it easy to build an improved version that gains a user base by simply ignoring or building beyond the spec, as services have done over the years. (AOL actually pushed the FCC to change the conditions of the Time Warner merger for similar reasons, as they essentially barred AIM from jumping into the video chat space, which started picking up steam in the mid-2000s.)
The tale of XMPP comes up a lot these days in discussions of Mastodon and similar social networks, largely as a cautionary tale.
It is seen as the ultimate example of the embrace/extend/extinguish strategy that has been used to kill open standards for decades. The term, tied to the Justice Department’s case against Microsoft in the late 1990s and early 2000s, was originally used to describe how Microsoft would splinter a market by developing what became the most popular implementation of a specific technology, then let the technology die on the vine.
(The lack of development on Internet Explorer 6 in the early 2000s is perhaps the most famous example of the “extinguish” portion of the strategy in action. The internet was too strong for Microsoft’s strategy to work, however.)
In the case of XMPP, its EEE tale involved Google, which went out of its way to build a closed implementation of the standard with only limited support for the whole feature set. As the website Ploum recently explained, it degraded the overall experience for end users who were actually interested in the XMPP protocol:
Newcomers discovering XMPP and not being Google talk users themselves had very frustrating experience because most of their contact were Google Talk users. They thought they could communicate easily with them but it was basically a degraded version of what they had while using Google talk itself. A typical XMPP roster was mainly composed of Google Talk users with a few geeks.
This example gets brought up often in relation to Threads.
Famed Apple blogger John Gruber—who has, strangely, become a harsh critic of efforts by the fediverse to remain noncommercial—has suggested that this argument is null because instant messaging was a dead-end technology.
Sure, that may be the case. But on the other hand, perhaps the reason it dead-ended was because of these protocol limitations, which allowed companies like Google to shape the commercial viability of the product.
The thing is, all the signs that this is a repeating problem are pretty clear from simply looking at the long history of the internet. There is no reason, for example, that a tool like Buffer needs to support numerous social media tools natively. It is only that way because the underlying protocols are not built to talk to one another.
They should, but for business reasons, they don’t. And honestly, there is no motivation to change that—as the instant messenger saga has showed, the only real motivation is to get ahead.
Thanks for reading, and hopefully you aren’t having to replicate messages across too many platforms. Find this one an interesting read? Share it with a pal!