What is efficiency?
Efficiency relates to how fast a user accomplish tasks once he or she has learned to use a system. The basic idea behind it is that, as you use a computer system more and more, your level of expertise in use of that system increases, thus lowering the amount of time that it took you to do a particular task. A good example of this is in the concept of shortcuts or quick keys. For example, many people use CTRL-X to cut a piece of text on a PC (alternatively, Mac users use Apple-X) and use CTRL-V to paste text (or Apple-V on the Mac). This is a very basic concept that allows people to be more efficient: Without this, a user would have to highlight the text with their mouse, then go to the edit menu, pick the cut item in the menu, then go to the place where the text is to be pasted, go back to the edit menu and click on the paste item in the menu. Using the quick keys, they highlight the text they want to cut, press CTRL-X, go where they want to paste the text and press CTRL-V. In this process, two extra time-consuming tasks have been removed. While it may not seem like much, if you consider the number of times a user might use those function in a given day, it adds up to quite a large amount of time.
So how do we do this?
One of the main challenge to the OSS community in terms of improving usability will stem from the fact that most OSS developers do not interact with everyday users when they are developing a system. The challenge here is in figuring out how to increase the speed at which a user can do a particular task. A good example used in the usability community to explain this concept is that of the microwave. The basic question boils down to which is faster, cooking a cup of water for 1 minute and 10 seconds or 1 minute and 11 seconds? From a purely mathematical answer, one would say that the former is the fastest. But from an interface standpoint, it isn’t. A user can more quickly type 1-1-1 than 1-1-.. This seems completely counter-intuitive to established mathematical formulas but highlights some of the complexities of usability design. What this highlights, however, is that one must think of those things before coding. This means that basic usability issues should be part of the design cycle of an application.
Highlighting efficiency
Here are a few points that one should consider as part of this process:
- Are my error messages clear? A user receiving a message along the lines of
java.lang.foo error 1023123will be confused. However, if the same message says Your request could not be processed, please press enter again, the user will be working more efficiently. Clear instructions are part of a good usability system. In this case, the user is not spending a while trying to figure out what happens and is asked to do something to solve the problem! - Does my system give feedback? This is important because users left without feedback tend to hesitate before moving on to the next step. A good example of how not to do this is the send e-mail screen in Squirrelmail, an otherwise really nice open sourced webmail application. When one presses send, the screen comes back to an empty message, giving no indication as to whether mail was sent or not. This lack of feedback left me confused and wondering whether the email had been sent or not the first time I used it. In this case, a simple Your email has been sent message would have done the trick.
- Is there a convention for this function? In the control key example, I showed how people might expect CTRL-X and CTRL-V to act as the cut and paste functions. Do not go against those basic rules as it will confuse the user. Generally, mainstream applications follow the same principles for basic functions. Here’s a quick sample of commonly used function (for Mac, replace the CTRL with the Apple key):
- CTRL-A: Select All
- CTRL-B: Bold text (in editing mode)
- CTRL-C: Copy
- CTRL-F: Find
- CTRL-I: Italic text (in editing mode)
- CTRL-N: New
- CTRL-O: Open
- CTRL-P: Print
- CTRL-Q: Quit
- CTRL-S: Save
- CTRL-U: Underline (in editing mode)
- CTRL-V: Paste
- CTRL-X: Cut
- CTRL-Y: Redo
- CTRL-Z: Undo
Reusing commonly used functions will allow users who have used other systems to easily make the jump to yours, without have to relearn a lot of tasks. This will make them more efficient as the learning curve to move to your program will be lessened.
- Is the behavior of my system consistent from window to window? Some people believe in innovating by providing different ways to navigate a piece of software, depending on where in the software you are. As a general rule, this is a bad idea as it confuses the user. If your first entry screen launches new windows, make sure that all the buttons launch a new window. Similarly, if it overwrites the main window, make sure that’s the case for all sub-items (and make sure there’s a clear way to come back to the previous window!) Users expect application to work in a consistent manner so choose an approach in terms of presenting screens, and stick to it!
- Is my navigation clear? This is another efficiency area where the OSS community can actually improve on the overall user experience. With Windows 2000, Microsoft has started to change the navigation based on how much users use a particular function (the infamous “where are my tools” menu). This is a really bad idea and flies in the face of convention when it comes to usability. Make sure that your navigation is consistent and do not make it disappear (navigation should not evolve! The other issue here is the concept of mystery navigation. This is more of an issue when people deal with designers. A designer might feel really strongly that the best way to “improve” the interface is to use some cutesy button instead of presenting something that is clear. Trust me, a button that says “main menu” is better than a twisty button that hides what the menu is.
If you follow those basic points, you will increase the efficiency of your system. As a result, they will be happier and will tell all their friends to use it. See, usability is already paying off!