Usability 101: Efficiency

On Mon­day, I high­lighted the five basic points of usabil­ity. Yes­ter­day, I delved fur­ther into the con­cept of learn­abil­ity. Today, we are focus­ing on the con­cept of efficiency.

What is efficiency?

Effi­ciency relates to how fast a user accom­plish tasks once he or she has learned to use a sys­tem. The basic idea behind it is that, as you use a com­puter sys­tem more and more, your level of exper­tise in use of that sys­tem increases, thus low­er­ing the amount of time that it took you to do a par­tic­u­lar task. A good exam­ple of this is in the con­cept of short­cuts or quick keys. For exam­ple, many peo­ple use CTRL-X to cut a piece of text on a PC (alter­na­tively, Mac users use Apple-X) and use CTRL-V to paste text (or Apple-V on the Mac). This is a very basic con­cept that allows peo­ple to be more effi­cient: With­out this, a user would have to high­light 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 high­light 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 con­sider the num­ber of times a user might use those func­tion in a given day, it adds up to quite a large amount of time.

So how do we do this?

One of the main chal­lenge to the OSS com­mu­nity in terms of improv­ing usabil­ity will stem from the fact that most OSS devel­op­ers do not inter­act with every­day users when they are devel­op­ing a sys­tem. The chal­lenge here is in fig­ur­ing out how to increase the speed at which a user can do a par­tic­u­lar task. A good exam­ple used in the usabil­ity com­mu­nity to explain this con­cept is that of the microwave. The basic ques­tion boils down to which is faster, cook­ing a cup of water for 1 minute and 10 sec­onds or 1 minute and 11 sec­onds? From a purely math­e­mat­i­cal answer, one would say that the for­mer is the fastest. But from an inter­face stand­point, it isn’t. A user can more quickly type 1–1-1 than 1–1-.. This seems com­pletely counter-intuitive to estab­lished math­e­mat­i­cal for­mu­las but high­lights some of the com­plex­i­ties of usabil­ity design. What this high­lights, how­ever, is that one must think of those things before cod­ing. This means that basic usabil­ity issues should be part of the design cycle of an application.

High­light­ing efficiency

Here are a few points that one should con­sider as part of this process:

• Are my error mes­sages clear? A user receiv­ing a mes­sage along the lines of java.lang.foo error 1023123 will be con­fused. How­ever, if the same mes­sage says Your request could not be processed, please press enter again, the user will be work­ing more effi­ciently. Clear instruc­tions are part of a good usabil­ity sys­tem. In this case, the user is not spend­ing a while try­ing to fig­ure out what hap­pens and is asked to do some­thing to solve the problem!
• Does my sys­tem give feed­back? This is impor­tant because users left with­out feed­back tend to hes­i­tate before mov­ing on to the next step. A good exam­ple of how not to do this is the send e-mail screen in Squir­rel­mail, an oth­er­wise really nice open sourced web­mail appli­ca­tion. When one presses send, the screen comes back to an empty mes­sage, giv­ing no indi­ca­tion as to whether mail was sent or not. This lack of feed­back left me con­fused and won­der­ing whether the email had been sent or not the first time I used it. In this case, a sim­ple Your email has been sent mes­sage would have done the trick.
• Is there a con­ven­tion for this func­tion? In the con­trol key exam­ple, I showed how peo­ple might expect CTRL-X and CTRL-V to act as the cut and paste func­tions. Do not go against those basic rules as it will con­fuse the user. Gen­er­ally, main­stream appli­ca­tions fol­low the same prin­ci­ples for basic func­tions. Here’s a quick sam­ple of com­monly used func­tion (for Mac, replace the CTRL with the Apple key):
  • CTRL-A: Select All
  • CTRL-B: Bold text (in edit­ing mode)
  • CTRL-C: Copy
  • CTRL-F: Find
  • CTRL-I: Italic text (in edit­ing mode)
  • CTRL-N: New
  • CTRL-O: Open
  • CTRL-P: Print
  • CTRL-Q: Quit
  • CTRL-S: Save
  • CTRL-U: Under­line (in edit­ing mode)
  • CTRL-V: Paste
  • CTRL-X: Cut
  • CTRL-Y: Redo
  • CTRL-Z: Undo

  Reusing com­monly used func­tions will allow users who have used other sys­tems to eas­ily make the jump to yours, with­out have to relearn a lot of tasks. This will make them more effi­cient as the learn­ing curve to move to your pro­gram will be lessened.

• Is the behav­ior of my sys­tem con­sis­tent from win­dow to win­dow? Some peo­ple believe in inno­vat­ing by pro­vid­ing dif­fer­ent ways to nav­i­gate a piece of soft­ware, depend­ing on where in the soft­ware you are. As a gen­eral rule, this is a bad idea as it con­fuses the user. If your first entry screen launches new win­dows, make sure that all the but­tons launch a new win­dow. Sim­i­larly, if it over­writes the main win­dow, make sure that’s the case for all sub-items (and make sure there’s a clear way to come back to the pre­vi­ous win­dow!) Users expect appli­ca­tion to work in a con­sis­tent man­ner so choose an approach in terms of pre­sent­ing screens, and stick to it!
• Is my nav­i­ga­tion clear? This is some­thing where the OSS com­mu­nity can actu­ally improve on the over­all user expe­ri­ence. With Win­dows 2000, Microsoft has started to change the nav­i­ga­tion based on how much users use a par­tic­u­lar func­tion (the infa­mous “where are my tools” menu). This is a really bad idea and flies in the face of con­ven­tion when it comes to usabil­ity. Make sure that your nav­i­ga­tion is con­sis­tent and do not make it dis­ap­pear (nav­i­ga­tion should not evolve! The other issue here is the con­cept of mys­tery nav­i­ga­tion. This is more of an issue when peo­ple deal with design­ers. A designer might feel really strongly that the best way to “improve” the inter­face is to use some cutesy but­ton instead of pre­sent­ing some­thing that is clear. Trust me, a but­ton that says “main menu” is bet­ter than a twisty but­ton that hides what the menu is.

If you fol­low those basic points, users will become more effi­cient when using your pro­gram. As a result, they will be hap­pier and will tell all their friends to use it. See, usabil­ity is already pay­ing off!