Independent web principles

Posting my list here, because putting them on Twitter only would just be too ironic:

1. Keep the master copy of all data you create in a way that nobody can prevent you from keep using that data

For example, if I write a beautiful poem on Gmail (it is Valentine’s day after all), Google can prevent me from accessing this poem in the future, e.g. by kicking me out. It hasn’t happened to me, but it has happened to others. Which is why I use gmail only as a glorified IMAP server; my primary copy of all incoming and outgoing e-mail is on the hard drive my laptop.

I’m not doing as well on social media posts, although I create most of my posts here on and syndicate them out to Facebook and Twitter via the WordPress Social plugin. That plugin has its issues, though, and it takes more work than I’d like.

2. Be at liberty to run whatever code you choose against your data. No lock-in between data and code.

For many years, Microsoft kept a tight lock on the data format for Word and the other Office apps. While you could keep the master copy of all your files under your control (see principle 1), it wouldn’t help you because only Microsoft software could read them. So the data has to be available in a format that does not force you into a particular vendor’s product.

Even so-called “open web” products have this flaw: what good does it do me if I can export all my data from Facebook, or Google, or whatever, but then there is no software that can read any of this in any meaningful way? It forces me right back into those silos. So we need alternatives for code that can read the same data, and we need to have the ability to develop new code that runs on our data.

3. Don’t depend on somebody else’s terms of service that might change over time against your will.

Imagine you have control over your data, and you can run all sorts of software against it, but then somebody comes by and somehow prevents you from doing it the way you thought you could. The primary avenue of doing this would be changing legal terms without your consent. For example, a patent might suddenly show up that you infringe if you keep doing what you have been doing, or, some product you are using might suddenly start selling your data to others because you agreed that they could change their terms of service in the future, or the license fee might double.

You don’t control your own destiny if these kinds of things can happen.

Personally, I think the best answer is:

  • Keep your data in open formats.
  • Primarily access your data with open-source software; closed-source might be okay if there are open-source alternatives;
  • On hardware that you have physical possession of, or that you could move to at any time.

Other models may be possible, but this one works, and that’s what I’m trying to do for myself, and for users of the code I create.