Really Simple Social Blogging

A proposal to implement a decentralized Tumblr/Facebook/Twitter like social blogging platform using simple things like WebMention and Microformats. This is based on some experiments I'm doing with Converspace on sandeep.io and was inspired by The First Federated #Indieweb Comment Thread.

Based on usage, it looks like I primarily do 4 things on sandeep.io:

1. Post original content. This could be text (both short and long form), links, photos, videos, quotes, etc. (http://www.sandeep.io/19)
2. Repost content from others I find interesting. (http://www.sandeep.io/36)
3. Comment on content from others. (http://www.sandeep.io/32)
4. Like content from others. (http://www.sandeep.io/33)

Turns out this is also broadly what you do on Tumblr, Twitter and Facebook:

• Tumblr: blog, reblog, comment and like.
• Twitter: tweet, retweet, reply and favorite.
• Facebook: update status, share, comment and like.

So I set out to see how this could be done in a decentralized way across the #indieweb. A couple of experiments later, I think I have a simple solution for achieving this, using nothing more than simple things like WebMention and Microformats.

The "social" part of this is letting others know that you have done one of those 4 things listed above and especially the person whose content you've reposted, liked or commented on.

This is where WebMention comes. It's a simple way to let any URL on the web know that  you've linked to it on your site. The problem however is communicating the context in which the URL was mentioned:

• Was it just mentioned in passing along with other content?
• Was it's content reposted?
• Was it liked?
• Was it linked to by someone commenting on it?

Taking a cue from the the experimental u-in-reply-to microformat, I'm using the following experimental classnames for links within h-entry:

• u-mention
• I'm actually not using this because if a link within an h-entry does not have any of the classes below it is assumed to be a simple mention.
• u-repost (http://pin13.net/mf2/?url=http://www.sandeep.io/36)
• u-in-reply-to (http://pin13.net/mf2/?url=http://www.sandeep.io/32)
• u-like (http://pin13.net/mf2/?url=http://www.sandeep.io/33)

A target URL that receives a WebMention can retrieve the source URLs HTML content and look for the above Microformat classnames to figure out the context in which it was mentioned along with an h-card/p-author entry to figure out the person involved.

The target can then show:

• Total number of likes along with the details of the people that liked it.
• Total number of reposts along with the details of the people that reposted it.
• Total number of mentions along with the URLs of the sites that mentioned it.
• Comments along with the details of the people that commented on it.

See this in action here: Indieweb Federated "Likes".

An important part that is missing from the above is letting other people easily follow you and get updates when you post something on your site. A microformats based feed reader should solve that. Following someone also gives you the opportunity to send a WebMention to the profile URL of the person you followed which in turn allows that person to show a Follower count (using u-follow maybe) along with the details of the followers. I've yet to explore this but will be posting more details when I get to it and dogfood it.

Wishlist: A microformats search engine that crawls the web looking for microformats, especially h-card so I can search for people just like I can on silo social networks.

Here are some additional experimental classnames I'm considering but not yet using:

• u-quote to be used when you quote text from a URL verbatim.
• u-follow to be used when you follow/subscribe to a URL (usually a person)

Todo

• A way to undo WebMentions (e.g., unlike) by deleting the source URL and sending a WebMention for which the target would receive a 404 in turn deleting the original WebMention. 
• I'm also hoping to extend WebMention to allow for private access to URLs to only the people that were sent a WebMention.

Updates

08 June, 2013

• Added h-card search wishlist.

09 June, 2013

• Added attribution to the @eschnou's indieweb comment thread that was the first instance I know of that combined something like WebMention (Pingback) and Microformats to figure out context. It went beyond the simple rel="in-reply-to" suggestion made in WebMention and read h-cards.
• Added note about sending WebMentions to user profile URLs. (rememberd to add this thanks to this tweet by @benwerd)
• Added note about private access. (rememberd to add this thanks to this tweet by @benwerd)
• Added list of other experimental classnames I'm considering.

10 June 2013

• Created the Todo section and added note about undoing WebMentions.

See Also

• Share vs Repost and Link vs. Mention
• RSSB microformats to Activity Streams

RecentChanges, a simple alternative to ActivityStreams

For updates watch: https://github.com/converspace/recentchanges

Some thoughts on representing updates to a site inspired by wiki style RecentChanges:

• Every resource (URL) has a RecentChanges endpoint.

• The RecentChanges endpoint at each level of the (URL) hierarchy aggregates all RecentChanges under it.

• The RecentChanges endpoint of the site aggregates site-wide RecentChanges.

• RecentChanges only requires/uses 4 verbs: Post, Respond, Update, Delete. (open to renaming these but the idea is that 4 verbs are enough)

• Examples:

• Sandeep Shetty posted Foobar. (new post)

• Sandeep Shetty updated Foobar. (edited an existing post)

• AnonymousOnPurpose responded to Foobar. (commented on a post - could even be a response to a specific comment)

• Sandeep Shetty deleted Foobar. (deleted a post)

Thinking About Metadata

Some of my thoughts on tagging and metadata in Converspace:

• Syntax over Interface: I prefer (from a user experience perspective) how tagging (and other meta-data like mentions, etc.) evolved on Twitter to be just syntax and became part of the content (without being obtrusive) with no special interface elements dedicated to them. This allows for the same interface to serve people that don't need them, and the ones that do. Invisible to the users that don't need it but yet, always there for people that need it.
• Visible Metadata: My preference for tags being part of the content has the advantage of them being always visible (moves/hangs with the content). However, it also has the disadvantage of not being able to cleanly do things like private tags (like how Pinboard does with tags that start with a period. e.g., .secret_tag). One obvious advantage of private tags is that you can do stuff like what Selective Tweets does with the #fb tag, but without having a visible public tag: like this IFTTT receipe that crossposts Pinboard bookmarks to Twitter that have the .twitter private tag. For the specific use case of publishing workflows, I'm considering using (something I'm calling) local action tags (tags that start with &, e.g., &action_tag) that are ephemeral and consumed by the publishing workflow and not saved as part of the content. Action tags obviously cannot be interspersed with the content and will have to be added at the end. Still need to figure out how this will work when the publishing workflow is also adding machine tags at the end. 

Update (after sleeping over it): Won't be implementing actions tags (as described above) because of it's limited scope (especially when it comes to allowing third-parties to participate in the publishing workflow) and I'm on the fence about Machine/Triple tags.

Update (May 07, 2013):

• Auto-tagging: Allow for the publishing workflow to automatically add tags (including Machine/Triple tags). This is hard when you don't have a separate tags property and only have one blob of text (content). For example, it might not make sense to add tags at the end of single-line post when it is missing an ending punctuation mark. To allow for auto-tagging, I came up with a syntax for trailing tags. Trailing tags are preceded by a blank line, starts with two spaces, followed by space-separated tags, followed by the end-of-string. e.g., "\n\n  #additional_tag1 #additional_tag2". Trailing tags can be added at the end of content if they do not exist or tags can be appended to existing ones. I chose this syntax for the following reasons:
• When viewing the Markdown, trailing tags appear slightly indented, which visually separates them from the rest of the content.
• AFAIK, it doesn't conflict with existing Markdown syntax. This makes it invisible when rendered by processors that don't support it.

Update (June 05, 2013):

• Machine tags are invisible metadata: Machines tags provide context for "machines" and should be syndicated but not displayed.

See also:

• http://microsyntax.pbworks.com/w/page/20869409/Sightings
• Flickr: Discussing Machine tags in Flickr API
• http://pigsonthewing.wordpress.com/2008/07/04/triple-tags-on-twitter/
• http://microformats.org/wiki/microblogging-nanoformats
• http://www.pigsonthewing.org.uk/suggested-method-of-publishing-microformats-in-twitter-posts/
• http://microformats.org/wiki/picoformats
• http://twitterdata.org/
• http://blog.wolfspelz.de/2009/09/twitter-microtagging-personal-tags.html
• http://microsyntax.pbworks.com/w/page/20869401/Publishing

Password Free Database

Got around to implementing Mozilla Persona for Converspace. It has its flaws but not having to store user passwords in the db is a big win!

Facebook's Like is just a canned response

• Writing blog posts (long form) is intimidating.
• Twitter's constraints (140 character limit, lack of title) makes writing less intimidating.
• Facebook's Like takes this to its logical conclusion by allowing people to "participate" by "publishing" an "activity" which is just a canned response.

AJAX based Poormanscron

I've been thinking of a good fallback for running long-running processes on commodity hosting for indieweb social web apps. Given the special use case of social web apps, where users might stay on the app for a long time (or leave a window/tab with it always open), an AJAX based poor man's cron might work very well.

References:

• Poormanscron (Drupal module, Ajax based)
• Web bugs for job scheduling: hack or solution?
• AJAX Refreshing RSS Content
• Event Scheduling
• phpJobScheduler

Renamed ActivityPingback to ActivityPush

Did this for a couple of reasons:

• To avoid confusion with Pingback and all its variants (should have done this a long time ago as per Evan's advise).
• To see if I can evolve this into a simple and generic way to push activities, to avoid having to use two protocol, one for pushing solicited notification (to subscribers via PubSubHubbub) and one for unsolicited notifications (which is what ActivityPush does currently). This is similar to what Pump.io does (replaces PubSubHubbub + Salmon), but I want to see if I can do it without an HTTP based protocol and differing a lot of things to the implementations.

Social Verbs

I've been thinking about social verbs lately and what they mean to me and how I want to use them, as opposed to how the social networks want me to use them. So I'm compiling a little work-in-progress list:

• I like something when it brings a smile to my face. (aliases: Love, Heart, Favorite)
• I share something when it is noteworthy and assume others might find interesting. This could be my own content or someone else's content or something someone else has shared. In the context where my blog is separate from my activity stream, I post to my blog and I share the link to the post with others. When my blog and activity stream merge into one, I just share content. (aliases: blog, tweet, status update)
• I bookmark something when I want to save it for future reference. (aliases: save)
• I star something to mark it as important/significant.
• I upvote something (in the context of a list of things) when it is more relevant.
• I recommend something when I really believe in it and want to tell others about it. (aliases: endorse, promote)
• I +1 something when I agree with it or support it.

What do the verbs mean to you?


References:

• "Clicking Like under something you or a friend posts on Facebook is an easy way to let someone know that you enjoy it, without leaving a comment." - What does it mean to "Like" something?
• http://wiki.activitystrea.ms/w/browse/#view=ViewFolder&param=Verbs
• Social verbs: if Facebook is 'to like', Twitter is 'to tweet' and FourSquare is 'to check in', what is Google +? To...

• “Like,” “share,” and “recommend”: How the warring verbs of social media will influence the news’ future
• The verbs of social media
• MMO Language as a Power-up
• Social Verbs
• We need Business Verbs in Social Software
• The 5 Universal Verbs of Social Learning
• Six Verbs You Need to Understand for the New Web
• Learnings about web ratings systems
• POSHstream, a POSHformat profile of activitystrea.ms
• http://indiewebcamp.com/ActivityStreams
• Facebook Like vs Recoomend

Distributed Mentions

Given the URI-centric approach of Activity Pingback (and Activity Web) I'm leaning towards /username over @username to mention/reply-to users on Converspace. This works very well because it's just a relative URI and lends itself well to the Federated Social Web by allowing you to mention/reply-to someone on another network with simple prefixing: some-other-social-network.com/username or another-social-network.com/users/username.

Inspired by:

• "/ is the new @." - Dave Morin
• Slide #37 of Social Network Supermarkets and How to Defeat Them - Chris Messina

See also:

• Consider using emails instead of URIs for identity