Werd I/O

For me, one of the most interesting aspects of #xoxofest was the humility on show from people like Evan Williams, Maciej Cheglowski and Cabel Sasser - people who, in my mind at least, have "made it", and should be happy, successful and singing on hillsides with butterflies. Instead, each of their presentations was introspective and personal in different ways.

Frank Chimero captures one facet of it well in this amazing post:

After several talks, an unstated theme began to emerge, providing fuel for many of the stories and ideas expressed throughout the two days. It was often hinted upon, but only directly stated in Christina Xu’s talk. It came out as bright and searing as magnified daylight: “Independence is lonely.”

Independence is lonely.

When I moved to the San Francisco Bay Area, I did so for personal reasons. My mother has (had?) idiopathic pulmonary fibrosis, an incurable disease of the lungs that causes progressive scarring until you can't breathe anymore. I wanted to be close to both my parents to support them, and to spend more time with them. It was a good decision: I was there when she had to be bumped up to two refrigerator-sized oxygen concentrators in parallel in order to be able to breathe, I was there when she had her double lung transplant, and she's lying on my sofabed right now, in readiness for yet another session at the hospital.

So I have no regrets, even with everything else aside. However, you've probably noted that the San Francisco Bay is not the worst place in the world to be if you're making software. Legends have been made here. The people here have have made the world change over and over again - even before the computer revolution - and will do so many more times. I want to be in that mix. Call it egotism, but I believe I can help the world change, too.

But I was lonely.

Now, it's true that I wasn't fully independent, or alone. I work for latakoo, an enterprise video management startup based out of Austin, Texas. I'd been working with them first as an unpaid advisor, and then transitioned to lead their technology team. However, they were all in Texas, and I was all the way over here. Flights and Google Hangouts are useful, but they're not quite the same as having a ready-made community to plug into.

I've always liked to have my own projects, but the last big self-owned project I'd helped to start - something called Elgg - had not ended well. It still continues to be widely used, and I'm still very proud of the work we did, but the startup we'd founded with it succumbed to a series of bizarre interpersonal issues that I still don't fully understand. It's a shame, because we had been successfully bootstrapping, and had succeeded in a way that I think most web startups wouldn't be capable of, from a standing start with zero knowledge.

Those interpersonal issues were killer. There were, through the course of Elgg's evolution, a number of what felt like attempts to subjugate me in importance in the company, and in the project. I was threatening, I think, which is bizarre; if you've ever met me, you'll know that I go out of my way to be un-threatening. (And I was responsible for building the project, which is still in use in two national governments, Fortune 500 companies, etc etc.) In the end, though, it was a disagreement over a fundamental business direction that made me leave; I realized that it could never be profitable under its current heading, and I realized I didn't have quite enough clout to change this on my own. The company faded away less than a year later, and Yammer, a company that took exactly the direction I wanted to head in, was sold to Microsoft for a billion dollars.

So it goes. I left in 2009, just as the web was becoming more mobile; it was something you accessed from everywhere, rather than on your desktop or laptop. So I started to build something called Outmap, which would let anyone create, curate and crowdsource sets of geographically-tied data, and then share and access them from wherever they were. My two big use cases were (for the free version) crowdsourcing lists of free wifi access points using Twitter, which was a big issue at the time, and (for the pro version) being able to take biological species counts using a smartphone.

But then there was a kerfuffle with some people, because they felt that perhaps I shouldn't have been creating any social software at all after Elgg. All software is social, of course, and it was really an attempt to bully me into doing some things I didn't want to do, having already been bullied into doing some things that I also didn't want to do. They had a lot more money and power than me, though, which meant that I wound up shelving the project.

All of which brings me to San Francisco in 2011, feeling utterly burned-out about my own projects, and feeling shy about connecting with people in the industry because I was no longer doing the thing I was vaguely known for. I was forced to be a talker rather than a doer; something I strongly dislike. I had left my girlfriend behind in Edinburgh, I was dealing with a dying parent, I was in the midst of my startup's scrabbling-around phase (trying to find the right product-market fit), I was personally losing money every month because of the phase we were in, and I didn't know anybody at all. Without realizing it, I lost faith in my ability to create things on my own terms. Reader, I was miserable. For a year.

This is where community becomes important. Finally, in an act of desperation, I put out a message saying that I was having trouble meeting people (although, yes, that was mostly because of my own barriers). Tantek Çelik responded, inviting me to a microformats dinner in the Westfield Dome, where I had some great conversation with him, Kevin Marks and Ariel Waldman, and we collaboratively ended up submitting a pull request to Elgg, to get its profiles to support appropriate microformat markup.

A month or two afterwards, I went to XOXO and found a community of independent makers and doers who were creating things on their own terms using the power of the Internet and were improving their lives in the process. In a quiet corner one evening, I cried. And then I made a resolution: I would give myself time, every day, to build my own things again. In November, as part of NaNoWriMo, I wrote a novel.

That Elgg pull request was eventually rejected, and it was as a direct result of this that I found myself writing the first code for Bonita and then idno, and then eventually presenting my platform at IndieWebCamp. It was a lot more than a simple social platform that embodied some technical principles; for me, this journey has been more symbolic. It's been about taking my life, claiming some ownership, and rearranging it to be what I wish it to be.

(An important note: I have no ill will towards the current Elgg team at all, which is, in my opinion, doing a great job.)

I wrote the database and object code for idno while I was spending my evenings in my mother's recovery apartment, while she was getting slowly better after her invasive surgery. A couple of commits were from the ward after she was readmitted. I wrote the interfaces when I had moved back to my own apartment, and was still waking up every night with flashbacks from the day of the operation. I presented the first version - chickens! - when I was finally beginning to breathe again on my own terms, and was wondering what the rest of my life would look like. And now, I'm getting ready to release.

For me, the #indieweb movement has been about software, sure, but it's more importantly been about meeting amazing people and once again being a part of a human movement. I have found my community in San Francisco, and I am no longer lonely.

They say that to have real satisfaction in your career, you should feel like you're making progress on meaningful work. More and more, I feel that way about my life. And it's helping me with my work on latakoo, my interpersonal relationships, and the way I feel about the world.

The power of XOXO isn't in the things that people are making on their own terms, although the things they're making are incredible. It's in the sharing of those things, and in the motivation to create, and in the community.

For both the #indiewebcamp and #xoxofest communities, I can say this: I'm proud to be there.

It was an honor to present Idno to the W3C Workshop on Social Standards: The Future of Business in San Francisco last week.

My position paper, The Indieweb as a Minimally Viable Platform, was previously posted on this site. It speaks for itself: the decentralized social networking technologies evolving as part of the #indieweb, I believe, are perfect for exploring and testing new social workflows and interactions without significant resource expenditure. In enterprise situations, this is key: too often, technology stacks are dictated by committee, and user experience becomes subservient to a growing list of untested needs. Silicon Valley startups know that you need to validate your ideas before you invest too heavily; it's time that enterprise caught up to this approach.

Conversely, larger organizations do have a different set of needs, and it's important to incorporate those into software designed to serve them. Security is often paramount (as it should be), and most large organizations won't consider running software on third-party clouds, or that "phones home" with aggregate statistics about their data. As it happens, those are some of the values that the #indieweb shares. It's also Elgg's largest market, and it's clear that there's still a need for a simple to use, off-the-shelf, fully self-hosted platform that enterprises can use to facilitate social communication internally. Idno's intent as a replacement for Elgg that works with modern web standards continues to be vindicated.

Some comment was made about how the #indieweb presenters at the event had to overcome their fear of the enterprise to get there. That's very far from the case. I've been working on easy-to-use enterprise software for almost ten years, and I continue to be passionate about bringing the ease of use and fluid social interactivity of the rest of the web to that market. I believe that the #indieweb community's work is very applicable, intend to help get it there, and know that I'm not the only one.

Thanks to Harry Halpin, Mark Weitzel and the Programme Committee for inviting me. I learned a lot, and had fun meeting everyone.

Also posted on IndieNews

This piece was submitted as a position paper for the W3C's Workshop on Social Standards: The Future of Business, due to be held on August 7-8, 2013, in San Francisco.

Really interoperable interoperability

Much has been written about both the power of APIs to connect social applications in powerful ways, and vendor lock-in in the context of those APIs. Rather than usher in a new era of interoperability and open computing, APIs have allowed vendors to create new ways to lock users into their ecosystems.

In many verticals, simply gaining access to a product’s API documentation is enough to require complicated licensing arrangements, vendor evaluation of your business intent for the API, and often, an asymmetric Non-Disclosure Agreement. “Open” is the new closed: too often, the API is a proprietary product in itself. This is as true in social software as it is elsewhere.

This proprietary nature carries multiple business risks. Not only does it require that customers invest heavily in a particular vendor’s products, but should that vendor subsequently decide to discontinue those products – as happened recently in the case of Google Reader and a number of Yahoo! products – the customer must repeat that investment in another platform. Finally, recent surveillance revelations must be food for thought for any business using proprietary services to host sensitive data.

Sophisticated open API standards mitigate these risks, but developing support for these can require a significant expenditure, and the business case may not yet be clear to most vendors. There is no doubt that they occupy an important place in the emerging social landscape, but not all vendors, or their customers, can justify the level of technical expense currently required to “buy in”. Indeed, given a high enough barrier to entry, even ostensibly open APIs may inadvertently have the same ill effects as closed ones.

Proving it

Although there have been significant advances in the field over the last five years, there remains a need to prove the business value of decentralized web technologies. To many of us involved in both the industry and the movement, this seems silly: after all, the business value of other decentralized technologies, like email and the phone system, are hardly questioned. Nonetheless, in a world where centralized data siloes regularly receive multi-billion-dollar valuations, the onus is on those of us who are building more open technologies to demonstrate their worth. Note, it is not enough to argue their worth: we must build, ship, and actively demonstrate a profitable product or service with a business model where the decentralized social web is an inextricable component.

I believe that these compelling business models exist, and that they are most easily discoverable in the enterprise. However, belief is not demonstration: we must continue to test and iterate them. During this exploration phase, this means that, our software and underlying protocols must be easy to write, adapt and change. Ease of development is more important than sophistication; we must not create our own technical lock-in before we even ship.

The IndieWeb

The “IndieWeb” movement was founded by Tantek Çelik, Amber Case and Aaron Parecki, around their annual IndieWebCamp event. Although it was originally created to encourage participants to self-host their own web presences (a laudable goal in itself), over the last year it has also begun to incubate a number of simple social web protocols based around Microformats 2 and Webmention.

At its simplest level, assets on the web are marked up with appropriate Microformats 2 classes, so that any parser may obtain a consistent JSON representation of their content. Linked targets on the page are then pinged using Webmention (or pingbacks), which alerts them to the presence of that content. They may then go back and parse the source of the ping, discovering content like comments, replies, event RSVPs and favorites. Adding more content types would be trivial, and indeed, more are emerging every week. If a content type is not registered, the target page may simply register that the source “mentioned” it.

An obvious further implementation incorporates signed HTTP requests for both parsing and Webmention pings, allowing for lightweight authentication so that protected resources can be selectively revealed.

The protocols and standards under development within the IndieWeb community offer some unique advantages for testing decentralized social models:

1. They piggyback on top of an open, decentralized system that everyone has already bought into: the web itself. Indeed, on the IndieWeb, where possible, the web is the API.
2. They are extremely simple to develop for, allowing you to concentrate on building well-designed tools that meet human use cases instead of building support for social protocols.
3. Social software need not be “monolithic”. Suites can be constructed out of small, compatible pieces, loosely joined.
4. Major search engines support Microformats, so marking pages up to be IndieWeb-compatible may also yield SEO benefits.
5. The IndieWeb community actively embraces participation in existing closed networks through a process called POSSE, minimizing the potential business impact for entities transitioning to a decentralized model.

POSSE - Publish (on your) Own Site, Syndicate Everywhere, as coined by Tantek Çelik – accepts that your friends, contacts or customers are easier to reach on the social platforms they’re already using. Therefore, content on your own, independently-hosted platforms syndicate out to your audience across the networks they already use; links point back to the originals. In the short term, it becomes immediately possible to experiment with decentralized social models without losing your existing audience. Over time, it may be possible to transition those audiences to consume and interact with your web presences in a more decentralized way, ensuring that you can post on your terms, and they can consume on theirs.

While most implementations of POSSE concentrate on consumer social tools like Twitter, Facebook, Flickr and Foursquare, there is no reason why the same principle could not be applied to commercial platforms like Yammer, Avid Interplay, GitHub, Salesforce or SocialText – or any proprietary service used internally inside any enterprise, APIs permitting.

Idno as an experimental testing ground

Idno is one embodiment of an IndieWeb-compatible open source platform that can be installed across many hosting environments. It was originally designed as a replacement for older open source networking platforms, but rapidly evolved into a testbed for many of the ideas the IndieWeb community was proposing.

At the time of writing, decentralized social web activities supported by Idno include:

• POSSE posts to Twitter, Facebook, Flickr and Foursquare, and replies on Twitter
• The ability to comment on, or reply to, a post (or multiple posts) on another IndieWeb-compatible site
• The ability to “like” a post on another IndieWeb-compatible site
• The ability to RSVP to events posted on other IndieWeb-compatible sites
• The ability to post content, including status updates, blog posts, bookmarks, photos, geographic “check-ins” and events that other people with IndieWeb-compatible sites may comment on, reply to, “like” or RSVP as appropriate

Due to its framework origins, Idno allows developers to easily build new post types. Indeed, support for events and RSVPs – at the time unsupported by any other IndieWeb-compatible software – were built in a single evening, with one developer, directly after an IndieWebCamp event. Other software produced by IndieWeb developers began to support events and RSVPs the next day. By the end of the week, at least three separate software platforms supported the content type. There is no doubt that the barrier to entry is low for individuals and businesses alike.

Conclusion

The rapid development that IndieWeb standards make possible is perfect for testing business models relating to the decentralized social web. This does not undermine the technologies and successes of the wider federated social web movement, or of other open social software projects; however, it does allow models to be tested much more quickly.

The relatively low barrier to entry of the IndieWeb also may encourage more developers to take part (as has already been shown), and as such, it seems likely that the standards that community is developing may find themselves in wide use for some time to come. An obvious analogy is RSS, which is not a sophisticated syndication standard, but saw widespread use due to its ease of implementation.

Many of the prevalent models for social software are hostile to the needs of both businesses and individual users. The IndieWeb aligns software developers with their users, while providing simpler tools for development, and encouraging both wider participation and more experimentation. I believe the result will be accelerated innovation in social software, and a much faster path to validating business models for the decentralized social web.

#indieweb #w3c #socialweb #business #idno

Syndicated to IndieNews

This site runs on idno: an open source social publishing platform that I've been working on for the past few months in my own time.

You may know that I co-founded Elgg, the open source social networking engine, which is used by the likes of Oxfam, NASA, the World Bank and several national governments as a social intranet and learning platform. The original thinking around Elgg happened a decade ago. Given that, you shouldn't be surprised to learn that my original thought experiment was: What decisions would I make if I was building Elgg today, in 2013? What would I do the same way, and what would I do differently?

Some technical decisions

I knew that I could make a faster social networking platform, with a better templating engine, and a much smaller codebase - even while sticking to PHP as an underlying scripting language. Partially that's because PHP 5.3+ is a much better development platform than earlier versions. It's also because there are now some well-tested, intelligent back-end frameworks, like Symfony 2, and front-end frameworks, like Bootstrap.

One of the major decisions I made when we built Elgg 1.0 was that not only was it a hassle for plugin developers to write their own database schemas - it was undesirable to the point of being dangerous. We effectively faked a NoSQL schema in MySQL by creating a data model around entities (first-class objects like users and blog posts), metadata, annotations and relationships. People were taken aback, and it was row-intensive, but it worked, and it continues to work today.

Nonetheless, today we have NoSQL, so #idno is based around MongoDB. This means there are far fewer database transactions involved - and adding new data to an object is incredibly easy. Together with a plugin architecture based on lazy loading, and Symfony's excellent observer pattern support, as well as the framework code I've built, I'm able to write a new plugin in an hour or two. That's important for a system I'm building in my spare time!

Meanwhile, all of the things about #Elgg that were great - a plugin architecture, granular access permissions - are intact. And on top of that there's a faster framework, and a responsive front-end that works really well in a mobile browser. Great!

But that's not the end of the story.

The #indieweb community has existed for years as a force to advance the state of the independent web, and to promote ownership of our own spaces. IndieWebCamp is an annual event for creators to discuss their platforms, technologies and ideas.

One of the big concepts to come out of #indieweb has been #POSSE: Publish (on your) Own Site, Share Everywhere. The idea is that your friends or followers shouldn't have to join your site to engage with you; you should be able to post on your own site and be read on Twitter, Facebook, Foursquare, or wherever they happen to be. idno has built-in plugins for status updates, blog posts, images, checkins and events. Correspondingly, it also has plugins to #POSSE this content to Twitter, Facebook, Foursquare and Flickr - and writing more would be trivial.

That's just as well, because I've committed to only post on my own site and copy to third parties (where that's possible).

Reinventing the social web

This year, though, something else happened. Using Microformats 2 (a way to very simply embed meaningful markup into any web page) together with Webmention (a way for any web page to lightly ping the pages it references), the community participants created the first indieweb decentralized comments thread.

Using nothing more than the markup on their own web pages and a very simple protocol, the participants created the basics of a decentralized social community, where each comment is hosted on its owner's own site, but nonetheless forms a coherent, easily-readable narrative.

This is a very big deal.

It's a completely different model to traditional social networking, where content typically doesn't bleed outside the walls of a specific social site. It's also different to previous decentralized social networking efforts, which have been in many ways more sophisticated, but much harder to join in with. Because a simple IndieWeb-compatible social tool can be built in an afternoon, just as a simple RSS-compatible tool can be built in an afternoon, these concepts have a much greater chance of succeeding.

Needless to say, idno is now a first-class participant in the decentralized IndieWeb social community. I've implemented IndieWeb comments, and moved immediately to also implement decentralized events that anyone can RSVP to, as well as decentralized likes. It also integrates with Firefox's brand new Social API.

You can browse the web and reply to any page, on a site that you truly own.

As more sites and platforms implement the IndieWeb social standards, those interactions will become correspondingly more social. For now, though, you can go ahead and interact with the web already.

Beyond that, idno will continue to develop over time as a community platform in itself. I'm using it here on my own site as a single-person publishing platform, but it doesn't have to be that at all, and all those Elgg-style features will continue surface as time goes on. But there's a big, wide web out there, and it's important to embrace that as widely as possible.

idno's homepage is here. Meanwhile, I continue to do work I'm proud of in my actual job, working for latakoo to facilitate media storage and transfer for video professionals and the broadcast news industry. We're talking about using decentralized social networking there too - but more on that another time.

I built an easy way to post chickens.

To post a chicken, or series of chickens, the user just clicks on the appropriate content icon:

Note that the content icons are designed to be accessible both on a touch device and with a pointer.

The user is then asked exactly how many chickens they would like to post (with clear messaging: "CHICKEN CHICKEN CHICKEN?").

Once the user has made their chicken selection, a new chicken object is created. An Activity Streams "post" event is called. I've written my chicken plugin to define chicken content as having an Activity Streams object type of "note".

Twitter and Facebook plugins are listening for new "post" events with object type "note". When I post chickens, they're sent one! If I've linked idno with my Twitter and Facebook accounts, the content is sent to those plugins, and they are in turn responsible for sending the content to their respective sites.

My chickens are posted to Twitter and Facebook.

Finally, the default template on my feed defers to my chicken plugin every time someone visits on my site and wants to see my chicken content. (The template there displays chickens with some photographic help.) I've added an h-as-chicken microformat content type behind the scenes, so third-party clients can parse my pages for chicken content. And finally, the Activity Streams content is available to anyone who requests my pages with an Accept: application/json header.

It took 30-45 minutes to code, except for chicken photo search and download time. And here's what a post looks like.

I've been thinking this morning about content types and granular access permissions (which, it turns out, is ground the IndieWeb community has already tread).

Activity Streams is a data syndication format with very granular content types, which is awesome - unless those content types dictate the kinds of content you actually allow people to create with your software.

Why should a content type be strictly a note, or an article, or a place, image, video, application? One of the amazing things about the modern web is that we can combine content types to create experiences that are richer than the sum of their media parts.

At the simplest level, I want to be able to (eg) include a photo with a checkin. But why not construct a post that's a photo followed by some audio followed by some text followed by an interactive widget followed by a non-linear video with an interactive layer on top of it? One of the neat things about the #indieweb is that you control your platform - and that should mean controlling the form of your content too.

Watch this space ...

#indiewebcamp

It shouldn't be surprising. I've been on the web and posting on the Internet since 1994, but posting in the usual way scatters my data all over the place. Short status updates end up on Twitter; longer, more personal ones on Facebook; checkins on Foursquare; photos on Flickr; audio on Soundcloud; etc etc etc.

My site here at werd.io is an attempt to change my posting habits from being silo-first to more of a #POSSE approach: Publish (on your) Own Site, Syndicate Everywhere. Now, all my status updates, posts, photos and checkins are here in one place, on a server that I own running code that I write, and copied to all those other sites.

It's made me think about posting much more deliberately.

A friend of mine often says that you shouldn't publish anything on the web that you wouldn't be happy seeing on a billboard. I don't think that's true on the whole web - for example, at latakoo we're building tools to make sending, storing and sharing private media content (video, audio, images, large data files) easier, including a self-hosted enterprise option that federates with our hosted .com site. But for the free, public, social web, it definitely makes sense.

This morning, I checked into my office, and then I checked into a local BBQ joint for lunch. Do I really need to share that? Possibly; possibly not. It's my choice, but at least having all this content front and center allows me to make it in a more informed way. I'll probably check in a little less often, except perhaps to announce my presence at venues for special events (like IndieWebCamp this weekend) or to "tweet" links to resources I think are interesting.

This is all new, and my thoughts on it are still baking. Having one stream has certainly made me think about my identity online in ways that I haven't for years. Maybe I'll maintain several identities? Run an anonymous site for frivolous checkins or photos of my latté? The jury's still out, but because I'm empowered to run my own platform, the choice is all mine.

#indieweb #indiewebcamp

Markdown is useful: an easy-to-use notation system that allows you to mark up your text in a safe, fast way.

Because you're never letting your users write raw code, there aren't any worries about them posting malware or exploit attempts, or accidentally writing bad markup. At the same time, simple lines and dashes are converted to valid HTML. Everybody wins.

But when you're writing your own site, you don't need to worry about those things. You don't care about you posting malware or exploit attempts. (Either you want to, or you won't.) You also don't need to worry as much about bad markup - and if you're not proficient in HTML, you can install a WYSIWYG editor, like the one in WordPress. Unless you're a Dr Jeckyll who morphs into an id-like alter ego without warning, you don't need to worry about your own trustworthiness as a user of your own system.

On a self-hosted #indieweb site, all #markdown does is restrict what you can do. It has a syntax to learn, just like basic HTML does, and because you actually have to keep in mind which HTML tags it uses when you write it, it's actually a little bit more complicated to remember.

I like a lot of the goals of new publishing platforms like Ghost (I backed it on Kickstarter) but this feature sticks out like a sore thumb to me. I'm not at all sure this is the best writing experience on the web. And I don't see what's wrong with HTML.

Updated to add: I've had lots of feedback by people who point out that they just want to write text, not HTML, which is more than fair enough. But surely this shows demand for a smarter, context-sensitive rich text editor rather than another syntax to learn. Why couldn't an editor know to start creating bullet points when you type an asterisk and a space at the beginning of a new line?

There's been a lot of news stories lately about how technology companies like Google, Apple, Microsoft and Yahoo! may or may not be giving your data to the #NSA as part of a project called #PRISM. They deny it, news outlets confirm it and it's hard to tell what's real and what isn't real.

Whatever your political views, or whether you think government entities should be able to snoop on your phone and electronic communications, it's hard to argue that the sheen hasn't come off the consumer Internet industry. As the economist Umair Haque said earlier today:

15. There is nothing more lethal to an economy than the idea that people have nothing more to contribute than "information".

— umair haque (@umairh) June 7, 2013

The large online services have created a world where, despite the breadth of software's possibilities, the scope of our communications are limited. On Facebook, you can post status updates, links, photos and videos; on Google+, you can post status updates, links, photos and videos. What if you want to post a game, or an interactive multimedia presentation, or a live graph connected to real-time data?

Those things are hard for centralized services, because they've got to concentrate on common denominator forms of content - like status updates and photos - but they're much easier when you control your own site. If you could install your own publishing app as easily as an app on your phone, and then add new ways of posting stuff to that site just as easily, suddenly you would be able to make your presence on the web your own. And you could let other people in - you could create online communities that fit your needs, rather than bending your communities around the limits of a Facebook group or a mailing list.

That's what inspired me to start working on idno, and these are some of the ideas that inspired other people in a community of developers called the #indieweb to build their own sites and platforms. We don't believe in treating people as data points; we believe in user-centered software for individuals. Software that you control.

#idno will be available to install onto your own site later this month; a turnkey hosted version will follow. In the meantime, if you're a developer, you can check out Idno on GitHub, or some of the other IndieWeb projects out there.

Won't you join us?

I've been self-publishing my photos and status updates for less than a week, but I already wouldn't do it another way. Idno lets me post easily from my phone or laptop, and the updates show up on the sites I'm connected to. Right now, that means Twitter and Facebook, but sites like Flickr and LinkedIn are coming. (This is all available as open source code, by the way.)

Technical aside: when I post something new, it gets an Activity Streams object type and verb. Status updates are notes, blog posts are articles, and photos are images. Plugins then listen for when new, public content is created with those object types (and, right now, the "post" verb) , and syncs them to third-party sites as appropriate. That way someone else could write a better status update plugin than mine, and nobody would have to rewrite the plugins that synchronize content.

The other silo that I use all the time is Foursquare. Theoretically, taking the user's location isn't hard - did I mention I'd written a book on Javascript Geolocation? - but in reality, this is harder than just grabbing the user's current latitude and longitude and saving it to an Activity Streams place object. Foursquare maintains an extensive database of venues, that's so good that a bunch of third party services use it as well. I don't really want to have to duplicate that.

There are alternatives: OpenStreetMap has a downloadable free software database of locations. The downside is that you need to extract points of interest yourself - and the database, perhaps predictably, is over 28 gigabytes. That's far too much data for most individual #indieweb sites to be handling themselves. It's certainly not something I'd like to deal with on my personal server.

For me, the perfect use case is this: I click "check in" in idno, the browser grabs my location, I'm presented with a list of nearby points of interest and I select one. The content is saved locally and then synchronized to location-centric services like Foursquare and Facebook Places.

Now, I could use Foursquare's database to populate that list of locations, but somehow that feels unclean. The purpose of me self-hosting is to own my own data, and using that database would make me dependent on Foursquare's service. Also, the flip-side of that also makes me uncomfortable: if my purpose is to put less value into Foursquare's service instead of my own site, I probably shouldn't be using the database they put so much investment into.

I'm not sure anyone else is syndicating their location to sites like Foursquare from their own sites, but if they are, I'd love to hear from them. Until then, I'm considering writing the simplest possible shim: a geolocation plugin that takes my physical location and lets me save a "hint" along with it, that will act as a way to gently nudge the third party synchronization plugins to pick the best venue. The hint wouldn't be publicly displayed, but for example, I could type "amendment" when checking into one of my favorite brewpubs in San Francisco, and that'd be enough for me to be checked into 21st Amendment on Foursquare.

Speaking of which, time to head over the bay and grab a pint ... Sadly, I won't be checking in just yet.

#indieweb #geolocation #posse

I just installed a vanilla configuration of idno onto my new website at werd.io.

idno is a personal attempt at building a publishing platform that adheres to IndieWeb principles: own your own data, publish on your own site, use existing social websites for dissemination but not as an origin. I've also tried to use microformats where possible, allowing every page to contain lightweight semantic information, as well as making it skinnable, extensible, and social.

I also wanted a chance to think about platform design again, separately from my work at latakoo (where I'm CTO) and informed by my previous work on Elgg (which I helped start nine years ago). What would I do if I was building a platform from scratch in 2013? How could I make it more useful?

I'm proud of the results so far, and the decisions I've made. Here are some highlights:

idno is based on Activity Streams, and every page is an API call

If you visit the front page of the site, or click on any user profile, the feed you see is an Activity Stream (albeit rendered to HTML). You can easily toggle a JSON version by setting application/json to be your web client's accepted type. There's automatic RSS, of course, too. And if entities have attachments - for example an uploaded file or a photo - the RSS items have automatic enclosure tags, as you'd expect. (That means idno can host podcasts and deliver other files via RSS.)

The system is designed so that all plugins automatically have an API without having to do any extra work. I'm also planning on implementing HTTP signatures, or something like them, to authenticate seamlessly in addition to standard sessions.

idno uses HTML5 (and Bootstrap, jQuery)

HTML5 needs no introduction or reasoning. Bootstrap is a very handy set of rails for responsive front-end design (with lots of pre-existing themes), and jQuery is an integral part of that. On top of that, idno bakes in some useful features behind the scenes - like autosaving works in progress using your browser's local storage, for example.

idno runs on PHP 5.4 with a MongoDB back-end.

PHP is a controversial decision, but it remains one of the most widely-deployed web scripting languages in the world. Version 5.4 is old enough to be installable on most servers, but new enough to contain some really neat features. Idno makes extensive use of the JsonSerializable interface. (It also uses a lot of 5.3 features like lazy loading and namespaces.) MongoDB, meanwhile, means that we don't have to force plugin writers to maintain schemas, nor to emulate NoSQL in MySQL, which has been a tactic I've used in the past. So far it's performing great, and it also provides GridFS, a useful file store.

All of this a work in progress, which has mostly been coded late at night, and there's still a lot to do. For example, at the time of publishing, the hashtags below aren't linked anywhere and aren't automatically marked up, but I bet if you check back in a few days, they will be. Another is that although my posts are automatically POSSEd out across the web, I can't yet posts things like replies to tweets from the idno interface. Nonetheless, I invite the brave to check out the GitHub repository (idno is released under an Apache 2.0 license), and let me know what you think.

#indieweb #indiewebcamp #idno #opensource