UI hints that prevent user errors

Question

What UI/GUI guidelines should be followed that subtly (or not so subtly) direct users so they don't shoot themselves in the foot.

For instance, you might want to give power users the ability to "clean" a database of infrequently used records, but you don't want a new user to try out that option if they've just spent hours entering new records - they may lose them all because they're 'infrequently used'. Please don't address this specific issue - it's just here to clarify the question.

While one could code a bunch of business logic in place to prevent some issues, you can't account for everything a user might do.

• What are some common techniques, tips, and tricks that prevent improper usage?
  • ie, How should I design the interface to alert users that a function or action is to be taken with care
• What should I design in that limits risk and exposure if a poor action is taken?

Answer 1

Make it possible to undo dangerous actions.

If it's a reasonably big applcation or system, require separate admin access for dangerous operations as well.

Answer 2

Everything can be undone. Don't erase - deactivate. Back up before every destructive operation, and give the user a way to restore.

That's the path. It's hard to follow it all the way, but it's what you're aiming for.

Answer 3

This is an old article, but it's still a great one:

Microsoft Inductive User Interface Guidelines

Answer 4

Never rely on anything that says "Are you sure?" The user is ALWAYS sure and that's if they even bothered to read it before dismissing.

Answer 5

Don't Make Me Think

And you can, in fact you HAVE to account for everything they might do. Because you (as the designer) as the one who gives them the ability to do all those things.

Before putting ANY item on a gui as yourself "Can this be misused?" and if it can, you might want to go with a lower level of customizability. Example hierarchy

• Button - Can be clicked.
• T/F Radio Button (mandatory) - Only two options.
• Combo Box - Many options, possibly "no option". more confusing.
• Text field - Myriad of wildly inconsistent options. More confusing for user, more dangerous for coder.

Basically, if the user doesn't need extra options, then don't give them extra options. You'll only confuse them.

Answer 6

I'm of the school of thought that, in case of inclarities or ambiguousity, the user is rarely wrong, and the UI is always to blame. So, when you say "punch the user in the face", tagged with "pebkac", I'm thinking that you would do good with a slap in the face.

Unfortunately, I'm unable to give any good UX-advice, since I'm a mere programmer, and therefore more or less by definition disqualify as a good UI-designer. I'd like just to point out the possibility, that you actually could be the one who needs to get a clue, and try to be more humble towards the users.

Edit for Adam:

The little I know about UX is how little I know about it. It's an entire career path. I know for a fact that there's very little anyone can learn by asking a single make-me-good-at-this question at Stack Overflow. It's like me asking "help me write better code", with the body text formulated as a story of how my colleagues ridicule me of my code.

We, programmers, are engineers. We like order and reason and logical decisions. But the average user is not a programmer, not an engineer and, in many cases, not interested in computers themselves the very least bit.

I'm glad that people are giving you nuggets of good advice, and I'm glad that you, contrary to my first impression (I'm sorry about that), are eager to take those bits and understand the needs of the user.

But the point remains: You need to buy books (Don't Make Me Think is a great place to start, as already recommended). You need to watch how people use your software. You need to observe where they stumble, and jig things around until your UIs seem natural.

I'm sorry I still can't give you an answer. Because I don't have it. And even if I would have it, I would probably have to charge you 50EUR an hour, for years into the future.

Answer 7

Partition your users and have fine-grained permissions.

Define some power-user permissions that enable the "more dangerous" operations.

Power user permission is not given out lightly -- only to actual power users -- and revoked readily.

Answer 8

Well there are a few different ways that I can/do go about these types of things.

1. User documentation - first and foremost give them some documentation to work with, and make the systems easy for them to use. Just general usability and descriptive names/actions for everything.
2. Provide confirmation screens with warnings. Full disclosure of what the action is going to do, with the warnings inside of a yellow box. It draws attention to it and helps prevent the need for the other items.
3. Have a roll-back plan. For large risky operations you can either simply set "deleted" flags, or offload the data to a temporary "recycle bin" of sorts should they accidentally remove/modify data that was unintended.
4. Require multiple approvals, for data purge operations especially go to a two-tiered approach, requiring approval from separate users.

These are just a few of the ideas that I have.

Answer 9

Make the results of the user's action visible and offer a way to undo those changes.

When the changes are visible, then the user gets feedback of whether the results were what he intended to do, and if they are not, then the possibility to undo will let the user to try again to reach his goal. If possible, make the results of the action visible before the user invokes the action (for example, when dragging some element, show what would happen if the user would release the mouse button, for example visualize addition of the element where it will be moved to and visualize the removal of the element from where it was moved from).

There are a couple of types of undo. The most simple is a single-step undo (as in Notepad), but it is often not enough. Better is a multi-step undo (as in Word), which covers most of the cases, but does not allow undoing a specific action without undoing all the actions that have been done after it. That can be solved by object-specific undo, for example in a form with many fields (or cells in a grid like in Excel), right-clicking the field would show a list of previous values in that field. For deleted data you could have a store of deleted data, from where the user can restore things after deleting them (for example if the user deletes a slide in Powerpoint). And finally you could have a full version history of every change, for example as Local History works in IntelliJ IDEA - make a history entry every time the file is saved (and save everything automatically after a couple seconds of inactivity).

Confirmation dialogs don't help. The user might read it the first time, but soon after that clicking "OK" in the dialog becomes an automated process, and the user will press Enter before the dialog even shows up. Then the confirmation dialog has become just a source of unnecessary mechanical work. The user is always sure about doing some action, even when he is wrong - otherwise he would not have done that action.

Answer 10

Two things immediately come to mind.

The first is the notion of progressive disclosure, i.e., only show users what they need in order to accomplish the task at hand. How many UIs have we seen that have hundreds of controls on a single dialog? Divide the controls into their respective tasks and only allow the user to do a single task at a time. An Advanced button on a dialog is one way to implement this, and this concept has the added benefit of separating the power users from the run-of-the-mill users. Run-of-the-mill users are less likely to attempt a task that is likely to be beyond their skill level.

The second is to leverage the wizard concept for complicated tasks. I know wizards have fallen out of style, but if a task is truly complicated, users usually appreciate having their hands held the first few times. A good example of this is the WinZip wizard interface. If you've never zipped a file before, this wizard uses a logical progression to walk you through the process. And then, once you've grown comfortable with it, you can switch to the classic interface to zip files more quickly.

Of course to do all of this requires a committment not only by the developers, but by management. And that, sadly, is where many of these usability battles are lost.