Nielsen-Molich heuristics for Usability
Interaction design, interface design, user experience design — all these terms have one very significant similarity — they involve the user for the most part, and are crucial in determining the kind of experience that an user has with respect to the product. You might think that since these are well-established domains, there must be specific rules and “theorems” to make sure you do not make mistakes; but as it turns out, this is one of those grey areas where you might just find gold hidden deep within uncharted territories.
And for that very reason, there are no rules or strict instructions to follow, but heuristics instead — broad rules of thumb that will keep you satisfied within the user-centered designing framework. The heuristics that were laid down by usability guru Jakob Nielsen and Danish engineer Rolf Molich in the early-1990’s — have stood the test of time and served as one of the most used set of principles of design.
This blog is the first of two posts, entirely dedicated to understanding what these heuristics are and how and where they can be applied. But before that…
Why?
Why should you bother knowing these heuristics?
It’s actually quite simple. Almost all products ever designed, that were never accepted by the general public, suffered from at least one usability problem. And usability can make or break your product. More on that, here:
So what usability professionals and interaction designers need to do, is to uncover usability problems in products and designs, and attempt to solve them for good — this is where these principles come in. And now that we have the purpose clarified, it’s time to get to know the “What”s. Here’s taking a look at the first five heuristics.
1. Visibility of system status
The system should always keep users informed about what is going on, through appropriate feedback within reasonable time.
Users should be able to understand right away the state that the system is currently in. While interacting with the system, the user should be made aware of his interactions, constantly and periodically. This can be taken care of, by lowering the response-time of the system to as low as possible — so the user would be provided with system status updates throughout, such as in the loading screen for Gmail, below.
2. Match between system and the real world
The system should speak the users’ language, with words, phrases and concepts familiar to the user, rather than system-oriented terms. Follow real-world conventions, making information appear in a natural and logical order.
One of the main reasons why most people end up totally frustrated with their systems, is because of the use of technical jargon at crucial points. This leads to severe mismatch between the real-life of the user and the digital-life that the system is trying to augment within the real-life. If there is no smooth transition into the digital system, usability problems are bound to crop up. For instance, while “fork”-ing a repository in GitHub might seem commonplace to developers, what is actually happening might not be evident to the layman.
3. User control and freedom
Users often choose system functions by mistake and will need a clearly marked “emergency exit” to leave the unwanted state without having to go through an extended dialogue. Support undo and redo.
The user should ideally never feel that she/he is communicating with a machine; the most usable system should be designed such that the user feels as if the communication is happening with another human on the other side. So, just like you would apologise if you told someone something that was not intended for that person, you should be able to revert and take back actions — rollback to a more desired state. For example, if you were about to post something on LinkedIn, and you accidentally clicked the “back” button, this is what LinkedIn would prompt.
4. Consistency and standards
Users should not have to wonder whether different words, situations, or actions mean the same thing. Follow platform conventions.
The ultimate aim for all good design should be to decrease the cognitive load for the users while using the products or interfaces. A foolproof way to ensure this is by making sure that consistency is maintained across the product — and its instances (if they exist). Also, if standards already exist like Google’s Material Design (image below), it would generally be a better idea to not go against those standards. This is because people love sticking to things, and they hate change. So as radical as your ideas might be, if they force the users to make changes in what they are doing and how they are getting stuff done — it just won’t work.
5. Error prevention
Even better than good error messages is a careful design which prevents a problem from occurring in the first place. Either eliminate error-prone conditions or check for them and present users with a confirmation option before they commit to the action.
To err is human. And to make provisions for moving forward, past the errors, is good design. Making educated assumptions about where users might commit errors, will help to enforce preventive measures for such errors. DuckDuckGo will scan the text being input into the search box as its being typed, and will try to resolve spelling errors and return similar results.
To get a deep dive into the world of error messages and how to design great error messages, you might want to take a look at this article:
These guidelines comprised the first half of the Nielsen-Molich heuristics for interaction design, and what they actually entail.
Check this space for part 2 of the set of heuristics, exactly at this time, the coming week!
Cheers!
