We'll see | Matt Zimmerman

The web is no longer just a collection of sites one can visit with a browser.  It’s increasingly a rich set of programming interfaces upon which applications can be built.  This, at a technological level, is very good news.  Interfaces make possible a greater variety of applications.  This is an old idea for software in general, but a relatively new trend on the web.

Application cooperation

Remember when desktop programs didn’t talk to each other?  Incompatible file formats, proprietary development, primitive multitasking features and monolithic design kept each program in its own silo.  Each one was only as good as what came in the original box, and if you wanted to do more, you had to look for a better program.  Usually, the one you found, with just the right feature you needed at that moment, was missing several others you couldn’t live without.  Power users would keep several different programs for doing different variations of the same task: one word processor had a great macro facility, while the other had beautiful fonts or could open the right file formats.

Proprietary systems were evolving toward a more cooperative model in the 1980s, when technologies like DDE enabled applications to work together in meaningful and standard ways.  Although its capabilities were limited, the benefit to end users was substantial.  There is of course a lot more which has happened in this area since then, but meanwhile, the modern free software movement has brought .  A free program could be improved to add “just one more feature” which would otherwise have required searching for (and perhaps buying) a completely different program.  Sometimes, new capabilities could even be “lifted” from one program to another, or shared as a library between multiple programs.  An improvement in one program could benefit other applications as well.

In short, free software programmers were no longer fundamentally limited by their own time and skill in writing programs: they could build on the work of others.  The programmable web, in some ways, promises even greater opportunities to do this.  The explosion of web APIs, and applications built on them, speaks for itself.  However, this freedom is in some ways more reminiscent of the limited power of proprietary application systems than of free software.

Open interface, closed application

Most web APIs seem to be open for use by anyone, within reasonable limits.  Given that they are, in effect, licenses to use someone else’s computing resources, it’s necessary to regulate their use, and appropriate to charge for the service.  However, non-trivial applications built on them are usually not themselves open.  This means that while application programmers can benefit from the availability of the API, they can’t build on each other’s work.

I can use the API to create a new application, but I can’t use an existing application to make a better one.

Open interface, closed implementation

Similarly, the backend software which provides these useful interfaces is usually proprietary.   Sometimes, this software is in fact free, but the API provider chooses not to share their version, sometimes exploiting a loophole in copyleft schemes which would otherwise require that it be shared.

I can use the API to create an application, but I can’t use it to build a new and better interface.

Developer freedom

What would be the characteristics of an online software ecosystem which promotes innovation at the same level that free software has done?  There are those who say that freedom on the web is about data: who owns the data, and what can they do with it?  These are interesting questions, but I’m more interested in how to promote the development of more and better software, and I think data is only a part of that picture.

A free web, to me, would support innovation through building on existing APIs, backend software and applications.  Everything new which was created would create new possibilities for further development.  The four freedoms largely apply, and for largely the same reasons.  The free software concept is not a complete solution, though, and needs to be adapted significantly for this purpose.  I can think of a few obstacles:

Copying software is virtually free, but providing a web service is not. One of the key benefits of online APIs is that they’re consistently available at a globally addressable location, and that requires high-availability hosting services.  Some providers, like Google App Engine, already offer a basic hosting service for free, but I think these are more likely loss leaders than sustainable free services.

Similarly, many interesting web applications, particularly “user-created content” sites, would be less interesting if they are decentralized.  When the data is fragmented, the overall system becomes less valuable.  Imagine if Facebook were free, and there were hundreds of smaller, specialized Facebooks rather than one large one.  The very thing which makes Facebook interesting (the ability to connect to other people in a variety of ways) would be significantly diminished unless these different instances were connected.  In order to support decentralization, applications need to share data. Unfortunately, building such applications with today’s tools is complex and difficult to get right.

What else is different?  What stands in the way of software freedom for the web?