GUI design techniques to enhance user experience

Question

What techniques do you know\use to create user-friendly GUI ?

I can name following techniques that I find especially useful:

• Non-blocking notifications (floating dialogs like in Firefox3 or Vista's pop-up messages in tray area)
• Absence of "Save" button
  MS OneNote as an example.
  IM clients can save conversation history automatically
• Integrated search
  Search not only through help files but rather make UI elements searchable.
  Vista made a good step toward such GUI.
  Scout addin Microsoft Office was a really great idea.
• Context oriented UI (Ribbon bar in MS Office 2007)

Do you implement something like listed techniques in your software?

Edit:
As Ryan P mentioned, one of the best way to create usable app is to put yourself in user's place. I totally agree with it, but what I want to see in this topic is specific techniques (like those I mentioned above) rather than general recommendations.

Answer 1

The best technique I found is to put your self in the users shoes. What would you like to see from the GUI and put that in front. This also gives you the ability to prioritize as those things should be done first then work from there.

To do this I try to find "layers of usefulness" and add / subtract from the layers until it seems clean. Basically to find the layers I make a list of all the functions the GUI needs to have, all the functions it should have, and all the functions it would be neat to have. Then I group those so that every thing has logical ordering and the groupings become the "layers". From the layers I then add the most important functionality (or what would be used for Day to Day operation) and that becomes the most prominent part, and I work things into the feature around those items.

One of the toughest things is navigation as you have so much to give the use how do you make it helpful and this is where the layers really help. It makes it easy to see how to layout menus, how other pieces interact, what pieces can be hidden, etc.

I have found the easiest way to do this is to start by see what and how your users function on a day to day basis this which will make it easier to get in their shoes (even better is to do their job for a few days). Then make some demonstrations and put them in front of users even if they are Paper Prototypes (there is a book on this process called Paper Prototyping by Carolyn Snyder). Then begin building it and put it in front of users as it is built often.

I will also recommended the book Designing Interfaces by Jenifer Tidwell published by O'Reilly

Answer 2

The items in the list you presented are really situation dependent - they will vary from application to application. Some applications will need a save button, some won't. Some conditions will warrant a modal dialog box, some won't.

My top rule for designing a usable interface: Follow existing UI conventions. Nothing confuses a user more than a UI that doesn't work like anything they've ever used. Lotus Notes has one of the worst user interfaces ever created, and it is almost entirely because they went against common UI conventions with just about everything that they did.

If you're questioning how you should design a certain piece of your UI, think of a few standard/well-known applications that provide similar functionality and see how they do it.

Answer 3

If your UI involves data entry or manipulation (typical of business apps) then I recommend affording your users the ability to act on sets of data items as much as possible. Also try to design in such a way that experienced users can interact with the UI in a very random, as opposed to sequential way (accelerator keys, hyperlinks, etc).

Answer 4

@noblethrasher, can you provide an example of such UI ?

Answer 5

If you do give the user a question, don't make it a yes/no question. Take the time to make a new form and put the verbs as choices like in mac.

For example:

 Would you like to save?    
     Yes        No

Should Be:

  Would you like to save?
    Save        Don't Save

There is a more detailed explanation here.

Answer 6

@17 of 26 I agree with what you're saying. However I want to collect a list of useful GUI tricks. May be there is an application that touched you? For me, increment search in MSVS was one of such features.

Answer 7

If you implement a search, make it a live search like what Locate32 and Google Suggest does now. I am so used to not pressing "Enter" at the search box now.

Answer 8

One of the classic books to help you think about design is "The Design of Everyday Things" by Donald Norman. He gives great real-world examples. For example, if you design a door well, you should never have to add labels that say "push" and "pull." If you want them to pull, put a handle; if you want them to push, put a flat plate. There's no way to do it wrong, and they don't even have to think about it.

This is a good goal: make things obvious. So obvious that it never occurs to the user to do the wrong thing. If there are four knobs on a stove, each one next to an eye, it's obvious that each knob controls the eye it's next to. If the knobs are in a straight line, all on the left side, you have to label them and the user has to stop and think. Bad design. Don't make them think.

Another principle: if the user does make a mistake, it should be very easy to undo. Google's image software, Picasa, is a good example. You can crop, recolor, and touch up your photos all you like, and if you ever change your mind - even a month later - you can undo your changes. Even if you explicitly save your changes, Picasa makes a backup. This frees up the user to play and explore, because you're not going to hurt anything.

Answer 9

Check out the great book Don't make me think by Steve Krug.
It's web focused but many of the conepts can apply to anything from blenders to car dashboards.
Topics covered:

• User patterns
• Designing for scanning
• Wise use of copy
• Navigation design
• Home page layout
• Usability testing

He also has a blog called Advanced Common Sense

And some random UI related links:
User Interface Design for Programmers by Joel Spolsky
flowstate about UI design craft
10 Usability Nightmares You Should Be Aware Of
7 Aspects of a great user experience

Answer 10

Well, one thing that may be obvious: don't change (even slightly) the position, color, font size, etc. of buttons, menus, links, etc. between screens if they do the same type of action.

Answer 11

If you are doing enterprise software, a lot of users will have small monitors at low resolution. Or if they are old they will have it at a low res so they can see giant buttons ( I have seen an 800x600 on a 24"ish monitor). I have an old 15" monitor at a low resolution (800 x 600) so i can see what the program will look likes in less than idle conditions every now and then. I know that enterprise users pretty much have to accept what they are given but if you design a winform that doesn't fit into an 800x600 screen, it's not helping anyone.

Answer 12

I've found UI Patterns to be a useful reference for this sort of thing. It's arranged much like the classic GoF Design Patterns book, with each pattern description containing:

• The problem the pattern solves
• An example of the pattern in action
• Sample use cases for the pattern
• The solution to implement the pattern
• Rationale for the solution

Answer 13

Really good feedback is extremely important. Even simple things like making it obvious what can and cannot be clicked can be overlooked or too subtle. Feedback when something might happen in the background is great. In gmail, it's great that there's a status ribbon appearing at the top that let's you know if something is sending or loading, but it's even better that it lets you know that something has sent successfully or is still loading.

The "yellow fade" technique is something else made popular amongst the RoR crowd that accomplishes something similar. You never want the user to ask the question, "What just happened?" or "What will happen when I do this?".

Another trick that has become more popular lately that I've been using a lot is editing in place. Instead of having a view of some data with a separate "edit" screen (or skipping the view and only having an edit screen), it can often be more user friendly to have a nicely laid out view of some data and just click to edit parts of it. This technique is really only appropriate when reading the data happens more often than editing, and is not appropriate for serious data-entry.

Answer 14

To add to your list, aku, I would put explorability as one of my highest priorities. Basically, I want the user to feel safe trying out the features. They should never back away from using something for fear that their action might be irreversible. Most commonly, this is implemented using undo/redo commands, but other options are no doubt available e.g. automatic backups.

Also, for applications that are more process-oriented (rather than data-entry applications), I would consider implementing an interface that guide the user a bit more. Microsoft's Inductive User Interface guidelines can help here, although you need to be very careful not to overdo it, as you can easily slow the user down too much.

Finally, as with anything that includes text, make the user interface as scannable as possible. For example, if you have headings under which commands/options appear, consider putting the action word at the start, rather than a question word. The point that Maudite makes is a good example of scannability too, as the "Don't Save" button text doesn't rely on the context of the preceding paragraph.

Answer 15

First Principles: Wilfred James Hansen

• Know the User
• Minimize Memorization
• Optimize Operations
• Engineer for Errors

Subsequent Expansions: Dr. Theo Mandel

Place Users in Control

• Use Modes Judiciously (modeless)
• Allow Users to use either the Keyboard or Mouse (flexible)
• Allow Users to Change Focus (interruptible)
• Display Descriptive Messages and Text (helpful)
• Provide Immediate and Reversible Actions, and Feedback (forgiving)
• Provide meaningful Paths and Exits (navigable)
• Accommodate Users with Different Skill Levels (accessible)
• Make the User Interface Transparent (facilitative)
• Allow Users to Customize the Interface (preferences)
• Allow Users to Directly Manipulate Interface Objects (interactive)

Reduce Users' Memory Load

• Relieve Short-term Memory (remember)
• Rely on Recognition, not Recall (recognition)
• Provide Visual Cues (inform)
• Provide Defaults, Undo, and Redo (forgiving)
• Provide Interface Shortcuts (frequency)
• Promote an Object-action Syntax (intuitive)
• Use Real-world Metaphors (transfer)
• User Progressive Disclosure (context)
• Promote Visual Clarity (organize)

Make the Interface Consistent

• Sustain the Context of Users’ Tasks (continuity)
• Maintain Consistency within and across Products (experience)
• Keep Interaction Results the Same (expectations)
• Provide Aesthetic Appeal and Integrity (attitude)
• Encourage Exploration (predictable)

Answer 16

Cleared for Deletion

Answer 17

A useful technique which I never see anyone use is to add a tooltip for a disabled UI control explaining why the control is disabled. So if there's a listbox which is disabled and it's not clear why it is disabled, I want to hover over it and it tells me why it's disabled. I want to see something like "It's disabled because two textboxes on the screen were left blank or because I didn't enter enough characters in some field or because I didn't make a certain action.".

I get into sooooo many such situations and it's frustrating. Sometimes I end up posting in the software's forum asking why a control is greyed out when a tooltip could have helped me in a second! Most of these software have help files which are useless in these kinds of scenarios.

Try to pretend you know nothing about your software and try using it. However this is not practical because you already have a certain mind set towards the app. So watch fellow developers or friends use the app and look out for the pain points and ask for feedback.

Answer 18

Here is a great DotNetRocks podcast episode where Mark Miller talks about how to create Good UI; Even though the show title is .NET rocks, this episode talks about a general rule of thumbs on how to create a UI to increase program user's productivity.

Here is an episode exerpt

Good user interface design can be done by sticking to some good rules and avoiding common mistakes. You don't need to be a latte-sippin tattoo-wearin macbook-carrying designer to create user interfaces that work.

Answer 19

Try to think about your user's end goals first before deciding what individual tasks they would carry out when using your software. The book About Face has excellent discussions on this sort of thing and though quite long is very interesting and insightful. It's interesting to note how many of their suggestions about improving software design seem to used in google docs...

One other thing, keep your user interface as simple and clean as possible.

Answer 20

Rounded corners!

(Yes that's tongue in cheek)

Answer 21

Sung Meister mentioned Mark Miller. You can find some of his blog posts regarding great UI on the Developer express blog. Here's a screencast of his Science of great UI presentation: part1 and part2. (both require Veoh player).

You can also find him on dnrTV: Science of great user experience: part1 and part2.

Here's a google techtalks about user experience by Jen Fitzpatrick.

Cheers

Answer 22

When using a dropdown, the default dropdown height is usually too low (default is 8 items for winforms, for example).

Increasing it will either save the user a click if the number of items is low or make it easier to search the dropdown if there are a lot of items.

In fact, I see little point in not using all the available space !

This is so obvious to me now, but for example, it seems even VisualStudio designers haven't figured it out (btw, if you manually increase Intellisense's height, it will stay this way, but that's offtopic:))

Answer 23

I'll give one of my personal favorites: avoid dialog boxes at all costs. A truly good U I should almost never need to pop up a dialog box. Add them to your program only as a truly last resort.

For more, you might want to check out easily digestible ui tips for developers.

Answer 24

The Coding Horror Blog regularly gives great ideas. Just some examples:

• Exploratory and incremental learning
• Self-documenting user interface
• Incremental search of features/Smart keyboard access
• Task-oriented design (ribbon instead of menus and toolbars)
• Providing undo instead of constant confirmation

Another aspect: use scalable icons to solve the problem of multiple user screen resolutions without maintaining different resolution bitmaps.

Answer 25

I like to follow these 3 guidelines:

1. Standard - follow known standards/patterns, reuse ideas from all products you respect
2. Simple - keep your solutions simple and easy to change (if needed)
3. Elegant - use less to accomplish more