What Is The Point Of Building A System To Manage Another System?

to-do-list.png

Sunday, 8.59pm

Sheffield, U.K.

A bad system will beat a good person every time. – W. Edwards Deming

There are certain laws in the Internet world.

One of them, Godwin’s Law, says that as an online discussion grows longer the probability of a comparison that involves Hitler or Nazis approaches one.

Another, Zawinski’s Law, says that every program tries to expand until it can read mail.

These laws are really an observation of the side effects that seem to happen to things over time – whether they are discussions or programs.

And one that I’ve been mulling over recently has to do with getting things done.

If you’ve read David Allen’s book on the subject you’ll know that he has a process – collect everything, pull out next actions and manage them in a system.

There is no shortage of todo list applications. Microsoft Project, for example, is really a todo list app that has a lot of stuff in it.

What I’ve found over the years is that aiming to get things done is pretty easy when you don’t have much to do.

Early in your career, for example, all you really have to do is get your work done – so you can track and manage everything and work a system that works.

But as you get older the problems of scale come up.

What happens when you have to manage life itself – all the things you have to do that revolve around kids, getting your house sorted, managing relationships, growing your business, looking after your property rentals and a host of other things.

Quite soon you can find that things make their way onto your list faster than you can strike them off.

It’s a peculiar problem that has to do with affluence.

Take your house, for example.

If you have young children the chances are that a new thing made of plastic enters your house on average every day.

At the end of a year, you probably have 300 odd things in your house that weren’t there at the start.

When your kids are 10, that’s closer to 3,000 – at which point you’ve given up any hope of ever getting rid of any of that stuff.

It’s sort of like that with todo lists that grow and grow.

One way to deal with the whole thing is to just ignore your list.

Some people start a new list every day – trusting that if something important is forgotten you’ll be reminded by someone or something else.

But if you do try and manage your list you’ll quickly realise that while life is lived one day at a time you need to hive your actions into a separate system – your todo list.

And now, you have that list to manage – and unsurprisingly, over time, that list can get stale and out of sync with what’s actually happening in your life.

This may seem a little pointless as a discussion – but here’s the thing.

We often think that we have to manage things for them to work.

But the best things don’t need managing – life itself – for a start.

Most living things go about their business without thinking of their todo list – they are self-regulating systems.

Humans are the only ones with this urge to have a system to manage another system.

And so a design principle for managing a system should perhaps be that it should be self managed.

For example, if you write stuff in a diary throughout the day and take notes of actions, you should be able to manage the actions in your diary without having to put them into a new system.

Practically, that is really a simple job of searching and replacing.

Search for action items that are marked as such – perhaps with brackets.

When you’re done, put an x in the brackets and don’t show them in the search any more.

You could do this with text files and around 3-5 line of code.

In Linux, for example, you could put each action on its own line starting with [] and find every instance with a command like look [] file.txt.

A trivial way of pulling out the actions.

That means your notes and actions are part of the same system and managed in there – more self management than anything else.

Or you could build or subscribe to an application – which is probably going to be more complex that requires you to manage two systems and that will eventually fall out of sync.

Like every CRM application out there.

Yes you can manage it with effort – but wouldn’t it be nicer if it was self-managed and didn’t need effort?

But building a simple system is often an order of magnitude harder than building a complex one.

And that’s because you often need to build the complex one and live with the pain of using it daily until you realise – in a flash of enlightenment – how to make it simpler.

But no one said the path to enlightenment was easy or straightforward.

Cheers, Karthik

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s