Microblogging with RSS

There's a general sense that Twitter is "getting worse". This is nothing new — App.net was formed two years ago for this reason — but it has flopped, because creating another centralized network was the wrong response.

So where do we go from here?

It's common knowledge that everything we now do with Twitter — posting, following, etc. — could be done with RSS. The infrastructure is there; the only remaining work is UI-related.

For any Twitter replacement, we'd expect comparable functionality:

• Fast, streaming updates
• Follower counts
• Length limitations
• Mentions (with notifications for those mentioned)

I'll take these in turn.

Fast, Streaming Updates: This is kind of a big deal, but it's also an easy need to address. Most RSS usage isn't the kind where subscribers are refreshing their feeds every minute or so. Ultimately you have to hit a separate server for every person you follow.

But in the wake of the Google Reader shutdown, we now have several RSS aggregator services (Feedly, Feedbin, etc) all set to poll any RSS feeds we might subscribe to. And because most of these services mimic Google Reader's API, there are a number of apps that sync with those services.

This means that we already have an ecosystem of light-weight RSS apps that can rely on third-party servers to do the heavy lifting of updating feeds. It's still decentralized, but it could in principle be sped up to support near-realtime updates without too much difficulty.

Follower counts: This is a little more difficult. As anyone with a podcast will tell you, it's nearly impossible to tell how many individual subscribers you have based on who's checking your RSS feed.

RSS feed subscriptions rely on anonymous fetches, so new items don't come to you, you have to go pull them — and you don't have to give out any identifiers to do so.

So any given six feed requests could be coming from one person six times, or five people one time, or three people checking from two devices, or two people checking from three devices, etc. etc.. There's really no built-in way to tell how many people are generating those feed requests.

Some RSS services (like Feedbin and Feedly) include in the HTTP request a notation saying how many users they have that are subscribed to that feed.

This notation is not very standardized, but it wouldn't be too hard to do so. Meanwhile it can still be parsed out without too much difficulty as long as it's there to begin with.

Actually knowing who is following you is a completely other matter. With RSS, there would not be any public knowledge of who John or Jane Doe is following without them ultimately taking steps to volunteer that information. This makes it difficult to create lists of who is following who.

There are two approaches possible here: either address it as part of a new microblogging RSS standard, or drop the notion of reliable follower counts/lists altogether.

I think there's something to be said for that second option.

Length Limitations: There's no doubt Twitter's length limitation has been a good thing. I mean, it defines the medium, right?

Where we all disagree is where to set the limit. Some of us have gotten used to 140 characters. Some would rather have 256 characters.

I do not think it's worth trying to get everyone to agree on a universal length limitation.

A better, more flexible approach might be:

1. Set some ridiculously high upper limit on how long a microblog can be before it becomes just a blog — say, 1024 characters.
2. Within that limit, allow users to specify their own length limitation. This character limit they choose will be specified in their RSS feed as a whole, as well as per-item. Exceeding your limitation within any one item might cause the feed to fail some kind validation.

As readers, everyone can then (for example) set an upper limit on the feeds they would see. If I was only interested in Twitter-style tweeters I might not see "retweets" of those who write in more than 140 characters.

An even better, even more flexible approach might be: don't address length limitations in the RSS standards level at all. Allow posts of any length.

• RSS microblog client apps could limit length at their own (or their users') discretion
• Similarly these clients could truncate display of long posts to a user-definable length.

This makes the "micro" in microblogging more of a presentation/UX issue, which is probably where it belongs.

Mentions/Faves: This is, in some ways, a tough one. RSS has no way of enforcing this kind of behavior (where you get notified if someone "mentions" you somehow).

Now, sure, in some ways it's actually quite simple: microblogging clients could just implement webmentions in some form. So everytime you included a link, it would look up the site in question and discover where to send a notification. To get twitter-style mentions, we could, say, agree on a standard notation where @joeldueck.com could mean http://joeldueck.com, so the client would know where to look for the endpoint.

But the fact is, there's no way to guarantee you'll know if someone mentions you, because there's nothing forcing them to send that notification.

Likewise, you can't guarantee that by mentioning someone you'll pop up on their radar, because they may not have implemented a way to receive those mentions.

So what do you need to mimic Twitter over RSS?

1. An RSS reader, ideally one that presents posts in truncated form, in a reverse-chronological mixed stream
2. Optionally, a cloud-based feed-crawler/reader service to do the heavy lifting and sync your position across multiple devices
3. A place to store your posts online
4. A place to serve a feed of your posts

You really only need #1 unless you want to be able to say things too, in which case you need #3 and #4.

Any existing Feedly-style service could provide the #1/#2 combo with just a little UI work.

Any blog could provide the #3/#4 combo. Undoubtedly some that are customized for microblogging would emerge if this becomes a thing.

Or, the Feedly-style service could add support for #3 and #4 without too much trouble.

Manton Reece talks about this in Defining a microblog post.

From my perspective, a microblog post has these qualities:

• Must have an RSS feed.
• Does not have an RSS item title.
• Contains short post text, 280 characters or less.

David Ely is also working on this.

A good example of an "easy" win would be if ThoughtStreams implemented sending and receiving webmentions.

• Perform webmention endpoint discovery and sending on all outgoing links in new cards
• Receive webmentions for streams and individual cards -- display them in appropriate places, and optionally notify the user.
• Ideally allow users to specify a u-in-reply-to URL.

If this were in place, suddenly I'd be able to carry out a exchange with other TS users, or between my TS and any webmention-enabled blog, or between TS and any Twitter account (if the Twitter user is signed up at brid.gy).

So let's talk about UI/UX possibilities and the plumbing behind it all.

The above could be a native app, or just a web-based app that happens to be showing up on a mobile screen.

Looks like your basic Twitter client. But there are some subtle differences.

It's actually an RSS reader, for one.

Instead of Twitter usernames, people are identified by a home URI. This could be their own domain, or the address of their profile page on whatever blog service they use (such as in the first example).

The ‘tweets’ are actually just blog posts.

We see now how ‘microblogging’ becomes purely a UI issue, rather than a length limitation enforced on the input side. Posts longer than X characters are simply truncated and have a permlink tacked on.

So if you write your posts in fewer than (say) 140 characters, you can be pretty sure it won't get truncated. But there's no length limit.

How “mentions” work, the short version: You mention someone simply by including a link. Your blog sends a webmention for every URL linked in the post. If you want to mention just ‘a person’ without regards to any one specific post, you link to their profile URL (e.g. twitter.com/theirname or theirdomain.com)

Q: Aren't URLs just so, well, clunky and clinical, compared with good ol' Twitter @names?

Definitely. But what we're seeing here are good ol' blog posts, which are sent as HTML. So Tim Carmody could just as well send "@jennydeluxe" a mention by writing a post which stored thus in HTML:

Terrific story by  <a href=
"http://twitter.com/jennydeluxe">
@jennydeluxe</a> on Hana Beshara:
<a href="http://www.nytimes.com/
2014/09/28/technology/the-unrepentant-
bootlegger.html">nytimes.com</a>

which would be displayed, of course, as

Terrific story by @jennydeluxe on Hana Beshara: nytimes.com

How “mentions” work, the a-bit-longer version:

Again, this is all based on Webmentions.

1. For every link you include in your posts, your blogging service looks up the link and checks for a <link rel="webmention"> in the page's header. The link tag gives the address of that site's webmention "endpoint" (e.g. site.com/webmention.php)
2. It then sends a webmention in the form of an HTTP request: site.com/webmention?source=mysite.com/posts/147&target=site.com/posts/123
3. The client site verifies that the source URL actually does contain a link to the client and decides what to do with it.

Right now webmentions are very much a DIY thing. Lots of coding involved, very ick for most people.

My thought is that, if Webmentions can head off the same abuse issues that plagued Trackbacks it's very conceivable that we'll start to see support for them baked right in to WordPress and Squarespace, and then it's off to the races.

But supposing webmentions don't work out at all, there's a (potentially much simpler) fallback: your RSS reader simply watches for links to your site in the feeds you've subscribed to. In Twitter parlance this means you only see mentions from people you follow.

UPDATE: With the proposed Vouch extension, you could receive mentions from people you follow and anyone they follow.

Richard Eriksson was inspired to set up a microblog on his site. There are others like this: adactio.com and kartikprabhu.com are two good examples: their authors publish to their own sites, which then re-post to Twitter and/or Facebook, and using web mentions they can track replies and likes from Twitter/FB or directly from other sites.

Here's an example of a microblogging conversation being carried out directly between two blogs.

Starting your own "microblog" is not difficult at this point. Again, what is missing is a client that combines microblogging with an RSS reader to approximate Twitter's UX.

Really, just think an open source Tumblr, optionally self-hosted, with RSS-powered "Follows" and Dashboard.