Modeled after OperatingSystemsDesignPrinciples.
The first thing to note is that almost all OS design principles are also UI design principles. For example, a UI should be
- distributed (as in ObjectBrowser inspectors)
- extensible
- reflective
- reversible
- uniform, consistent (all users see the same thing)
- self-documenting (games frequently have tutorials within the game)
- progressively disclose itself
- transparent scripting on top of direct manipulation
but quite a few of these principles have their own particular twists for UIs. For instance,
- political economics / realtime
- the UI should prioritize responsiveness above detail, and important details over unimportant details (a responsive UI is one that reacts within 100 ms to input)
And then there are principles unique to the design of UIs. Well, good UIs at any rate since every principle of good design that can be formulated has been violated at least once by some hack.
- DirectManipulation
- expressiveness -- express all of the underlying system
- directness -- express nothing but the underlying system (winamp violates this with its playlist editor)
- Proportional Cost - the more common an operation, the less overhead it should incur
- Expectedness -- no unexpected consequences ever, if the system and UI are reversible, this becomes: no invisible consequences ever
- Transparency - continuous transitions, transparency of commands
- Clarity -- avoid visual clutter
- Avoid Modes At All Costs, Even Quasimodes -- navigation and action commands should be orthogonal like in BlackAndWhite in a CLI user-interface, some modes can be useful. e.g. the "chdir" command -- though as a programmer, I wish that the concept didn't exist outside of the shell
- physicality
- visible causality
- unity of identity
- locality
- Don't ever blame the user!
Parsimony
- Present Only Business Objects -- an object is something that can be controlled explicitly, everything that isn't a meaningful domain object is overhead
- verbs aren't domain objects, you idiot! -- Squeak's UI was made by idiots
- no interfaces
- this implies 'nouns are objects, verbs are not'
- Present Only Meaningful Choices
- Don't Waste Your Breath
- don't repeat what the user already knows
- don't explain details the user doesn't give a damn about
- provide multiple levels of explanation
- don't shout features the user has given up using (like context menu items after the user has switched to the appropriate shortcut)
- Locality of input; the equivalent of OneTaskPerWindow? for those who appreciate that WindowsAreEvil.
- Never transfer overhead onto users. Control of overhead is overhead. User input about overhead is overhead. Don't create overhead for users!
Ideas:
- limit choices - one good way is better than a thousand better ways
- sensible defaults
- locality / associatedness - similar commands should be together, different ways to invoke a command should be together (menu, gesture, keybinding), also progressive disclosure
- Shortcuts shouldn't interfere with "long-cuts". Shortcuts are nice for power-users, but don't let them confuse newbies. For example, don't make auto-completion force a guess. Perhaps even turn it off by default if it may confuse some. Suggestion: make a link to the side that says "handy shortcuts". It can contain instructions and/or advanced time-saving options. Newbies will probably ignore it, and power-users or experienced users will view it when they are ready.
Its interesting (to me at least) that almost all of these principles apply equally when your "user" is another piece of code -- I.e. when you're designing a programmers interface. Its amazing how many APIs are difficult to use because they violate these principles (e.g. modelessness, expressivness, directness, expectedness, etc.)
That actually doesn't surprise me since I'm designing my OS and UI to respond in the exact same way to both users and programmers. It's a straightfoward application of ProgressiveDisclosure; people start off as ignorant users and the system progressively discloses itself to make them into programmers.
That's mighty rude to force (however gently) the user to become a programmer.
Would you say the same thing about reading and writing? That a system which gently forces the user to become a reader and writer is rude? Or how about typing? I'm not the first to speculate that programming is or will be deprofessionalizing. If I can help such a trend then that's a GoodThing.
Note also that the system doesn't force users to become programmers. That's not what progressive disclosure is about. Progressive disclosure is about showing the user the level after whatever level they're at, so that they're able to move to the next level.
"the system progressively discloses itself to make them into programmers." -- Note how there is nothing in that sentence to signify that this is an optional process. If you can't manage to write English clearly, perhaps you should seek someone who can.
That's because it isn't an optional process. Idiot. And I'm not going to bother trying to explain again. You can't understand, fine, why should I give a damn?
It isn't optional, but it isn't forcing the user to change. If what is displayed on my terminal changes over time, it is forcing me to change to interpret it. Or are you using NewSpeak when you write here?
two commonly violated principles
- steal focus / steal pointer; violates user control of Hand
- broken critical path -- pointer jumps to cancel on downloads -- violates proportionality, common operations should be simple to perform (canceling is not a common operation)
two principles that even most games violate:
- positionality over semantics; no semantics in interface? position is easier to see AND to remember than having to recall the name of some unit, figure out the first letter, etc
- use only accessible controls, under the LHS of keyboard in combination with mouse
direct/simple mappings - don't penalize touch typists, don't force mouse-keyboard switching
most games DO use these for camera controls. Evil Islands uses it for most controls; it doesn't exploit modifier keys appropriately
flash the screen if you need to get the user's attention. If it's not worth flashing the screen for then it's not worth a notification at all.
Either LOGARITHMIC or ZOOMABLE controls. The little position marker in winamp and media player are completely evil. They don't allow large leaps to skip a bunch of crap you don't want, nor fine-grained control. Even having two levels (middle 10% is per-second, the rest is normal) would've been sufficient.
constant feedback and constant relevant feedback (if you show basic build menu, and ALT accesses advanced build menu then show the advanced menu when ALT is pressed)
Not sure how to classify this problem, but I hate it when notices or warnings pop up with vague descriptions, such as "this process was blocked". What fucking process? Don't use "this", tell me the name, location, EXE path etc. of the offending process or program and/or window title, or at least give a button that gives more details.
CategoryInteractionDesign CategoryUserInterface
User Interfaces Design Principles