Software Development

In my recent article Good Service—Bad Software, I made a stink about why open-source software is inhumane and unusable. To all those who read this and thought I was flaming, sorry, I really messed up there; my article sounded like a flame. As some commenters suggested, there are some excellent examples of humane interface design in the open source world. I know that there are forces for good in the open source world; among them, contributors who are unpaid and simply want usable software for their own use. I know that there are people, both in the companies I seemed to be accusing and outside of them, that try to make free and open source software usable.

So I asked myself: why on earth did I actually write this article, when I knew it was going to incite flames? What makes me so passionate that I feel the need to write articles like this? Because, well, software stinks.

Software Stinks

I’m talking all software. Not just open source software; not just free software; not just cheap software; and definitely not just Windows software. To be explicit, for those of you sitting behind your pretty white (or black or brushed-titanium-effect) screens, I include Mac software. As a full-time Mac owner and user, I state that Mac software is awful in some ways; it’s just more consistent in the ways that it is awful.

Don’t believe me? Okay, then try this on for size: Try to write one-page instructions for configuring HTTP proxy settings on a client computer. Those of you who don’t know what I’m talking about, don’t worry, you’ll get the idea in a minute. Suffice to say that “configuring HTTP proxy settings” is something that has to be done surprisingly often in order to make the Internet work on people’s computers.

At first, you will laugh, and scribble down instructions for how to do it Firefox in four or five sentences.

But then I will say: “Those only work on Firefox 1.5 on the Mac.” So you go to the trouble of looking up Firefox’s historical methods of setting this information, and take screenshots on Mac, Linux, and Windows versions of the software for Firefox 1.0, 1.5, and 2.0. There are just enough differences to confuse non-programmers (who will be reading this documentation, make no mistake) unless you make separate instructions for each of these cases.

And you might still be inside of one page. At which point, I’ll say: “Okay, now add instructions for IE, versions 5.0, 5.5, 6.0, and 7.0. Oh, and make sure that they work on Windows 95, 98, 2000, XP, 2003, and Vista(s). Oh, and try to make sure you include instructions in case the person is running Mac IE 5.5 or earlier. Oh, and make sure you don’t confuse the user about proxy versus auto-proxy.” And I haven’t even mentioned the rest of the Linux and Mac browsers. Or all the software out there that uses the Internet but isn’t a web browser. Or if there is a system-wide way to do this on Linux or BSD systems, it will vary (possibly wildly) with your favorite distribution flavor.

Get the picture? This is one task. It is a very simple task, in that you have three short strings you need to enter into some text field or config file somewhere. For many users in the world, you must perform this task to get your computer to do what you need it to do. And the software out there fails.

Okay, if it was simply the case that you needed a giant look-up table from system-type to the instructions, and those instructions were simple, this wouldn’t be so bad. But imagine trying to tell a user to figure out what version of Internet Explorer they are using, when they only know it as “that link on my desktop that I click on to get to my Yahoo mail.”

How do we make it better?

I’m not talking about how we make any one piece of software better. Ask one of the Raskins; ask Joel Spolsky; ask Don Norman; ask any of the couple dozen people who have been banging the drums about actually using the concrete facts of cognitive psychology and the principles of designing for low error rates, comfort, and ease-of-use. They can tell you a lot about how to make your software interface better. There are definite tools for making any given interface better, and measuring how bad it is.

But the tools are not being used! My questions is not how we make software better by better design; that’s Aza’s field. My question is: how do we make software better by actually getting better designs implemented?

That’s why I wrote my prior article about software and the service-driven economy. After I published that article and watched people’s reactions to it, I realized I failed. All I did is talk about the problem. Sorry about that.

Watch for more

Over the last couple years, we’ve been doing a lot of reading, a lot of interface design, a lot of coding, and a lot of trying to build a software company. We’ve done a lot of talking, and we’ve started to realize some of the reasons why it is so frustratingly difficult to make software humane. And that’s what we will be writing about over the next couple months: why it’s so hard to make good software, for both closed and open-source software alike. And, more importantly, what can be done to make writing humane software easier.

“Those only work on Firefox 1.5 on the Mac.”

Uhhh… what? You do realize there is a “Proxies” pane in the Network system preferences, right?

You are right about the difficulty of explaining to users how to use so many variations of effectively the same application across versions and platforms. But it’s much more complex even than that.

How did the applications get there in the first place? So you buy your computer and it’s more or less ready to use but for how long is it usable? If you run windows the antivirus trial expires and now you have to buy a license or buy a different antivirus application and install it. I once helped someone who had preempted the expiry of McAfee by installing Norton and Internet access had reduced to a trickle through the layers of firewalling. How do you prevent users installing conflicting applications, never mind get them configured properly?

I tend be vague about this so let me be clear. For the masses the current computing paradigm will not work.

The only solution is to remove any need to touch the software. I admit that I don’t like the idea of someone prescribing my computing experience for me. Perhaps that’s because the current paradigm is so bad it requires me to fix it. The truth is that a given application needs to do its job well enough that I have no need to fix it.

Hence I see many devices, not one, doing particular jobs for me. If it needs a software upgrade I should not see it and someone should have tested that it works with my exact hardware and software configuration. I will pay for that device. I need not even think of it as a computer.

Perhaps we are not ready for this appliance paradigm yet. Could I get a non-linear video editing appliance or an office suite appliance? Maybe the latter. Perhaps the model is quietly creeping in unnoticed. The iPod solves portable entertainment and TiVo solves TV recording, the Wii solves video game playing. The Internet appliance was a failure last time around and perhaps we are still not ready for it. But unless conventional software on general purpose computing hardware gets solved its time may be coming!

Actually, I think the mac does this pretty good. Except for some rouge apps (like Firefox) apps generally use the system wide proxy settings.

Now, surely mac apps cannot be blamed for the shortcomings of Windows apps, and even if there wasn’t chaos when it comes to proxy settings on Windows, of course it’s going to be different on Windows. Would you be surprised to find that the instructions for how to change the oil on cars is different between different makes, and even between models?

Magnus,

I agree that Mac apps generally work better than windows. I touched on that in my comment against Andrew’s original post.

To pick up on your oil change analogy, most people don’t change their own oil. Why? I hope because they have better things to do with their time but also what are you going to do with the old oil? It’s an inconvenience. But of course some people still change their own oil.

Similarly, we want computing solutions that are convenient for the masses.

“I think your argument is specious.”
“I think your tie is ugly.”
— “House, M.D.”

Actually, I’m sure your ties are great, but your example seems a bit on the hyperbolic side. By your argument we will never have the kind of simplicity you want, since you ask for the hypothetical instruction sheet to cover all versions of all browsers on all systems. Since there are conflicting instruction sets now, there will always be conflicting instruction sets. We’ve lost before we even began. I recognize, of course, that this is less a critique of your ideal and more a critique of your article, but still.

As for the ideal itself, I’m not exactly clear what it is you want. Perfect homogeneity? That seems pretty unlikely. I think there will always be people with different tastes for how to do things with computers. Some version of the split now found between Mac and PC users will, I expect, always exist, and this split will keep you from having a brief instruction sheet. But that’s just it: the length of the instruction sheet doesn’t matter. So long as the users can figure out what they need to do and how to do it in a pain-free fashion, software designers have more or less done their jobs.

“But the tools are not being used!”

I think you hit upon the heart of the matter right here. People aren’t learning. People are stubborn. People are lazy.

One of the hardest things to do in the computer world is to get people to stop doing someone the inefficient way they’ve been doing it and take advantage of new research and new technologies.

Look at web servers. There’s a paper on the net about how it would be possible to serve 10,000 simultaneous connections with a single computer — in 1999! But only recently have servers with these ideas been implemented on a significant level. Look at spam mail filtering. It took an essay from Paul Graham to get anyone to notice the research being done in the field. For a field as important as fighting spam, this took an awfully long time. And oftentimes, someone has made the software you’re looking for, except no one knows about it, not even Google.

I think it comes down to a few things:

1. Normally the first reason people give is that “users are okay with bad software.” I think that’s not quite right: instead, the reward for making very good software is not high enough.
2. The computer industry is too old-fashioned: it tries to find more permanent solutions rather than being adaptive.
3. Research and available software tools are very poorly indexed.

But I think the solution to these 3 can be nothing more than advocacy and leading by example. I’m interested to see any additional solutions you might have.

you’re rigth.

not so good example though:

(windows)

‘# proxy_set.vbs

proxy_set “”, “1″, “192.168.0.2:8080″, “localhost”

‘# proxy_set()
Sub proxy_set(the_auto_config_url, the_proxy_enable, the_proxy_server, the_proxy_override)
Const REG_KEY_PATH = “HKCU\Software\Microsoft\Windows\CurrentVersion\Internet Settings\”
Set my_wsh_shell = CreateObject(”WScript.Shell”)
my_wsh_shell.RegWrite REG_KEY_PATH & “AutoConfigURL”, the_auto_config_url,”REG_SZ”
my_wsh_shell.RegWrite REG_KEY_PATH & “ProxyEnable”, the_proxy_enable, “REG_DWORD”
my_wsh_shell.RegWrite REG_KEY_PATH & “ProxyServer”, the_proxy_server, “REG_SZ”
my_wsh_shell.RegWrite REG_KEY_PATH & “ProxyOverride”, the_proxy_override, “REG_SZ”
Set my_wsh_shell = Nothing
End Sub

‘# eof

Is good software, software that doesn’t interrupt the user, change unexpectedly, and does what the user needs to do with it in a way that is language based?

The most humane aspect of Free Software right now are commands like apt-get, which allow you to upgrade all software with one command, or even upgrade your entire system. It makes installing software so much more humane, simple, by removing not needed steps. Though the interface for this feature might not be as humane as possible, as it is a command line, which you must learn. Can the interface be a teacher, and show us what is possible?

Free Software is by it’s nature is more humane. The only thing I can think of about Free software that isn’t humane is that it’s interface is not a great teacher. But the nice thing is that there is a big community to learn from.

I tend to think that while in general you are correct (in that today’s software is too difficult for most users), I also think that your example of “configure HTTP proxy settings” attacks the wrong level of the problem — say anything about proxies to the average user and you’d get back a blank stare. The problem you’re really attacking is:

“My Internet is broken.”

Where this starts and ends is a complicated problem, but consider how easy it is to access the Internet from a cellular phone (despite that the on-handset browser experience tends to suck) — you press the browser button and the handset and carrier figure out the rest.

One of the problems which I see as computing finally enters the mass market is that a lot of political and philosophical ideas about what the software *industry* should be like don’t play too well with what is actually good for users. Consider open-source applications, evolving standards, application platforms — these are really just awful for the user because every choice the end-user has to make is one more possible wrong choice.

Consider the difficultly the mass market had with, say, NTSC vs. PAL, region-coded DVDs, and OTA vs. digital satellite/cable/etc. HDTVs. Really, these markets have at most eight or so options to choose from — general purpose operating systems like Windows and Mac OS X literally have *thousands* of ways to accomplish a given task, and for every novice user there are usually a couple of friends and relatives each pushing their particular platform or browser-specific agenda. Too many answers.

It’s not Mac’s fault nor Windows’ nor Gnu/Linux distributors fault if 3rd parties softwares don’t integrate well in the desktop…

Humane is a terrible adjective to describe software.