For a few years I wrote a column on human-computer interaction (HCI) for the British quarterly trade magazine, Interface. This is one, slightly revised.
Advice for building interactive computer systems usually includes something about learnability. The learnability of a system includes two important parts: how easily new users can learn to carry out common tasks and, once they have some experience with the system, how easily they can improve their performance.
There are obvious differences between learning in a software environment and learning in the real world. For example, a few years ago I spent some time in California, and I learned how to skate with inline skates. (I eventually managed to stay upright for minutes at a time.)
My first step was putting on the equipment. Lacing up the skates was surprisingly complicated, because the eyelets are in an unusual pattern. It took some experimentation to figure it out: "Is this right? No, the ends aren't long enough to reach these holes..." In contrast, the latches that help hold my ankles in place were straightforward. I could work the latches back and fort to figure out how they work, even though I hadn't seen anything exactly like them before.
The wrist guards were another story. These are open-fingered gloves holding a piece of curved metal to protect my hands if I fall. I first put them on the wrong way, so that my wrists were bent slightly forward. It was hard to move my wrists around naturally with the gloves on backwards in this way, which helped me notice and correct my mistake. (There are much less pleasant ways I could have been made aware of this, but I was lucky.)
So part of learning about my equipment was simple exploration: seeing what it was possible to do, and deciding whether what I was doing was the right thing to do. But there's more. In learning how to skate, I watched other (much younger) people skating around me and tried to match their general movements. Once in a while I asked someone's advice. I practiced simple techniques until they became natural, and I found that simple actions sometimes led directly to more complicated ones that I'd have to handle.
How about software?
It's easier for people to learn to use a new application if it follows the same conventions as other applications they might already know. This is consistency. It means that buttons look touchable, on your mobile application, and there are File and Edit menus in your desktop application. Including novel interactions is fine, as long as the tradeoff with consistency is carefully considered.
Feedback is important. Are you doing the right thing? If it's a complicated task, you'll want to see signs that you're making progress and indications that you might be going in the wrong direction. This can be challenging for a designer--the software can't read your mind--but it's possible. For example, in the Alice environment you can write programs using visual building blocks. One subtle combination of blocks can cause a program to run forever, which might not be what you want, and when the system detects the relevant pattern, it says, "Here's what can happen--do you know what you're doing?" (It's more polite than that, of course.)
People learn both by figuring things out on their own and by watching or asking other people. Software used to be delivered with extensive documentation and manuals. For better or worse, that's rare today. What do people do instead? Often, they use a search engine to ask, "How do I do such and such?" and they find someone who's already gone through the relevant learning process and helpfully written about it.
A lot of people (most?) don't read instructions before diving in. This generally works for simple applications. It makes the design of complex applications harder, though. If you've ever rented a car, you've probably checked out a few things (where the lights are, how to work some of the dashboard controls) and simply driven off. You already know how to drive--what's to learn? Now imagine stepping into the cockpit of a commercial airliner. You see a yoke that looks much like a steering wheel, pedals in the floor, and a complicated dashboard. Surely flying can't be that much different from driving!
We can apply these ideas in practice. Here's an example from one of my students, about a real-world task:
At my job in a department store, you first pay for large items at the register and then you pick them up in a delivery area. In the delivery area, there's a machine that scans your receipt, asks you a few questions ("Is this your order?"), and then sends a message to the warehouse for the right items to be brought out. It's dead easy. Customers find it annoying, though, mainly because they don't take the time to read the instructions about what they need to do.
Could we streamline this interaction? Probably. After paying for some item, a customer arrives at the warehouse entryway with an unfamilar computer standing in the corner. We can imagine customers watching a looped video or a sequence of signs with pictures that demonstrates the process (just as I watched other skaters, and just as you might follow a tutorial). Customers could use a telephone handset or microphone, connected to a simple voice recognition system, to ask questions about the process (just as I asked advice of strangers, and just as you Google for help). If other customers were going through the same process, they could watch each other (sometimes you'll have the chance to watch over someone's shoulder to learn a new application). None of these solutions can completely replace a human to handle problems, just as having a human trainer is usually best for learning, but software that's designed for learnability can help.