Do you ever do things wrong? Make mistakes while you're in the midst of using a system? I just did a recording where I thought I was doing a recording and actually failed to select one of the options I need to select to get it to work. However, if you can understand why mistakes happen, then you're in a far better position to put them right.
So what we can do is use the execution evaluation cycle, the Norman model, in order to distinguish two classes of human errors, slips and mistakes. So first of all slips. So a slip happens when actually, you start off doing everything right. You understand what you're doing, your system goal. You understand the way the system works and you understand what you want to do. You formulate the right action plan and you decide the right thing to do.
And with my video here, I decided I wanted to record my screen, which is also recording from one of my microphones. I even had the little dialog box throw it up. And then something goes wrong. For some reason you don't do it. Now, in that case, I just for some reason obviously missed clicking that button. Whether I forgot at the last moment or whether I thought I clicked and I didn't, I'm not sure. You might, for instance, in a mail system...
you can imagine a user thinking, "I want to save my mail for later." And they go to click the save button and they accidentally hit the delete button instead. I'm sure that's happened to you more than once when you've been using a system. Certainly, it happens a lot with one of the mail systems I use. So that's a slip. Because it's at that very low level of the last action, it's quite easy not to notice that you've done it at all.
And I'll just emphasize this is an error, should we say, in the execution part of the execution-evaluation cycle. You've got the right goal, but you just haven't – for some reason – something's gone wrong in the execution. A mistake happens far sooner. A mistake is when you maybe do all the things you intend to do. It's just what you intended to do was the wrong thing. So again, in a mail system you might think, "Ah,
I want to save this mail message." So you see a button, it's called Archive and you think, "Oh yes, that's like going to a filing cabinet and putting the mail message into the right folder." So when I click Archive, I'm going to be given a list of folders. You click archive and the mail message disappears, because what Archive means is, "I'll sort of save it somewhere in the background." But it's not the same in a lot of email systems as actually then putting it into a folder.
So your *understanding of the system* was the problem. What you chose to do was what you intended to do. You pressed the Archive button, but it's just what you intended to do wasn't right for that system. Now, maybe after a while you learn how the system works. That doesn't happen anymore. But it's the sort of thing that often happens when you start using a new system and you're not so familiar with the kind of wordings. Now, notice, this is an error in the goal stage – your goal was wrong. As I said, in the example I gave there,
the goal was wrong because of your understanding of the system. Sometimes though, your goal can be wrong because your evaluation of previous steps. So for instance, when you hit that Archive [button], maybe you do understand archive and you've been using your mail system a lot, you know exactly what it does. You hit Archive and then for some reason you realize that the mail message you meant to archive is still there. And of course the reason for that is you thought that was the selected
email message, but perhaps a different one was selected. So your understanding of the system state, based on previous evaluation of actions you did on the system, was wrong. So you can both have these mistakes formed by a poor knowledge of how the system works. Or you can have mistakes that are because you've got a poor knowledge of the underlying state of the system at this moment in time. Having understood this, we're now in a position to actually think what are the best ways to fix these?
And depending on which kind of errors are happening, then there are different strategies to fix them. So if this is a slip, if the person has got the right understanding of the system and it's just that last bit of action that's going wrong, then we want to look at low-level interface things to try and prevent that bottom-level interaction. We might space other things out further. We might make them so that they're just larger, so the person is less likely to select the wrong one.
What you might do is give a very low level, instant feedback. Something like a little beep, but one that may vary in its tone depending on what you selected. So that the user gets this instant feel about which thing happened. You know, one of those spontaneous things that appears for a moment and then disappears or the like. There are various ways you can do this. But this is about just saying to the person, "That is what you just did. Hope that's right." And crucially, that means if you do something wrong, you fix it because often the problems with slips is not so bad that you do them.
But if you don't fix them straight away, that's often when serious problems start to occur. Of course that doesn't help if it's a mistake. If your goal was wrong and you get the beep that says that you just pressed the right button, well it was the right button. It was the button you meant to press. It just didn't do the thing that you really wanted to do. It does what you think it does, but that isn't the right thing
because your understanding of the system's wrong. Now you notice I split these mistakes into two classes. In fact, we've got three kinds of ways of fixing things. So one of those kinds of mistakes is when you don't understand the way the system works. Like the meaning of that Archive button. Then, as a designer, you can ask questions like, "Have I actually designed the right system here?" If all the users are doing that, maybe the wording you're using is the wrong wording for that kind of user. Or the model that you have for the kinds of user doing this is the wrong model.
Maybe some users have this problem, some don't. So it's not something that you can just change the system for. Maybe what this says is you need better ways of helping to train the user. Now that could be the first time you hit the archive button it pops a little box up that says, 'This is about to happen. If you meant to do this instead, this is what you should do.' Perhaps even with an okay/cancel. And one of those things that says, 'Don't show this again.'
Or you might show that for a while and then have it disappear. Or maybe you'll do something more reactive. You keep track in the system and if the person is constantly doing archive and then undo and then file, maybe then next time they log in, you pop up one of those tip boxes. It says, "Did you know that archive was about doing this?" and "This is how you do the other." So again, if you understand it's a problem about understanding the system, then you can offer ways to do it.
If it's the person didn't understand the states of the system, like the mail message they think is the selected one, that isn't. Then you can ask, how can I improve that semantic level of feedback? The semantic presentation, so that the person understands the state of the system so they can make the appropriate goals. Now, it could be that you, to make it a nice-looking interface, the way you highlighted the selected mail message was very, very subtle.
And maybe it's a bit too subtle and needs to be more in your face. It may be that at the point at which they selected it, it wasn't very clear what was going on. But again, if you understand that that's what's going wrong, that they think one thing's selected and actually it wasn't, then you can start to think about ways of making that more clear to them. But as a general rule, the more you understand about the kinds of errors that people make and the kinds of problems that happen, the better position
you are in to do something positive that really helps them.