intelligent software, stupid software, and Unix-philosophy software

I had some experiences with some spectacularly bad software over the past few weeks. BMC Software markets this confusing ball of stuff, with some internal boundaries I don’t understand well. My interface to it at work is called Remedy–it’s how I make requests for stuff like a server to run software on, or an account on a new system.

It has some intelligence, or tries to. There are ways to route requests. How do I get this thing I need from the Company? Well, it comes from some part of the company, and the software assumes you don’t know where that part is, and it gives you a few abstracted ways to specify that. Sometimes it grabs it out of your description of the problem you want to solve.

Or, you know, tries to. In practice, you do know where things come from, or have ways of finding out, so you make your request, you email the relevant person with the request number, they go in and correct whatever mistakes you or the system made so the wrong people don’t receive it and cancel it and they get credit for the work, and then they get to work.

Anyway, I was struck by how poorly this works, and I reflected on my experiences with using intelligent software. There seems to be a continuum of intelligence:

Highly intelligent software: Google is the example that comes to mind. It spell-checks my most obscure searches, and can tell if I want to do a search or convert between units. Its intelligence makes it easy to use, like having an assistant. It also gives me the option of bypassing its intelligence.

Stupid software: the BMC example above seems to fall in this category. As does Clippy, Microsoft’s intrusive office assistant thing that popped up and annoyed you, before Microsoft woke up and killed it. As does Microsoft Word’s document formatting, which I find infuriating. I often spend more time battling it than I do writing my damn document.

Unix-philosophy software: software that relies on the intelligence of the user. It’s not trying to be intelligent. It assumes you are, and gives you tools to do what you wanna do without getting in your way.

The Unix command line is the canonical example. Unix tools like grep, find, and sed are examples of tools that do particular things, do them reliably and predictably. They put a burden of expertise on the user, but they make sense. The boundaries between what grep and find do make sense. The way they talk to each other makes sense.

As complex as they may be, they serve a powerful philosophy: simple tools that work together to accomplish complex things. Pieces of a puzzle that has a sensibility behind it. A consistency that allows you to make predictions about how they work, even if you don’t know their function exhaustively.

They eschew intelligence, by design. Grep knows what you can tell it, on what terms, in what language. Grep knows what you do tell it when you invoke it. It knows what the end of a line of text in its input looks like. It knows little else.

Wikis probably belong in the same category. They are simpler than Unix command-line tools, arguably better designed, but they do exactly what you tell them to. And you can integrate them with other tools in all kinds of interesting ways.

The intelligence here is also in the designer: not just in anticipating my needs, but also in an appreciation of the limits of their understanding, and the thought to give me power in flexibility.

Google, on the other hand, knows a great deal. Google sits on one of the biggest piles of data, if not the biggest, in human history. Google is actively analyzing that data, pulling intelligence out of it, making it useful.

And Microsoft? When Microsoft Word screws up the formatting of my spec, once more, there’s no way for it to learn from my frustration. There’s no accumulation of information. It thinks it knows what I want, and it’s usually wrong, and there’s no way to train it. Which is why I hate using it.

So we see a distinction between software that is stupid and software designed with no pretense of intelligence in the first place. And we see what it takes to make software that is intelligent: software that can collect information and learn from it. Whether or not it is using a process behind the scenes that humans would describe as ‘intelligent,’ the effect is the same.

It’s awfully hard to do that well–Google spends billions on making and keeping their one-line entry tool smart. It’s also difficult to make intelligently designed, powerful yet simple tools, that talk to each other in useful ways. I don’t know how much Microsoft spends making their document formatting engine, but I have a feeling most of it is wasted.



Leave a Reply

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

You are commenting using your 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 )

Google+ photo

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

Connecting to %s