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).