While preparing one of my presentations for the upcoming Sharepoint Conference I came
across this funny article.
Talks about the principles of poor UI Design (I thought I could be asleep here…so
I decided to read 2 words and not to risk me being in a winter hibernation slumber).
I admit I had a good laugh at this – so I’ll share. (my favourite is #6)
http://www.sapdesignguild.org/community/design/golden_rules.asp
Golden Rules for Bad User Interfaces
by Gerd Waloszek, Product Design Center, SAP AG – Last Update: 02/27/2007
The SAP Design Guild Website is full of guidelines and tips for good user interface
design, and it’s not the only one on the Web. Nevertheless, we see examples of bad
user interface design everywhere – many more than users would like to see. As people
like to do just the opposite of what one is proposing, we thought that it might be
a good idea to promote bad user interface design. Therefore, we collected “Golden
Rules for Bad User Interfaces” on this page – please help yourself (and do the opposite).
We started this page with ten rules and are continually expanding our collection.
Note: The rules are listed in backward order – the most recently added rules
come first. In all other respects, the order of the rules is arbitrary and does not
reflect their significance.
Golden Rule No. 14: Do not let users interrupt time-consuming and/or resource-hungry
processes.
Reasoning: Making processes that put the computer into agony more or less uninterruptible
ensures that users take their mandatory coffee breaks.
Example: Start a backup or indexing process while users are not aware of it.
Make this process hard to cancel, that is, let it ignore the users’ mouse clicks and
key presses.
Golden Rule No. 13: Leave out functionality that would make the users’ life easier
– let them do it the hard (cumbersome) way.
Reasoning: Additional functionality would provide users with too many choices
and might confuse them.
Example: When users want to add items to a list, allow them to add items at
the end of the list only and let them then move the items to the correct position.
That is, do not offer additional functionality for inserting items at their target
locations. To add some spice, introduce spurious errors that return items to the bottom
when users have already moved them half-way up.
Example: Do not offer the option of selecting multiple items, for example,
for moving or deleting items. The option of working on one single item suffices to
let users achieve their goals – apart from that it may take a little bit longer…
Example: After inserting a set of new items (for example, by command,
drag-and-drop or copy-and-paste) don’t show them as selected. This would help users
to recognize where in the list the items were sorted in. To detect the items that
were just inserted will consume quite some time, besides the pure recall of which
items were inserted. (Contributed by Oliver Keim, SAP AG)
Golden Rule No. 12: Destroy the work context after each system reaction.
Reasoning: Destroying the work context allows users to reflect their work and
ask themselves whether it really makes sense.
Example: Deselect selected screen elements after a system reaction (e.g. a
round trip).
Example: Move HTML pages or tables that have been scrolled down by the user
to the top after a system reaction (e.g. a round trip); in the case of multiple pages
(e.g. in hit lists or document list) return the user to the first page.
Golden Rule No. 11: Take great care in setting bad defaults: contrary to the users’
expectations, disastrous, annoying, useless – it’s up to you!
Reasoning: Bad defaults are a nice way to surprise users, be it immediately
or – at best, unexpectedly – anytime.
Example: Set default options in Web forms so that users get unwanted newsletters
or offers, have their addresses distributed, etc.
Example: Set the default option in dialog boxes on the most dangerous option,
for example, on deleting a file or format the hard drive.
Example: In forms, set dates (or other data) on useless default values. For
example, set the date for applying for a vacation on the current day.
Golden Rule No. 10: Spread the message of bad examples and live it!
Reasoning: Examples are a perfect teaching method. But as we all know, bad
examples are the best – they allure most.
Example: Just follow any of the other golden rules on this page, that’s a perfect
start.
Example: If you have to make presentations make sure that you include your
bad examples in the presentations.
Note: Good examples are hard to find and typically criticized until nobody
appreciates them anymore. Why waste time with unproductive discussions?
Golden Rule No. 9: Keep away from end users!
Reasoning: You are the expert and know what users need – because you know
what you need. Why should they need something else?
Example: If you think that a certain functionality is not needed don’t implement
it – why should other people need it?
Example: Many end users have many opinions, you have one. That’s far easier
and faster to implement.
Note: Doing without site visits saves your company a lot of time and money.
Golden Rule No. 8: Make using your application a real challenge!
Reasoning: This teaches people to take more risks, which is important particularly
in economically harder times.
Example: Do not offer an Undo function.
Example: Do not warn users if actions can have severe consequences.
Note: If you want to top this and make using your application like playing
Russian roulette, change the names of important functions, such as Save and Delete,
temporarily from time to time…
Golden Rule No. 7: Make your application mouse-only – do not offer any keyboard
shortcuts.
Reason 1: This will make your application completely inaccessible to visually
impaired users. Therefore, you can leave out all the other accessibility stuff as
well. That will save you a lot of development time.
Reason 2: This will drive many experts crazy who used to accelerate their work
with keyboard shortcuts. Now, they will have more empathy for beginners because they
are thrown back to their speed.
Golden Rule No. 6: Hide important and often-used functionality from the users’
view.
Reasoning: This strategy stimulates users to explore your application and learn
a lot about it.
Example: Place buttons for important functions off-screen so that users have
to scroll in order to access them.
Example: Hide important functions in menus where users would never expect them.
Golden Rule No. 5: Educate users in technical language.
Reasoning: Lifelong learning is hip. As many of us spend a lot of their time
at the computer, it’s the ideal stage for learning. Moreover, sociologists bemoan
that people’s vocabulary is more and more reducing. Applications with a challenging
vocabulary can go against this trend.
Example: Always send URLs as UTF-8 (requires restart) (advanced settings in
MS Internet Explorer)
Golden Rule No. 4: Use abbreviations wherever possible, particularly where there
would be space enough for the complete term.
Reasoning: Abbreviations make an application look more professional, particularly
if you create abbreviations that are new or replace commonly used ones.
Example: Use abbreviations for field labels, column headings, button texts
even if space restrictions do not require this.
Examples: Use “dat.” instead of “date,” “TolKy” instead of “Tolerance Key,”
“NxOb” instead of “Next Object,” and many more…
Golden Rule No. 3: Make it slow!
Example: There are nearly unlimited possibilities of making software slow.
For example, you can include long lasting checks or roundtrips after each user input.
Or you can force users through long chains of dialog boxes.
Golden Rule No. 2: Do not obey standards!
Example: Do not use standard screen elements for a given purpose, such as single
selection (e.g. use checkboxes instead of radiobuttons because they look nicer).
Example: Do not place menu items into the categories and locations they typically
belong to (e.g. place “Save” in the “Edit Menu”).
Golden Rule No. 1: Keep the users busy doing unnecessary work!
Example: It’s a “good” habit to let users enter data that the system already
knows and could provide beforehand.
Example: Let users enter data into fields only to tell them afterwards that
they cannot enter data there (e.g. an application lets you enter data on holidays
or weekends and tells you afterwards that you cannot work on those days).