What is a social network?

I would like to reclaim some language:

Social is an adjective that means relating to human society and its members.

A network is an interconnected system of things or people.

Therefore, I’d suggest that we can define a social network as just being an interconnected system of people.

The audience of this talk is a social network; so are your friends, colleagues, interest groups and so on. Social networking tools facilitate social networks. The universe of social tools certainly includes web applications with social functionality, but it also includes structured face to face interactions, telephone, post, SMS, email. In other words, the web is just one possible tool for this purpose – albeit a very effective one.

If you build it, they will come

You can’t install a social networking tool and instantly expect usage: Field of Dreams is not a good model for community development. The web is littered with ghost sites created using Ning, Elgg and more that have been established in the hope that a user-base will magically appear; however, if your main selling point is the social network itself, nobody’s going to join until that network of people exists and is actively using it. It’s a chicken-and-egg problem.

Therefore, you either need to have an existing network of people to facilitate interactions between (for example, when Facebook launched at Harvard) or compelling functionality that is useful without a network of existing users (for example, Delicious).

If we’re creating a tool that’s useful for the first user who signs up, without a pre-existing social network, then what we’re really talking is a software application that uses the web as an interface, and happens to have social functionality as one of its features.

The web as applications

When the web was conceived, it consisted of documents and pages linked with hypertext: linked words and phrases that, when clicked, would load another, relevant document. Each page had its own Uniform Resource Locator, which allowed you to return to that specific page at any time. Each page could be a destination in itself, and although the sites (collections of pages) could be linked together through hypertext, each one had no need to know about your activities elsewhere on the web. Why would they? Documents don’t have memory; their role is simply to impart information.

Step forward to today, and the web is not entirely made of pages: applications now represent a large amount of the web. (Princeton WordNet defines an application as “a program that gives a computer instructions that provide the user with tools to accomplish a task”; Google Docs, Remember The Milk, Flickr, Delicious etc are all applications by this definition.)

The benefits are tangible: you can access an application’s functionality from any web-compatible device, anywhere in the world. You’re no longer bound to the software you happen to have installed on a particular machine, and you no longer need to worry about whether you’ve remembered to save a particular file onto a particular drive. Because of historic resource limitations, web applications tend to be easier to use, and entirely bypass the need for IT departments, which have unfortunately earned a reputation for being obstacles to productivity in many organizations.

This change of web usage has been reflected in the ongoing development of HTML, the markup language that all web interfaces are written in. The first four versions were largely orientated towards documents; however, HTML 5, currently in development, is the first version that explicitly contains functionality to support web applications. That includes offline storage and usage, sessions, and more advanced interface features. However, aspects of the document-orientated model remain.

Silos of information

Each application is its own atomic destination with its own URL, and is by default only aware of data created within it. That means we need to register for each application we want to use, fragmenting our accounts over potentially hundreds of products and company data centers, and that the documents, files and data we create within them can’t easily be shared with other applications. On my desktop, I can write a document in Word and open it in OpenOffice, or take a Paint doodle and load it in Photoshop, but there’s no easy, generic way to take my bookmarks from Delicious into another bookmarking tool, or to take my Google Docs and open them in Acrobat.com.

Currently, each web application is like a silo: they exist on their own, and if they interoperate at all, it’s through specific links between applications that have to be individually developed. Certainly, data created in an application stays in that application; sometimes you can check your GMail address book for contacts in order to find existing friends on a service you’ve just signed up to, for example, but it’s rare that you can actually export data fully into another product. As many of these services are free, a significant portion of their business models revolve around being able to control user-contributed data, keep users coming back, and sell user-generated activity data for marketing purposes. (One has to question whether the market for personal details will continue to be profitable, or whether, like the web advertising market before it, it will saturate and crash.)

In a social networking tool, the site model means that your contacts, the information you share and any detailed access permissions all relate solely to the application they were created in. However, collaborative spaces in social web applications are like documents: they’re one of the currencies of the social web. Just as I need to be able to use my wordprocessor of choice to edit a document, I need to be able to use my social tool of choice to collaborate with others.

Turning the model upside down

Right now, we have to register with each application we want to use. What if we required each application we used to register with us, in digital identities under our own control?

What if, using these identities, anyone could connect to anyone else, and anyone could store their data anywhere as long as the storage provider followed the same broad standards?

The web itself would become a social networking tool.

This is far more flexible, and future-proof:

• Your ability to collaborate is not subject to a single company’s success: social functionality and application infrastructure are inherent in the web itself
• The possibilities for collaboration are not subject to technology beyond common open standards, which can evolve
• A wider range of application possibilities is ensured, because web applications gain the ability to interoperate in a general way
• Privacy and user control are established by allowing a person to determine which application has access to which data

By establishing a general standard for social application interactions, the services and technologies used to make connections become less relevant; the Internet is people, one big social network, and users no longer have to worry about how they connect. We can all get on with communicating and collaborating rather than worrying about where we connect.

User-centered identities

Under this model, providing the software that hosts your digital identity becomes big business. This hasn’t gone unnoticed by the main service providers, and they’re already fiercely competing to be your identity on the web:

• Facebook wants your central identity to be a Facebook account (and arguably have made the user-centric model for the web part of their strategy for a very long time)
• Google wants it to be a Google account
• Twitter wants it to be a Twitter account
• Microsoft wants it to be a Live ID
• OpenID want it to be any OpenID-capable URL

Because I use all of these services, the result is a very complicated identity space. These are a subset of my profiles:

• facebook.com/ben.werdmuller
• google.com/profiles/benwerd
• twitter.com/benwerd
• profiles.yahoo.com/u/4IZCH2K6PEV775MICYR3DXMAMQ
• benwerd@gmail.com [my Microsoft ID, ironically]
• benwerd.com [my OpenID]

For identities to be usable as a generic standard, you should be able to use any of these – or all of them. Nobody has just one facet (or persona) comprising their identity; everyone has a collection, representing the different parts of their lives. Ben Werdmuller the web strategist for hire doesn’t need to be connected to Ben Werdmuller the Doctor Who fan, who in turn doesn’t need to be connected to the Oxford resident. They can be connected if I choose to make them, but separating parts of your life is part of a user’s control over their identity.

However, that needs to be context-specific, not application-specific. Currently, for example, my Facebook account tends to be personal, while my Twitter tends to be professional. That doesn’t make sense: in order to write personally on Twitter, I either have to accept the collision of those two parts of my life, or I need to create an entirely separate, fragmented Twitter account. Wouldn’t it be better to be able to control who sees which interactions, and choose tools based on the functionality they add to a conversation? Otherwise you have the situation I present above: one identity per communication context per application. That will quickly become unmanageable, and the web will be littered with dead profiles.

Conversely, I believe the future of the web is in atomic digital identities based on permissive, open standards, linked together as an application framework.

How do we make this work?

Problem to solve: user control

First and foremost, the framework for decentralization must be established – in other words, the actual social mesh standards that will make it possible.

Technical mechanisms need to be established for controlling access to a resource or collaborative space, which should be easy to use without removing any of the flexibility of the platform, and should allow for the maintenance of multiple personas.

Another part of access control is allowing a resource to expire gracefully. It’s important to know when to lose data: sometimes documents, resources, spaces, personas or entire identities may be transient and only required for a certain length of time. There’s no need for everything on the web to exist indefinitely; currently, rigorous indexes like Google ensure that much of it does.

Finally, the tools and standards we create must be permissive of goals, content and structure that we might not have thought of. There certainly doesn’t need to be an overarching structure or taxonomy between individual identity spaces, and constraining the technology to a rigid set of activities and data types would limit the scope of the platform.

Problem to solve: ownership

Existing web applications tend to have a single-ownership model for resources. However, Silona Bonewald rightly pointed out to me that this isn’t always the case, and in a free-flowing social mesh, multiple ownership needs to be represented. For example, all collaborators on a resource should have ownership access, unless they explicitly choose to rescind that right.

In a company environment, a user’s employer may have shared ownership (or full ownership, with author access available to the employee). The same may be true with students in a university environment. On sites like Facebook, the service owner may in reality have some ownership rights over the content.

How can we maintain this granularity, but also retain user control?

Problem to solve: privacy & transparency

There is a very public attitude of "when you put something online, it’s published" in some parts of the software development community, which is a useful concept that gives developers carte blanche to share data freely. In a fully user-controlled environment, this public-or-completely-private binary situation can no longer be the case; a resource may have been published to a few select people. Ignoring this trait disallows the platform’s use in important environments like enterprises or public bodies.

When you sign up to a service, you agree to that service’s terms and conditions and privacy policy. However, your data may be farmed out to a collection of other, secondary services via APIs, without your knowledge or consent.

An important aspect of user control is knowing how your data is used and where it is transmitted by the applications you use, so I propose a simple, human-identifiable and machine-readable mark that:

1. Applies permissions to how my data can be used by applications (like Creative Commons does for shared content)
2. Tells you in a visual way what happens to your data when you visit a site
3. Incorporates multi-ownership

It may be that these issues are addressed within the terms and conditions of a service. However, it’s very unlikely that a user will actually read the full contract. Therefore, a simple graphic icon with a link to a plain-English description, with an underlying microformat for machine-readable use, would be a welcome addition to the user experience. As the web becomes more mesh-like and data moves around more freely, conveying what happens to data owned by less-technical end users will become more and more important.

Problem to solve: platform

Finally, while it’s great having a conversation about this, these ideas aren’t useful to anyone unless someone goes ahead and builds it.

There are some existing projects and thinkers who are on these tracks:

• The Diso Project is turning the WordPress open source blogging tool into a decentralized digital identity through an array of open standards, and the project’s Chris Messina has a lot of wise things to say about its development.
• Laconi.ca is a decentralized microblogging platform, whose Open Microblogging standard may be adaptable into a more widely-scoped technology.
• The Open Stack is a set of developing technologies that address some of the issues.
• Marc Canter’s Open Mesh treatise goes into detail on many of the issues.

All of these are important contributions that strongly address some of the issues; however, we’re still a long way away from the vision of an open, social web.

Conclusion

I believe strongly, for the reasons stated above, that a decentralized, user-centered model for the web is the best way to advance it as an application platform.

Needless to say, I have my own ideas about how to actually build the platform, based on my Making the most of the web principles. However, it has to be a collaborative process: there’s no sense in building an open collaborative standard by yourself. My main concern is that the platform is created and works in an open, lightweight, flexible, easy-to-develop-for way while remaining secure and yielding control to the main user. The result will be an entirely new kind of platform, and presents a unique opportunity for anyone who wants to jump on board.

Images:

• WOW! My 1000 Friends by Cavin was released under a CC Attribution Generic 2.0 License
• Lonely Tree by Jule Berlin was released under a CC Attribution Generic 2.0 License
• Logo 2.0 part II by Stabilo Boss was released under a CC Attribution-Noncommercial-Share Alike 2.0 Generic License
• Upside Down by Johnny Jet was released under a CC Attribution Generic 2.0 License
• Pro Control 24 by Aud1073cH was released under a CC Attribution-Share Alike Generic 2.0 License

Related entries

• Social networking: beyond the silo (2)
• The Internet is People (3)
• User control on the open web (9)

It seems like the shift in innovation in social tools has gone from developing new and interesting technologies to developing interesting models that happen to use technologies. This is a big step, and in some ways represents the space coming of age. There’s still plenty of technological development and innovation to do, but the platform and concepts are at a point where they can be adapted into all manner of social collaborative spaces, business tools, social experiments, games, art projects, and combinations of those things. It’s becoming a very exciting field to work in.

That said, some adaptation needs to happen, and it’s important to realize that these ideas only work in an effective way when they’re made relevant to the outside world. The social web is extremely political: it imposes an opinion about how the world should be open and social, democratic and centered on individual preferences, but ironically doesn’t allow for differences in that point of view. That makes it very hard for late adopters, enterprises, governments and public organizations to feel the benefit.

Over on Persona Prime, Silona makes this point about technology-inspired government transparency:

Where is the change management?  We are doing some big stuff here and we are poised to make serious mistakes and I see no prelim work being done to prevent this.  Where are the best practices in open govt documents?  All I see are “I want” lists.  I have not seen us doing anything serious to ally [the fears of people who might be wary of transparency].

It would be cool if every Fortune 500 company wanted to be on Twitter, but the reality is that they don’t, and often for very legitimate reasons. If what we’re doing is establishing a new, global, decentralized way to create, share, disseminate and discover information, then we have to take into account the differences in all the decentralized nodes. Embracing different corporate cultures, and different opinions on how communication should be, is part of that. Compromising and addressing the fears of companies and late adopters will build a larger userbase for all our tools, and make the platform much more useful in the long run.

Related entries

• Building the user-centered web (8)
• Beyond the echo chamber (0)
• Top 10 blogs about the social web (1)

A few people here and there are trying. I watch what Chris Messina, David Recordon, Marc Canter, Joseph Smarr, Kaliya Hamlin, and a group of others are trying to do by pushing a more open web. Those are the kinds of efforts that inspire me and are inspiring Building43. Can we build on what they are trying to do and take it to main street?

Marc Canter is taking it a step further and moving to Cleveland, Ohio, in order to start a new company that helps create Digital Cities:

Where workforce development, content production and local foods meet in the valley of health care, medical digitizing and the history polymers.  Add to that some Seniors interviews, green jobs knowledge bases and authorized venues, community services and common constructs – and you have our project!  Oh yah – and a business directory of……

In both cases, they’re taking the ideas that the web community has created – open, democratic platforms for content agnostic collaboration – and bringing them to communities and people who might not have been exposed to them but could benefit in real, tangible ways. The message I’m getting is that the theory has gained momentum and is rolling into something great; now it’s time to bring it to the world.

And me? I’m in Washington DC this morning, talking with the AAC&U about how these ideas can be used in education.

Related entries

• Social networking: beyond the silo (2)
• Building the user-centered web (8)
• Adapting to the real world (1)

This isn’t, of course, meant to be the top 10 social web blogs ever – these are just some of the blogs that I keep coming back to regularly. (I had more that I dearly wanted to add, but don’t update quite often enough to be considered regular blog resources.) Everyone’s list is different, and equally important in itself; that’s the great thing about the social web.

Related entries

• Adapting to the real world (1)
• Pathdigger (0)

The iPhone 3.0 software update supports CalDAV, an open standard for sharing and updating calendar information. Luckily, so does Google Calendar.

It should really be easier than this; one of the important aspects of integration through open standards isn’t just its possibility, but also its accessibility. This feels more like a hack than real functionality – but at least it works.

1. On your iPhone, press Settings, and then Mail, Contacts, Calendars.
2. Press Add Account… and then Other.
3. Press Add CalDAV account.
4. Follow the instructions for enabling Google Calendar in Apple’s iCal. Specifically, this means using your Google account details for the username and password, and setting the CalDAV server name to be https://www.google.com/calendar/dav/YOUREMAIL@DOMAIN.COM/user.
5. I found that the iPhone didn’t pick up the authentication first time round – you may need to go into Advanced settings and re-enter them. The www in the server name seems to be important.

You can also do it using Google Calendar’s Exchange emulation, but that never worked for me. As with this, your mileage may vary.

Related entries

• Social networking: beyond the silo (2)

Have you ever looked at a piece of social software and thought, or worse, blogged, that it was worthless? Here’s a trick for evaluating social software in a way that isn’t going to make you look stupid six months down the road: assume it’s valuable if people are using it. Then try to figure out what value they’re getting.

I’ve lost count of the number of times I’ve heard people be dismissive about Twitter, or Facebook, or another well-loved web tool because they didn’t understand it. I’ve even been guilty of it myself – but it’s not productive. Much better to figure out why people love it and learn from what you discover.

Related entries

• Making the most of the web, right now (2)
• Learning on the social web (1)
• Twitter: lessons on getting your web app out there (3)

During the first year of the two-year study, student achievement increased 27.5 percent, according to Whithaus, who is principal investigator of a study to evaluate the project’s effectiveness.

Computer use – and particularly, online community engagement – increases engagement with formal learning, which is great news for the e-learning software market. But I’m particularly interested in the effect of networks on informal learning – specifically, learning from our activities on the web.

Learning happens when two sets of experiences and assumptions are exposed with each other – in other words, when we communicate. The web is the most globally efficient communications method the world has ever seen, and as a result, I believe, may rapidly transform our world culture for the better.

Last month, I met with J. Nathan Matias from the World University Project, a project that aims to evolve higher education by shedding light on how people learn and teach around the world. His intent is to highlight experiences that people in the west have largely not been exposed to, and in so doing advance mutual understanding between our academic systems. It’s a brilliant idea, which takes advantage of the potential of a universally accessible global communications network.

Recently, the Iranian election swamped Twitter, to the point where they rescheduled maintenance in order to minimize the effect on dissidents in the country. Suddenly, because Iranian dissidents were online and conversing with people from the west, Iran seemed less like a scary, far-off country filled with terrorists and more like – gasp – a country filled with actual human beings. Clay Shirky had this to say:

I’ve been thinking a lot about the Chicago demonstrations of 1968 where they chanted “the whole world is watching.” Really, that wasn’t true then. But this time it’s true … and people throughout the world are not only listening but responding. They’re engaging with individual participants, they’re passing on their messages to their friends, and they’re even providing detailed instructions to enable web proxies allowing Internet access that the authorities can’t immediately censor. That kind of participation is really extraordinary.

On a smaller scale, we’re now interacting with people from other walks of life, with markedly different sets of skills and interests, on a daily basis. The opportunity available to us is not just to get our message out on an unprecedented scale – but to get other peoples’ messages in, and in the process make ourselves more educated and informed than we’ve ever been. On a personal level, it can help us with our fourth grade homework; on a societal level, it’s a revolution.

Related entries

• Internet addiction and online learning environments (0)
• Building the user-centered web (8)
• Beyond the echo chamber (0)

In summary: Opera Unite uses the buzzwords of openness, without explaining why they’re useful in a way that makes sense for end users, and without actually being open.

The point Chris makes about users not caring about decentralization without having its follow-on benefits made clear resonates loud and clear with me. Here’s an interview where I talk about data portability and user control – two years ago. Nothing has changed, because nobody’s found a clear way to make this a marketable feature for end users. I’m beginning to think there isn’t one – which isn’t, of course, to say that I don’t strongly believe in the concept. It’ll allow for all kinds of new applications and push the envelope of what’s possible on the web, if we can find the business case for the steps in between.

Meanwhile, I’d love to post a counterpoint. Anyone want to write a post about why Opera Unite is awesome?

Related entries

• Opera Unite: a great idea, wrong center (7)
• Building the user-centered web (8)
• Social networking: beyond the silo (2)

While it’s impossible to judge at this early date whether it’ll “forever change the fundamental fabric of the Web” as Opera promised, it’s a very big idea. Web browsers have always been about bringing information from the Web onto a PC. With Unite, Opera 10 still does that–but it can also fling information from the PC up to the Internet. [..] It launches with some apps that Opera developed itself, including a file-sharing service, a chat room, a music player, a photo-sharing tool, and a note-taker.

Engadget has a video introduction to the application.

This is yet another entrant into the decentralized social web space, but it violates one of my key rules of web application development: keep the browser invisible. Here’s why I think this is important.

I own three computers – two Windows laptops and a Linux machine that runs Ubuntu – as well as an iPhone. All can access the web. At any given moment, I can be connected with any of these devices, depending on which is the most appropriate. For example, I use a 17” laptop at home, but if I’m travelling I’ll take my 12” model; when these are switched off, I might use my iPhone to quickly check something on the web or write a swift email. Additionally, sometimes I connect using other peoples’ machines, or computers in offices I happen to be visiting.

One of the exciting features of the web is that I can use my applications and access my data from any of these. Although I have my preferences as to which device I use, my applications and my data don’t care. They’re agnostic.

As soon as I require a particular browser to be used, I limit myself. I can only access this functionality from the devices that have it installed – which in the case of my iPhone or someone else’s computer is an impossibility. The Opera Labs announcement provides a pretty sound reasoning for decentralized, user-centric services:

Our computers are only dumb terminals connected to other computers (meaning servers) owned by other people — such as large corporations — who we depend upon to host our words, thoughts, and images. We depend on them to do it well and with our best interests at heart. We place our trust in these third parties, and we hope for the best, but as long as our own computers are not first class citizens on the Web, we are merely tenants, and hosting companies are the landlords of the Internet.

However, Opera Unite provides a different kind of centralization and locks us into a particular way of accessing the web. It still yields useful functionality but is a far cry from the cloud-based social architecture that most web application providers are working towards.

Update: To clarify, you don’t need Opera Unite to access services someone else is hosting using Unite. But then aren’t you only half-participating?

Related entries

• Opera Unite: divided (2)
• Building the user-centered web (8)
• Social networking: beyond the silo (2)

Yesterday, the BBC announced that they were using an open source framework called Hemlock in order to provide real-time web games on their Childrens’ site. Hemlock’s interfaces are built in Flash, but the real-time aspect is powered by XMPP. Developer Ron DeVera explained why over on the Hemlock blog:

XMPP is commonly used to enable chatrooms, like Gtalk or Facebook Chat. However, instead of just sending text, Hemlock lets you send all kinds of data at the speed of instant messaging. Even better, XMPP is designed to scale up and send data to many people at once, so you can push that data to multiple people in real-time.

In other words, it’s perfect for real-time applications on the web.

Traditionally, live web applications have used a development methodology called AJAX, which stands for Asynchronous Javascript And XML. In order to provide the illusion of a real-time application, the web browser needs to continue to ask the server if there’s any new data to ask, via a new AJAX request – which is a waste of bandwidth and resources both on the user and server side. XMPP, on the other hand, pings the client software whenever there’s new data.

Servers already need software to host and process dynamic web pages, as well as a database server to handle most types of user data. To use XMPP, you need to add an XMPP server to the mix – something that in the past was more fiddly than most people were willing to play with. However, times have changed, and ejabberd is free, open source and easy to install on Windows, Mac OS X and Linux servers. (I’m still at the early stages of playing with it; I’ll let you know how I get on.)

The XMPP community is still very small compared to the wider web, but developments like Wave and Hemlock should accelerate growth and interest in it. There are some interesting projects springing up, and lots of libraries available for XMPP development; XMPP programming is a skill developers should get in on now, before it really heats up.

Related entries

• Social networking: beyond the silo (2)
• Google Wave is exciting and transformative (4)
• WordPress Multi User and ad hoc communities (10)

Creating a new web tool, or adapting one for your own use, can be a bit like pitching a movie: a lot of people come to me and say things like, “it’s like Delicious meets Youtube, but for the iPhone”. That’s great, and can result in some very interesting ideas, but I think it’s always best to go back to first principles and ask why you need the tool to begin with. My post The Internet is People addressed some key points on this:

• Your tool must plug into an existing network of users, or be useful for user 1 (the first user to sign up). Delicious lets you save your bookmarks into the cloud; Flickr lets you easily upload photos so other people can see them. Both services come into their own when you connect with other users, but the core of the site is useful before you’ve done so. Facebook is different, but it had the Harvard real-world social network to plug in – and it now acts as a useful aggregation of your other activity on the web, which arguably is useful for user 1.
• You can’t build a site and assume people will come and use it. It’s a lot of hard work, even when the technology is ready for launch; you need to lead by example, constantly adding content and using the site as you would like it to be used. Not to mention the hours you have to put in promoting it elsewhere.

The feature set itself should be tightly focused:

As each tool should focus on one particular network, or at least type of network, I’d argue that the exact feature set should be dictated by the needs of that network. Educational social networks might need some coursework delivery tools; a network for bakers might need a way to share bread recipes. The one common feature in any social network is people; even profiles may not be entirely necessary.

I mention at the end of the post that these principles were the guiding ideas behind the design of the Elgg architecture. They’re now the principles behind the tools and strategy I develop for my clients.

In this blog you’ll find lots of talk about new technologies, innovative approaches and the ethics of social media. These allow us to build interesting new tools, but they always sit on a firm foundation: the Internet is just people connecting and sharing with each other, and the purpose of web tools is to make that as easy as possible.

Related entries

• Assume there’s value (2)
• User control on the open web (9)
• Social technology reinforces existing networks (1)

The rise of social networking

Social forces have been the driving force behind application innovation on the web. Whereas previously we might have looked to advances in computer science for new directions, now some of the most dramatically impactful applications are lightweight, simple, and technologically unimpressive. The best new web applications have centered around collaboration, sharing and discovery with other people.

Correspondingly, enterprises have been relatively quick to pick up on this trend, and software vendors have been quick to grab the market. In an Intranet Journal article earlier this year, Kara Pernice, managing director at the Nielsen Normal Group, had this to say about the rise of social technology on the intranet:

"In the 9 years [the Intranet Design Annual, which highlights the ten best-designed intranets of the year] has been coming out (since 2001), I’ve never seen a change quite as great as this one."

On the Internet at large, social network use is growing at ten times the rate of other activities and now accounts for 10% of all online time, according to Nielsen Online in this March 2009 report (PDF), and is now more popular than email. Jerimiah Owyang has a list of more relevant statistics over on this digest blog post. Executive summary: social networks are big, transformative in terms of how we communicate and share information, and growing at an enormous rate.

Monetization vs. collaboration

Wikipedia defines a “walled garden”, in software terms, as being:

[..] A closed set or exclusive set of information services provided for users (a method of creating a monopoly or securing an information system).

In other words, a walled garden is a system where the data can not easily be imported or exported. These are often also called data silos, after the solid buildings used for secure storage.

Facebook, the #1 social networking site in most western countries, has over 200 million users, including over 30 million who update their profiles at least once a day. The network is free to use, yet their revenue for 2008 has been estimated at around $265 million, despite a decidedly “in progress” revenue strategy.

This has traditionally required a walled garden strategy: the content that users put into Facebook has not been easily removed for export or viewing in other interfaces, in order to preserve revenue from advertising (and – although this is a hunch – revenue from statistical analysis of users’ data). It’s only been in the light of some extremely negative publicity (for example this February 2008 New York Times article) that they have begun to relax this policy and embrace the open direction that much of the rest of the web is heading in.

Speaking personally, I get more enquiries from people wanting to build something “Facebook-like” than anything else, presumably because of its phenomenal popularity. However, this kind of walled garden approach is not conducive to true collaboration; generally people who ask for this are lacking a full understanding of the processes involved in social networking.

According to Nielsen, there are almost 1.6 billion people online. While Facebook’s 200 million sounds like a lot, it’s actually a drop in the digital ocean – so what happens if I want to share a Facebook conversation with someone who hasn’t signed up? The only way is currently to email them a link and force them to register for the service. Facebook would love me to do this, of course, because they get more eyeballs to view their ads and more people to fill in profiles. But what’s the point of even being on the web if you can’t make use of the decentralized communication features that form its backbone?

If I want to collaborate effectively online centering around a resource (which could be a file, a discussion or a pointer to something external), I need to be able to:

• Share that resource with the people who need to see it
• Grant access for them to edit it if required
• Notify them that it’s been shared with them
• Restrict access from everyone else

Furthermore, I need to do this with the lowest possible barrier to entry. My aim is to collaborate, not to get people to use a particular piece of software. By restricting this process, the Facebook model hinders collaboration.

The open web

The web was designed to be an open system, and adheres to principles (notably “every object addressable”, ensuring that every resource on the web has a unique reference address) set out by Doug Engelbart for open hypertext systems generally. Because web pages are interoperable, and all use the same basic standards, any page on the web is allowed to link to any other page on the web, no matter who wrote it or where it is hosted. In many ways that’s the key to why the platform is successful: despite being fragmented across millions of computers throughout the world, it navigates like a cohesive whole and can be viewed using a single piece of browsing software. (The downside to this is that the whole platform lives or dies depending on the capabilities of the browser you use: the sad fact is that Internet Explorer users, who often don’t have a choice because of policy decisions in their working environment, are at a disadvantage.)

While the original web was content-based, the social web is collaborative and centered around live data. However, because web applications are each developed separately using different sets of back-end infrastructure, their data does not adhere to the principle of interoperability – their user interfaces all use the same basic standards and can be viewed in a browser, but the underlying applications and data models tend to not work with each other. When social networks emerged, for example, there was no way to get Livejournal and Friendster, two of the pioneers in the space, to speak the same language; you still can’t add someone as a friend on one social network from another. More recently, this has become apparent in the walled garden approaches of Facebook and others.

Not only does this situation create a bottleneck for application design, and run contrary to the underlying principles that made the web a success, but it’s also a bottleneck to better collaboration. As Tim Berners-Lee, the web’s inventor, put it recently in this essential TED talk, data needs to be linked and interoperable in the same way pages are now. Beyond that, because walled garden services are making money out of the private information we’re loading onto them, there’s a human issue regarding the overall control of that data. Marc Canter, Joseph Smarr and others codified this into a Bill of Rights for users of the social web back in 2007. Though the issue has moved on since then, the underlying principles set out there are essential for open, collaborative, social tools on the web.

While the World Wide Web Consortium works on academically-developed standards for linked data in the form of the semantic web, developers have been getting their game on trying to solve the problems of interoperability between their applications and user control over their data. Application Programming Interfaces (APIs) – published sets of instructions for programmatically querying and extending web applications – have become popular, but in a very walled garden kind of way. Arguably the most successful has been Twitter’s API, which has led to a number of high profile third-party applications like TweetDeck and Tweetie that collectively eclipse Twitter’s own website interface in volume of usage. But these APIs are their own form of walled garden: an application written for Twitter will only work with Twitter, for example. The APIs are not generalized between applications, and as such are not truly open; in many ways they’re a way for services to get more functionality and reach for free.

One of the first attempts to publicize the benefits of truly open data was Marc Canter’s Data Sharing Summit, which I wrote about at the time for ZDNet. Chris Saad’s DataPortability.org attempted (largely successfully) to brand it, and latterly the Open Web Foundation has attracted some of the web’s leading lights in order to create a single organization to handle the creation of a set of open web application standards. Many of these comprise the Open Stack, which I’ve written about before; more generally, Chris Messina has written a very thoughtful overview on the topic.

Fluid collaboration

It used to be that to use the web, you would need to sit down at your computer and log on. Those days are over; the web is becoming more and more ubiquitous, thanks to devices like the iPhone. It’s also being integrated into software that wasn’t previously connected – it’s as easy, for example, to paste the URL of an image into the ‘Insert Image’ dialog box in most word processors as it is to pick an image from your own hard disk. The open, generalized API standards being created by groups like the Open Web Foundation bring us closer to enjoying that level of integration with collaborative social technologies.

The Internet is people, not technology: tools on the web (or anywhere else) facilitate social networks, but are not the network themselves. Currently they consist of destination sites, like Facebook, LinkedIn or Twitter – places that you explicitly have to visit in order to collaborate or share. This is the currently-fashionable model, but it’s a necessarily limited view of how collaboration can take place: all of these sites thrive on the walled garden model and are designed around keeping participation within their walls.

Not everything on the Internet works this way. Email, and increasingly Instant Messaging, are two technologies that generally do not: messages on email, Jabber and to a much lesser extent Skype are peer-to-peer and do not go through a central service:

1. You select the people you wish to collaborate (in this case, email or chat) with. Nobody but the listed recipients will be able to see the content you share with them, and it doesn’t matter if they’re using the same service as you; you don’t have to invite them to join email in the same way you have to invite people to join Facebook.
2. You write your content.
3. You send it.
4. They (hopefully) send content back.
5. The collaborative exchange lasts only as long as it’s useful, and then disappears (but is archived for reference).

Recently, Google announced Wave, a decentralized pairing of protocol and open source web application that took email and IM as its inspirations to redefine how collaborative social technologies could work. Questions have been raised about how a decentralized tool like this can work with corporate data policies present in most large enterprises and public sector organizations, but in some ways they miss the point: Google Wave is best thought of as a proof of concept for how decentralized, transient communities can work in a standard way on the web. In short, websites are a kind of walled garden in themselves: what we will return to is the idea of the web as an open patchwork of people, data and information that links together to form a whole, much stronger than the sum of its parts.

Predicting the future of social networking on the web is hard. However, I believe that as general open social technologies develop and become more commonplace, the “social networking site” will shrink in importance – instead, social network facilitators will become more and more ingrained in all the software you use. This will dramatically increase the types of content and communication that can be used, and present opportunities for much wider, more fluid and – most importantly – more productive collaboration as a whole.

Related entries

• Building the user-centered web (8)
• User control on the open web (9)
• The Internet is People (3)

Of course, Automattic also own Andy Peatling’s BuddyPress, which is fast becoming a solid competitor in the open source social networking market. I’ve seen people have some installation difficulties with it (it’s apparently been simplified to a 13 step process), so it would make some sense to include it as an optional piece of functionality out of the box. But most importantly, I think there’s a change in progress, illustrated by the Google Wave announcement yesterday but not represented in this announcement.

Communities are forming around users, not users around communities.

In the web application model we’ve been using for the last fifteen years or so, you would install a piece of facilitative software in order to create a web community. That might be forum software or Microsoft Sharepoint depending on needs and context, but they’re both centralized communities. The user visits them to log in and participate; users swarm around a single community access point.

However, consider Skype. It’s not a web tool, but it’s often considered to be one of the new breed of applications. When you want to share something here, a community is automatically created between users, who can then have text discussions, call each other and share files – not dissimilar activities to those you might find on centralized communities like Sharepoint, but with the following advantages:

• It’s transient: there’s no need for the community to exist for longer than it has to.
• There’s no effort involved. Once you’re done with a community, you simply close the communication (but a backup is typically kept, so you can come back and reference the activity).
• It’s private: it’s very hard to share activity with the wrong people.
• It’s decentralized: the community is physically hosted between all the involved parties.

Google Wave also shares all these characteristics, and we’re going to see similar functionality crop up in a host of applications over the next year or two. The reason is simple: it’s a better way to communicate communally.

Of course, blogs are usually public entities, and in that sense WordPress Multi User does its job. But it’s tough keeping track of comment discussions, and there’s no elegant way to have a private, communal blog – something that intranet software needs and that tools like Elgg have done very well for years (disclaimer: I co-founded it). But even that sticks to a centralized model, and eventually, those ad hoc, transient communities are going to be everywhere. It’s going to be interesting to see how tools like WordPress evolve to cope.

Related entries

• Social networking: beyond the silo (2)
• Building the user-centered web (8)
• Elgg 1.5 (2)

Google just released it.

Damnit.

In all seriousness, Google Wave, and particularly the Wave Protocol, have the ability to completely change how we communicate on the Internet. That might sound a little over-enthusiastic, but so far the project seems to be getting everything right. It’s distributed, extensible, granular (as public or private as you want) and open. There’s been some talk about the interface for their sample client being a little cluttered, but the team are at pains to point out that it’s in the early stages – and this misses the wider implications of the technology.

I’m not the only one talking in superlatives. Tim O’Reilly points out:

Suddenly, familiar applications look as old-fashioned as DOS applications looked as the GUI era took flight. Now that the web is the platform, it’s time to take another look at every application we use today, and ask the same question [project founders] Lars and Jens asked themselves [with email]: "What would this look like if we invented it today instead of twenty-five years ago?"

It remains to be seen how the project will develop, but I’ll be paying very close attention.

Related entries

• XMPP: powering the real-time, really live web (9)
• Social networking: beyond the silo (2)
• Building the user-centered web (8)

There’s a new kind of web development afoot, which marries old-school object-orientated programming techniques with the distributed power of the web.

Application Programming Interfaces (APIs) are published sets of instructions for programmatically querying or extending a service. For example, the Google Maps API allows anyone with some development skills to build applications based around Google Maps; the Twitter API allows anyone to build an application that lets you interact with Twitter (like Tweetie or Tweetdeck). The act of allowing anyone to do this is generally thought of as being “open” – as in, open to anybody. While that’s true, in another sense they’re very closed.

The trouble is, if you write a microblogging application using the Twitter API, you’re locked into Twitter. If you want to write an application for another microblogging service, you have to use their API and start from scratch again. The formats produced by each service’s API are proprietary, as are the methods to query them. They’re incompatible with each other by design, because those services don’t really want you moving users’ data around between them. They want users to sign up with them and then stay there – a great proposition for the service, but a lousy one for the users, who have no real way of importing or exporting the content they’ve created.

Furthermore, there are some situations where this one-API-per-service model breaks down completely. Let’s say you’ve joined a social network and you want to check to see which of your friends is already there. The service provider could use a Gmail API to check your address book, but some users will use Hotmail for their email, so they’ll need to use the Hotmail API as well. Repeat for Yahoo, and every single email provider under the sun – there’s no way anyone could possibly write this feature without a generic API that works across all services.

Enter the Open Stack, which is a set of generic APIs designed to provide common tasks:

• eXtensible Resource Descriptor (XRD): allows an application to discover resources and APIs relating to a particular page (for example, an application could check a user’s profile page and discover that they have an OpenID). There’s no point in having open APIs if an application can’t find them, and XRD fills this gap.
• OpenID: allows anyone to log into any service that supports it using the same digital identity (potentially linking that user’s accounts on those services together). A Wordpress.com ID is an OpenID, for example; you can log into any OpenID-compatible site with it.
• OAuth: a way to authenticate access to API-based services without forcing the user to present their username and password for that service. Previously usernames and passwords were passed in order to authenticate APIs, which led to serious security issues. Here a user can easily and securely grant or deny an application’s access to their data. OAuth can also be used to apply granular access controls to a piece of data.
• Activity Streams: a way to broadcast your activity on each service (for example ‘Ben has published a blog post’, a la Facebook’s river) so that it can be aggregated at a central point.
• Portable Contacts: a simple way to transmit collections of contacts, like email address books and lists of friends, between services.
• OpenSocial: provides a framework for hosting remote application widgets on a service.

In programming jargon, a stack is a specific data or platform structure; actually, this is more of a pile of useful technologies that can (in part) be used together.

These generic APIs allow for a more distributed kind of web application. Suddenly, instead of writing support for a particular function from scratch, you can pick up an existing code library and slot it in. You can interact with any service that supports them without writing any further code.

However, there are some unresolved issues that need to be discussed. One major headache is the privacy implications. If I sign up to BensFabApp.com, I agree to the terms of service and privacy policy there. However, behind the scenes it might be accessing the APIs for AppOfEvil.com, which has a very different privacy policy and terms and conditions. How does that second set of terms and conditions apply, and what’s the legality of passing a user’s data across two services with two different sets of terms, when the user only knows about one of them?

A second issue is a user’s control over their data. When BensFabApp.com sends data to AppOfEvil.com, it may get cached and duplicated. What happens if I delete the original data on BensFabApp.com? So far in the open stack there is nothing to handle deletion of content. It’s a fair argument that when something is published publicly you lose control over its distribution; however, if access has been limited using OAuth or another method, there’s no way of reaching out an ensuring its removal from every system it’s been sent to. That would be fine if the data had been sent to another person or application with the user’s express permission, because they’ll be aware of the implications. However, if it’s been sent completely behind the scenes, they have no way of knowing that it was sent to begin with.

These are issues with any API-based service, but generalized APIs are likely to be used more frequently. Solutions to all of these problems will be found, but it’s important to note that they’re not there yet – which serves as a warning to applications developers and an opportunity for anyone who wants to step up and provide them. As this kind of open API becomes commonplace, new kinds of web applications will begin to emerge as developers spend less time reinventing the wheel and more time innovating. It’s just one of the things that makes the web as a platform so exciting to work with.

Related entries

• Implementing open standards is too hard (0)
• The mechanics of "open" (1)
• User control on the open web (9)

On a not-entirely-unrelated note, I want to make you aware of GlobalVoices Advocacy, which aims to create a global anti-censorship network of bloggers and online activists in the developing world. This is important work; one of the really exciting aspects of the web is the way information can spread and undermine oppressive legislation. It’s also dangerous, as blogging in places where freedom of speech is not protected can have severe consequences. They provide tutorials on blogging anonymously, as well as blogging effectively for a cause.

Zemanta, a blogging tool that suggests content to include as you type, is offering a small funding award to the charitable cause that gets the most posts as part of their ‘blogging for a cause’ promotion. It’s a good idea, and if you like what GlobalVoices Advocacy do, maybe you could write about them too – or any other good cause that you think is deserving.

I vote for Global Voices Advocacy because freedom of speech and the fight against censorship is one of the most important fronts in the fight for human rights around the world. This is a fight that we can all participate in, without having to go through governments, and GlobalVoices Advocacy is one organization that shows us how.

This blog post is part of Zemanta’s "Blogging For a Cause" campaign to raise awareness and funds for worthy causes that bloggers care about.

Related entries

• BarCamp Transparency (2)
• Notes from BarCamp Oxford (5)

• Web references: page
• Web references: site

To use them, drag each link to your browser toolbar. This will create a couple of buttons that you can click when you want to find more information about whatever page you’re looking at; the first checks the full page URL, while the second just searches for the domain name of the site.

At the moment both open Google Blog Search and Twitter search as tabs. If you have suggestions for other searches I could add, let me know and I’ll update the code here.

Most Commented Posts

• Gender differences on the new frontier (21)
• End of an era, start of a new one (15)
• WordPress Multi User and ad hoc communities (10)

Visual poet: “That’s pretty cool, but what about visual poetry? You know, that Fluxus kind of stuff? Because you can’t really separate that into stanzas.”

Standards geek: “Hey, you’re right. I’d better create a new element for visual poetry.”

Visual poet: “Awesome. Thanks, man; now I can represent my visual poetry using your standard.”

Spoken word poet: “Hey, that is awesome. But I don’t have any way of representing my poetry, which is all spoken. I don’t write it down at all.”

Standards geek: “Good point; I don’t have anything for spoken word poetry. I’d better create a new element for that.”

Performance poet: “While you’re at it, could you create a sub-element for performance poetry? We’re like spoken word poets, but we also sometimes use music and elements of theater in our performances.”

Standards geek: “… Okay, I’ve added some new elements that represent performance poetry.”

Haiku poet: “Could we also have something for haiku? Although haiku can be thought of in stanzas, it’d be useful to draw out the kigo and the kireji and represent those explicitly. Also, haiku can be drawn as a line of Japanese characters or as three lines of Latin text, and it makes a difference to the overall interpretation of the verse.”

Standards geek: “I don’t really know what those are, but I’d like to support haiku, so okay, they can go in.”

Linguist: “This standard is only going to be useful to me if I can add interpretations to a poem, and group poems together to make a themed collection.”

Other linguist: “And I’d like to comment on other peoples’ interpretations so I can tell them why they’re wrong.”

…

Standards geek, two months later: “Okay, I think I’ve got every major representation of poetry that everyone’s asked for. We’re ready to lock down the spec and build some libraries for initial testing. The only problem is, the specification is now seventy-two pages long, so that might take a while.”

Kinetic poet: “Sorry, I just got here. Can we add a marquee tag?”

Photo by surrealmuse, released under a CC Attribution-Noncommercial-Share Alike license.

Most Commented Posts

• Gender differences on the new frontier (21)
• End of an era, start of a new one (15)
• WordPress Multi User and ad hoc communities (10)

Although I left to pursue other projects last month, Elgg is close to my heart. I headed technical direction through Elgg version 1.5 (the most recently-released version), co-founded both Elgg and Curverider, was co-author of Elgg’s vision and ethos, and remain a major shareholder in Curverider. As a result I’m absolutely delighted about this state of affairs, which should allow the project to realise its commercial and technical ambitions.

Most Commented Posts

• Gender differences on the new frontier (21)
• End of an era, start of a new one (15)
• WordPress Multi User and ad hoc communities (10)

In keeping with the rest of Oxford, it’s suddenly begun changing dramatically over the last couple of years (I’ve joked a couple of times that someone at the City Council planning office must have died, but this may not be too far from the truth; despite a glut of brilliant minds and genuine creativity, the city itself has always been stiflingly conservative). One of the newcomers is The North Wall, an arts centre that actually sits a few doors down from that first Curverider office on South Parade, and is in some ways more exciting than any other arts space in Oxford. From hip hop comedy dance to puppetry, its events seem to bring new blood.

Ben’s Big Gig was probably the first gig of its kind. Ben Walker is Internet famous for his Twitter Song, an in-joke that, appropriately enough, has been bookmarked, re-tweeted and blogged all over the web, and attracted praise from the likes of Demi Moore. He’s also a genuinely talented songwriter and musician who has been playing around Oxford for years at various events, including a regular stint at the now-defunct QI Club (which was associated with the TV show of the same name). Together that was enough to sell out the arts centre, as well as attract hundreds of visitors who watched live over the web – Nick Gill’s gorgeous lo-fi poster, pasted up all over town, couldn’t have hurt either. A Twitter wall on the back of the stage read out feedback as it happened, forming a back-channel to the music and allowing the audience to heckle the comedy warm-ups with relative safety. All of this felt not like a technological gimmick, but an organic part of the experience.

Live web gigs happen all the time, but they’ve usually got major backing. Sandi Thom was famously discovered through webcasts, but it was a PR stunt: she already had a major publishing deal, and at the time the streaming technology would have cost tens of thousands of dollars. Times have changed: although it’s probably not free, technological improvements have brought live streaming within reach of independent artists. Ben’s the real deal, a performer with old-school talent who just happens to be using contemporary tools to reach his audience. We’re going to be seeing much more of this.

However, the first-mover advantage definitely holds water. At the end, as I was leaving, I told Ben that he needed to do it again. He confirmed that he will; I suspect the audience will be even bigger next time.

In the meantime, here’s the video feed from the gig:

The delightful picture of Hugh Fearnly-Whittingstall was released under a CC attribution license by Ben Walker.

Most Commented Posts

• Gender differences on the new frontier (21)
• End of an era, start of a new one (15)
• WordPress Multi User and ad hoc communities (10)