User Interfaces can be seen as being made up of three elements:
- Visible features that can be directly scanned by the user.
- Hierarchical structures that offer functionality that is not immediately visible, but can be hunted through.
- Hidden features that cannot be directly intuited from simply looking at the interface and therefore must be learned.
The temptation, from a usability perspective, is to see hidden features as problems that must be resolved. In the case of a feature that is not immediately intuitive the naive answer is to make it more obvious through labelling, icons, explanations and visual design cues. However, in many cases this may be a very bad answer. This article discusses the issues involved.
WHAT IS A HIDDEN FEATURE?
We can consider that our experience with an interface is made up of tens or hundreds of small learning events. When we first use a new piece of software, we know nothing about how it works, except perhaps what we bring to it from watching other people use it and what we have seen in adverts and introductory materials.
Some of the features of the interface will be well labelled and clearly expressed directly in view. Others will be familiar because they follow common patterns for software in general, or software in that operating system. However, in any piece of software, there are likely to be some features that are not immediately visible, whose purpose is obscure, or whose method of operation is unclear.
In some cases, these elements are a usability problem that should be addressed, but in other cases, hidden elements can be justifiable, or even valuable.
Context menus – right-click context menus date back to some of the earliest GUIs. They can be very powerful, since they offer a set of options that is contextual to the element being clicked on, but they suffer from the weakness that they are invisible – the user has to remember to use the right-click and figure out which elements have a contextual menu.
Shortcut keys – most applications support a range of Mnemonic and Shortcut key combinations. These are very powerful, but are difficult to learn, since they are not expressed directly on screen and are hard to explore even via trial-and-error.
Drag tab to create new window in Chrome – when the Chrome browser arrived in 2008 it popularised tabbed browsing and in particular, the idea that tabs could simply be dragged out in order to create a new window, or dragged back to stack them.
Touchscreen gestures – the iPhone and other touchscreen devices have popularised a number of gestures that are neither visible, nor immediately obvious to the new user. However, they have rapidly gained wide acceptance and are now uncontroversial. For example, swiping and pinching.
Pull down to refresh – in the iOS email client (and many similar list-based examples), the list can be refreshed by pulling it down and releasing – as if new emails were simply waiting ‘above’ the top of the list and you could scroll to them.
Double tap to like in Instagram – double tapping on an image in Instagram (and many similar systems) is a shorthand for ‘liking’. This is simple and timesaving, but cannot be intuited from simply looking at the screen.
Swipe to the side to delete items – in the iOS email client (and many similar list-based systems), swiping horizontally across an item reveals contextual options for that list item – usually the ability to delete it.
WHY WOULD IT BE WRONG TO ‘FIX’ INVISIBLE FEATURES?
Making every part of an interface simple and obvious is a laudable aim, but unlikely to be truly practical, or desirable. Making a hidden feature more visible and obvious usually has the cost of adding clutter to the interface. As the number of features increases, it becomes less and less viable for them all to be made explicit.
At the same time, an interface which emphasises the unequivocal presentation of its functionality; using all of the prevailing standards and patterns; and including clear explanatory text and labelling, is likely to end up very dull and workmanlike. That may work for some interfaces, but sacrificing a little clarity in the service of a better presentation of your brand is often a good bargain. Unusual, or engaging interactions may not be immediately clear, but can give a product a specific personality and identity that is worth its weight in gold.
Another factor is that not all features are equal. Most products have a small set of really core functionality, with many more features that are useful, but far less important. Making everything ‘clear’ may obscure the genuinely core interaction with useful, but secondary functionality.
HOW CAN YOU ASSESS IF AN INVISIBLE FEATURE IS REASONABLE?
Hidden features can be analysed in terms of their Discoverability and Memorability; and their Pay-off. If a feature is highly discoverable and memorable, then it can be easily justified. However, features that have a large pay-off can justify being harder to discover, or requiring more effort to memorise.
Discoverability describes the ease with which a user can find the feature. Even though a feature may not be immediately visible on-screen, there may be ways that it is hinted at, or can be guessed based on familiarity with similar behaviours in other applications.
Factors that impact Discoverability include:
- Hinting: in some cases, access to the feature is not visible directly on screen, but visible hints are shown on rollover of part of the screen.
- Trial and error / accident: there are cases when it is feasible for the user to find hidden features by accident. For example, pull down to refresh in iOS can be discovered as a side-effect of scrolling through a list.
- Observation: Some features can be picked by observation of other people, or from video tutorials or adverts. This typically requires the interaction to have a self-explanatory visual quality when observed.
- Training and support: features may be described in the interface, or in support tools, allowing the user to learn them. For example, keyboard shortcuts are typically shown alongside options in menus.
- Following an established pattern: Using a hidden method that is common in other similar interfaces increases the chance that the user will try it out.
Memorability describes the ease with which the user can learn the feature. In some cases, seeing something in action once is enough to remember it; in others, significant effort is required to remember shortcut key combinations, or text commands.
Factors that impact Memorability include:
- Simplicity: The simpler the interaction, the easier it will be to remember – more steps will make it harder.
- Engaging interaction: A feature can be memorable because it has an engaging interaction quality. For example it may be highly visual; feature drag and drop; or use tactile gestures.
- Game-like interaction: If the feature has a playful or game-like quality to it, this will improve the rate of repetition and make it much more memorable.
- Repetition: Re-using the same interaction many times within the interface will improve its memorability through repetition.
Pay-off refers to the benefit that is provided by learning the feature. The larger the Pay-off, the greater the incentive to learn and remember it. In some cases, a large Pay-off can compensate for limited Memorability and Discoverability of a feature.
This chart plots Memorability against Discoverability for a number of examples. The relative Pay-off of each feature is shown by the size of the circle. Features that fall into the top left quadrant are easy to justify, even if the Pay-off is small. Features falling into the bottom right quadrant are the most difficult to justify. However, they may be appropriate if they offer a high Pay-off.
A good example of a feature that is hard to discover and remember, but offers a large pay-off is a command line syntax – once learned, it allows the user to access thousands of actions very quickly and efficiently, explaining its persistence as an interaction method for certain applications.