There seems to be an interesting argument going lately. The topic that spurs this discussions is: “Should we expect people to adapt to complex user interfaces, or rather adapt user interfaces so that they are easy for people to use?”
Scott at LazyCoder.com thinks that we as developers should always strive to make software as easy and intuitive as possible. He seems to completely reject the opposing view that certain level of complexity can’t be avoided. While I agree with Scott’s sentiment, I think that this issue is more complex than that. You can’t make something easy to use without trading off power and flexibility.
Let me define this problem more formally. When designing software there are many variables that you have to deal with, but let’s look at just two. Ease of Use and Power seem to be very closely related. In fact their relationship can be best described by the following graph:
At the point (0:10) – maximum power, minimum ease of use we would have something like a library or service with a public API as it’s sole interface. Is it easy to use? Of course not. You need to read the API specification documents, you need to figure out how to use it to do what you want it to do. But it is extremely flexible – it can be used in hundred’s of projects, in conjunction hundreds of other libraries and applications. It is entirely up to you on what do you use it for, and how do you combine different API calls to achieve new and unexpected effects.
On the other hand point (10:0) represents the opposite end of the spectrum: extreme ease of use, and almost no power or flexibility. What would be a good example here? The embedded software that runs the GPS unit in your car, or the ATM at your bank. It is extremely easy to use – you communicate with it by pushing big, self explanatory buttons on the screen. But what can you do with it? Not much… Or rather, precisely what it’s designer envisioned it to be used for.
I said it before, and I’ll say it again – GUI design kills flexibility. GUI applications do only what their designers wanted them to do, and nothing more. As you add flexibility and power to your GUI application, the complexity increases – and you end up with applications like Photoshop – which require certain level of skill, and practice to use.
It’s interesting that Scott decided to ask about this:
Is that really the point? Whatever the developer decides is what’s right? People should adapt to the computer, no matter how poorly designed, rather than adapting the computers to people?
The ironic part is that the attempts to make the software easy to use, are exactly that – decisions made by the developers on what is right for the user. These decisions might be made based on usability studies, focus groups and etc. But who is to say that what is right for your Grandmother is also right for you?
If you aim to maximize the ease of use you end up with a dumb application that appeals to the lowest common denominator, but it is to limited for a power user. When you make a general purpose application it is best to aim for the middle of the graph – you want to be somewhere around (5:5) where you get decent usability, and decent functionality and complexity.
Still, we really need the whole spectrum. Some applications will have to be notoriously hard to use because of their complexity. And some applications will have to be overly simplistic, because of their nature and function. If you cover half my graph with your hand and say “this side is bad, always try to end up in the opposite one” you essentially exclude whole domains of potential niche problems that you might have wanted to solve.
Not everyone wants a point and click interface – and it is not always appropriate. Case in point, my recent post about netcat.
[tags]ease of use, power, usability, flexibility, functionality, lazycoder[/tags]