Principles to Support Usability

Being a designer, how will you know whether the design you created is usable by the user or not? In order to determine the usability of our design, we need design rules and principles. All possible principles that can support usability are roughly divided into three main categories: learnability, flexibility, and robustness.

Learnability

Learnability principles determine how easily novice users can learn to interact with system features and attain maximum expertise. Here are a few key things to remember to improve learnability.

• Predictability
  The user should be able to predict the results of future actions based on the knowledge of their interaction history. Predictability can be satisfied with multiple degrees. For example, it can be achieved by:

  • Restricting the required user’s knowledge to currently perceivable information.
  • Increasing the required user’s knowledge to every previous action and every previous display’s content.

  Operation visibility is a form of predictability concerned with showing the users all available operations they can perform next. If all operations are visible, the user will be able to consider all possible actions that could be performed.

• Synthesizability
  The user should be able to perceive the effects of actions on the system interface, i.e. the updated system must be reflected on the interface. The interface’s ability to reflect system state changes is called honesty. There are two aspects of synthesizability:

  • Immediate honesty: Notifying the user without requiring any further action from the user. For example, when moving a file from one folder to another using WIMP interaction styles, the user can see the file moving. After it has moved, the user can immediately see the file in the destination folder.
  • Eventual honesty: Notifying the users after they have performed the required actions. For example, when moving a file from one folder to another using command-line interaction styles, the system state does not update the user on what percent of the file has been moved. Once the file has moved, the user has to recall the destination folder address and run a command to list folder content in order to check if the file is present in the new position.

• Familiarity
  The user should be able to map prior experiences of real-world and other computing systems on to interaction with a new system. Familiarity deals with the user’s first perception and impression of the system. It determines whether the user is able to initiate interaction. There are two ways of increasing familiarity:

  • Guessability: An object’s behavior and purpose can be predicted by mapping its appearance to a real-world object. Using metaphors can increase the guessability of an object. However, if not used properly, metaphors can sometimes be difficult to understand. For example, a trash bin icon used as the deleted items folder is a good choice of metaphor, but using a photocopier machine as an icon for the copy operation could be difficult to understand.

  • Affordance: An object’s behavior and purpose can be predicted by its intrinsic properties, just like the appearance of shoes indicates that they should be worn on feet and not on hands. Similarly, digital items like a button’s appearance should indicate that it should be pushed.

• Generalizability
  The user should be able to extend their prior knowledge of a specific situation of interaction to other unencountered but similar situations. Generalizability should be supported within and across applications. For example, cut, copy, paste, save, and other common command operations work the same way in all windowing systems.

• Consistency
  Consistency is the most important and most widely discussed principle of usability. It states that the system should have similar behavior in similar tasks and situations. Consistency can be determined with respect to actions in the form of input expressions and output responses.

Note: Consistency is not a single property that can either be satisfied or dissatisfied. Consistency is measured relative to something. Most of the usability principles can be reduced to consistency. For example, familiarity can be reduced to consistency with respect to real-world experiences and generalizability can be reduced to consistency across platforms.

Flexibility

Flexibility determines the number of different ways a system and user can interact. This interaction is also referred to as a dialog between the user and system. A system’s usability can be improved by applying the principles of flexibility, which include the following:

• Dialog initiative
  There are two types of dialogs based on who initiated them. These are:

  • System pre-emptive: A dialog that is initiated and controlled by the system and the user simply replies to the system queries. For example, while closing an unsaved document, a warning dialog box is initiated by the system with two to three response options for the user.
  • User pre-emptive: A dialog initiated and controlled by the user. For example, while editing a document in a text editor, the user can freely perform any action from the available set of actions in any sequence.

  Having flexibility means that the user should have maximum control over dialog flow. From the user’s perspective, maximized user pre-emptive dialogs and minimized system pre-emptive dialogs will increase the flexibility of the system.

• Multi-threading
  This principle states that the user should be able to perform multiple tasks at a time. Multi-threading can be of two types:
  • Concurrent: Allows working on multiple tasks at one time. For example, copying files from one directory to another and using the browser simultaneously is concurrent multi-threading.
  • Interleaved: Also known as temporal multi-threading. More than one dialog can be initiated at one time, but the system only allows working on one task at a time. For example, having multiple windows open with different tasks, but only being able to work on one of them at a time.

• Customizability
  The user or system should be able to modify the user interface according to the user’s requirements. Customizability can be divided into two types:

  • Adaptability: The user’s ability to modify the interface according to their requirements and expertise.
  • Adaptivity: The system’s ability to modify the interface according to the user’s requirements by recognizing them as novice or expert.

  For example, adaptive web designs (AWD) support the principle of customizability. An AWD has multiple layouts to represent its design and it automatically changes the layout that best fits the available space on a device.

• Substitutivity
  The user should be able to provide input or view output in alternative ways. For example, a line in the drawing package can be drawn by specifying the coordinates’ values, and the line will be drawn automatically, or the user will draw the line first, and then the coordinates will be specified automatically.

Robustness

Robustness is the amount of support provided to the user to successfully access and achieve the desired goals of their interactions. Robustness in an interface can be achieved through the following principles:

• Observability
  The user should be able to evaluate the internal state of the system through the state’s representation on the interface. For example, the system displays the file copying status on the interface.

• Recoverability
  The user should be able to reach the desired goal after an error has been made and recognized. There are two options for recovery:

  • Forward: The user’s current state is accepted and negotiated towards the desired state. This is also called negotiation. For example, closing a document without saving changes is forward recoverability, i.e. you will have to make changes again to reach the desired goal.
  • Backward: The user’s current state is returned to the previous state. This is also called undo. For example, retrieving erased text from a document by pressing the undo button is backward recoverability.

• Responsiveness
  The user should be able to receive the response of the system state in a short or spontaneous response time. Responsiveness also deals with the stability of the system. Stability states that the response time for similar actions and tasks should be constant. For example, the time taken by a menu to pop up as soon as the cursor moves to that menu should be the same as the time taken by all menus to pop up.

• Task conformance
  Task conformance is the extent to which all the user’s desired tasks are supported by the system. There are two aspects of task conformance:

  • Task completeness: The system should provide support for all actions required to complete a task. For example, Google Docs offers all the possible actions that a user can possibly perform while creating a text document.

  • Task adequacy: The system should consider the user’s understanding of tasks and should support tasks as the user wants. For example, Google Docs offers the ability to select the font size from a dropdown menu, but not all sizes are available in that menu. Look at the image. What if the user has to select font size 15? They cannot directly select it.