We'll see | Matt Zimmerman

a potpourri of mirth and madness

Toward a free web

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?


Written by Matt Zimmerman

September 14, 2008 at 19:51

Posted in Uncategorized

Tagged with ,

4 Responses

Subscribe to comments with RSS.

  1. Yes, there is a double edge for making LaunchPad.net open source. :-)

    Dread Knight

    September 15, 2008 at 00:18

  2. A major obstacle to free trade is free pathways. You may be aware of the flap over Google’s original TOS for Chrome. The TOS demanded one “give Google a perpetual, irrevocable, worldwide, royalty-free, and non-exclusive licence to reproduce, adapt, modify, translate, publish, publicly perform, publicly display and distribute any Content which you submit, post or display on or through” the browser.

    This is “standard” wording for many online services. After many gripes, Google changed the words for Chrome, but the words persist for Google Docs, Bookmarks, Apps, and various other Google Services. We may “trust” Google to “do no evil” but the “opportunity” (at least legally) persists.

    Similar TOS wording is enforced for e.g., WordPress. Creators of online materials should not have to accrue the right to “adapt and modify” their works, forever and ever, world without end, in order to use online services. (I am certain Google will not allow us to “adapt and modify” the Google corporate logo!) This will continue to get in our way.


    September 15, 2008 at 02:16

  3. […] Zimmermn: Toward a free web. With the move toward web-based applications, although that’s not an entirely new thing, […]

  4. It’s actually the other way around. As you point out, running web services costs money and for many such services it’s not attractive to decentralise them – now that is *exactly* why there’s no reason to worry about giving away the code that runs these services.

    Take your example of Facebook: nobody would attempt setting up the same shop at another domain, because they wouldn’t stand a chance – after all, if Facebook uses something like an Affero license, whatever fancy extensions you come up with they can then take back, too. I even don’t think someone would manage to set up an ad-free version – how would that pay for itself?

    Users might however “scratch their itches” and fix whatever bug is in their way, or they might try to get extensions accepted into the project. In addition, users would have the comforting feeling that they *could* in theory set up a community server – think of it as a backup for the hypothetical situation that Facebook would go bust. It’s a win-win situation.

    An interesting thing is that you do of course need to be big enough for this principle to kick in. Facebook has reached a user base that would allow them to do this without fear of, say, AOL taking their code and setting up a more popular equivalent. That’s why I think it’s smart to keep Launchpad (sorry to bring that up, but actually Dread Knight did :)) under covers for a couple more months.

    Maybe a nice “standard practice” on the web would be to release new web services with a EULA that promises the user to hand over the code to them at a set date in the future. If by that date you didn’t get big enough to be protected by above principle – well, then you didn’t have a good service anyway….


    September 17, 2008 at 17:28

Comments are closed.

%d bloggers like this: