Design Guidelines

Keep the Interface Simple

• Whenever possible, reduce the amount of function presented to the user at a single time.
• Do not want to overwhelm the user with all of the functions that your application can perform.
• Keep advanced functions (that are not commonly used) away from the common everyday tasks.
• Provide easy access to the advanced functions, but not let them get in the way of the tasks that the novice user would perform daily.
• Try to design the interface to match the mental model of the user
• Put yourselve in the shoes of your end users and think as if they might think and act as if they might act. Remember that you already know how the program works because you designed it. They might be using the application for the first time. Anticipate their thoughts and design your product to match those thoughts.
• If necessary provide separate views for each type of user (e.g. Provide only a high level view of the interactions for the business analysis—without technical jargon, and provide a very low-level detailed view for the technical analysis).

Build upon the user’s prior knowledge

• Whenever possible try to leverage the user’s past experience with your products and with items that they interact with in their everyday experience.
• The users may already have a mental model of how to interact with your products. You need to use this knowledge to help build a system that they understand without having to read a manual or click and receive on-line help.
• Be consistent within your organization.
• You cannot have one portion of your product work in one way while another portion works in a completely different way. Work closely with the other business units to make sure that they are following any specific company standards or style guides that have been created for interface design.
• Follow industry-standard guidelines for User Interface designs
• There are many sources for UI design guidelines and these can be an invaluable resource for us. You need to make your product consistent with products from other vendors that your clients may be using.

Place the user in control

• Allow users to accomplish their task in any order they would naturally use. Do not force them to some arbitrary notion of the “correct” way to do something.
• Some people like to work top-down, while others like to work bottom-up. You must consider this and allow the users to use your products in the manner that best matches their own way of doing things.
• Allow users to have several mechanisms to perform the same task (E.g. Pull-down menu, Right-click and/or keyboard short cut) and not just one way.
• Remember that some people are used to using GUI’s, others are used to Unix terminals and still others are used to 3270 screens. You must respect the experiences of each of these types of users. You must take into account their various skill sets and schemes for working with a computer and design your system so that it will work with each of them.
• You need to provide a way to use the application without touching a mouse that is just as easy as using a GUI.

Anticipate and assist frequently occurring tasks

• You need to present task in an order that makes sense to the user and such that the user doesn’t have to dig down into the interface to do the things that they would do most often.
• You need to remember the 80/20 rule and design the interface knowing that 80 percent of the users will use only 20 percent of the function. That 20 percent of function should be clear and easy to use and understand.
• You need to provide short-cuts to using the tasks that the users perform often. This is different from keyboard short-cuts. You need easier interfaces within the most frequently used items.
• You should provide macros or wizards to help with the completion of complex common tasks

ALWAYS respect the users actions and/or choices

• If the user selects or deselects something then you must select or deselect that item.
• Do not present a control to a user and not let them change or interact with it.
• Do not present a control to a user and not respect the change or interaction with the control.
• If the user creates a new object, put that object in the foreground and select it, as chances are they will want to work with the object that they just created.
• Allow the user to add multiple instances of the same object without forcing them to reselect the object (e.g. when in the current PI interface if the user is making connections between tasks with the connector arrow, do not force them to go back to the palette and reselect the connector arrow each time they want to connect two objects)
• You need to always have the delete key to delete what is selected.
• You need to support all of the keyboard shortcuts that the advanced users already know and use in the other applications they use (e.g. Ctrl-Z= undo, Ctrl-S = Save, etc)

Try to keep the user out of trouble, but don’t confine them

• Provide visual clues, reminders, and lists of choices.
• When ever possible you need to help the user out with items. You need to do as much work for them as possible and try to reduce the number of keystrokes are required.
• Provide intelligent default values.
• You need to pre-populated fields with data that are most likely going to be entered by the user manually.
• Always provide task-oriented context sensitive user assistance
• You need to help the user with the task that they are trying to solve and make sure that your on-line user assistance does that and does not just describe the interface.

Provide thoughtful error messaging

• You need to provide messaging that is more than just a slap on the hand. Tell the user in a complete sentence what went wrong and suggest a way that they can fix the problem.
• If providing those annoying conformation dialogs (do you sense a bias here?) you need to provide an option to discontinue displaying them. The option must be on both the dialog box itself and somewhere in the preference settings (they might want to turn in back on!)

Make actions predictable and reversible

• Always provide proactive feedback such that the user will know the effects of performing an action are BEFORE performing the action.
• It is always much better to avoid making an error than to try to correct one. The more work you do up front to make sure that the user knows what the effects are of performing an action, the more user errors you can avoid.
• Always provide feedback such that the user knows that their action was correctly performed.
• There is nothing worse than not knowing if your action has been processed. How many times do you think people accidentally print out several copies of a word-processing document because then were not given feedback that their print job was successfully sent to the print queue?
• Always allow the user to undo their actions, but only undo the most recent action, not an entire series of actions.

Always provide the user with the most up-to-date information

• Automatically refresh the screen immediately when changes have been made.
• Do not force the user to hit a refresh button to see the results of a change that they have make. But do maintain a refresh button in case the user wants to refresh the screen for some other reason
• Provide status messages for modes, states and status of remote servers (if necessary)
• The goal is to avoid presenting the user with any surprises. you need to keep them informed about anything and everything relating to the task that they are using your system to solve.
• Always provide feedback to the user so that they know whether their most recent work has been saved to disk. (You should provide an configurable AutoSave feature just in case they don’t save their work often)

Allow the user to customize their experience

• Let the user set preferences for how the system will look-and-feel (i.e. Metal, motif, Win32) and other screen elements.
• The user would like to have this application look like the others on their screen.
• No two people are alike. People like to have varying screen backgrounds, etc. and allowing them to change these seemingly trivial things will make the interface feel more comfortable and familiar
• Remember these preferences for the next time they use the system.
• Let the user set Default values
• Personalizing a computer interface can lead to higher productivity and user satisfaction. Allowing users to set default values can save them time and hassle when using frequently used functions.
• Remember the State of the interface and restore that the next time the user returns.
• People are likely to want to continue working on the same project when they return (perhaps the next morning). You should help them but returning the system to how it was when then left by remembering the state of all of the windows, settings, etc.

Avoid typos and other common mistakes

• You never get a second chance to make a first impression. You need to give your users a feeling for your commitment to a quality product. They do not get to see the source code, so they will be judging your quality based upon the interface.
• Never ship a product with a spelling mistake or typo (usually these get classified as P3 or P4 bugs, but in terms of the UI they are P1 or P2). They are very easy to fix, so let’s fix them!
• Always have a technical writer or editor examine wording or sentences for proper grammar. (Many times some improper sentences from non-native English speakers sometimes make it into the interface. You should always try to avoid this)
• Avoid the use of sexist language (Use they or the user instead of the generic pronoun he)
• Try to be politically correct (This can get difficult when dealing with the internationalization of your products, as different words, colors or objects can mean different things in other cultures).