Slashdot Mirror
User Interfaces in Free Software
Havoc Pennington wrote a piece on creating good user interfaces, with special attention toward GNOME 2. See also the advogato thread.
← Back to Stories (view on slashdot.org)
← Back to Stories (view on slashdot.org)
Right from the start I think that the free software movement was geared by geeks toward geeks, and it's become a game of catch up developing quality gui's and moving away from traditional cli's. Added focus in this area will surely see a boost in gaining mainstream desktop users and subsequently enthusing them with the free software ideal. Of course a pretty interface is excess baggage and can lead to bloatware, but surely it's imperative to the future of open source?!
A lot of people do not understand how themes and options do decrease the usability of the UI. If you are able to improve the UI significantly by changing a few options or applying a skin, then there was something wrong with the whole thing in the first place. People should not waste their energy on themeing engines or messy options dialogs (my favourite horror is the KDE control center) but focus on one UI style and make that the best. Rather one perfect UI than a dozen so-so ones.
The attitude of free software nerds towards useability is often the defining limitation of the spread of free software.
The fact that it's free should not mean that you should have to be a nerd to use it. Good useability is probably more important than correct functionality.
In a previous posting, I sum up what I think are the main reasons why Linux won't make it to the desktop just yet. Wrapping up my arguments nicely, the article was scored down as a troll.
-- Rolf Lindgren, cand.psychol
To quote Bertrand Meyer from his monumental book Object Oriented Software Construction:
Good user interface designers follow a more prudent policy. They make as limited assumptions about their users as they can. When you design an interactive system, you may expect that users are members of the human race and that they can read, move a mouse, click a button, and type (slowly): not much more. If the software addresses a specialized area, you may perhaps assume that your users are familier with its basic concepts. But even that is risky.
Which lead to the following design principle:
User Interface Design principle
Do not pretend that you know the user; you don't
Interesting article, or set of opinions.
The major stumbling block I see in free desktop software is it's inability to innovate much further than win32 or MacOs, but there's a reason for that.
It's called familiarity - to innovate too far, would be to alienate users, so it has to be a gradual process.
KDE and Gnome have improved enormously, but they are still lacking the cohesive feel that win32 and MacOS desktops have. IOW, things like keyboard shortcuts, copy and pasting text between applications etc. are virtually universal between all different applications.
The question should be asked, are features like transparent window borders, animated icons, slide-out-menus really neccessary for a productive desktop ?
Shouldn't more development time be put into creating an efficient, robust and stable work-horse desktop and less time on the fancy bits ?
There's another aspect to this - the UI 'hobbyist' or 'tinkerer' - the very people who support and participate in the development of free UI's sometimes seem to loose the most important idea behind a good UI - the end user. Much time is spent on the idea that 'total customisation' should be the end goal - is this flawed thinking ?
How many people really want to customise thier UI to the 9th degree ? - surely the majority of people simply want a plain and effective UI that helps there productivity ?
More customisation = more code = more bugs = slower UI
A slashdotting - you get the stick first and then the carrot !
As obvious as these sound, here are my rules for a good user interface on the work I do, whether it's a web page or a GUI app:
1) Keep It Simple Stupid
2) Think Like a User (the dumber the user, the better the UI)
3) Make it LOOK better than it WORKS
The last rule is true because if the app looks like crap, no one will be happy, but if it looks GREAT and works so-so people (users, your boss) will be excited and give you more time to get the bugs worked out. This is my main problem with someone like Jakob Nielson's whiny biatching... the app has to be simple, but it's got to have good design too. Colors, buttons, subtle eye-candy, well balanced spaces, etc. Usability is key, but design is always first.
Anyways, many of the people who work on open source software seem like the people who CAN'T STAND USERS. And by users, I mean the stupid, stupid people who might use their software. It seems pretty weird, but it's true... Maybe a little less antipathy for the newbies would go a long way to helping OSS GUI design.
-Russ
Me
The guys at work had a chuckle at the iarchitect.com User Interface Hall of Shame. If companies like Microsoft weren't featured it wouldn't be half the fun!
Everyone enjoys a scape goat; I noticed that a lot of university professors also reference this site in their online GUI course notes!
Anyone know of any other good "chambers of GUI horrors".
Torturé par la fenêtre.
consider coffee a lubricant that helps one penetrate the coding zone
Why? Because I use Windows NT all day long at work, so that's what I'm used to. Like the qwerty keyboard, 'doze UI may not be the best, but is what most people are most familiar with. This is not a silly attempt to generate flames. I think there is some merit to just conceding the "look and feel" battle to M$ and concentrating on areas where there is a competitive advantage, like security, or just developing quality free software, with no privacy-transgressing EULAs.
Of course, tinkering with window managers and desktop setups is still a fun pastime. :)
However, the Man-Machine Interface (MMI=GUI+CLI) is the front-ent between me and the computer. Better yet, is _the_ computer as I see it. And what I like about Gnome is that it is a reasonable good platform with a lot of components (panels, menus, applets) with which I can build _my own_ GUI. Which is surely not the best GUI. But is it the GUI which best fits my needs.
I whish good luck to Gnome developers in their quest. I just hope they don't loose the component approach they had up to now. And don't lock users in _their_ idea iof the best GUI (while I agree that too many preferences are evil).
Ciao
----
FB
Maybe libglade is what you are looking for. Glade generates an XML description of the UI which is used to generate the UI code. Libglade reads the XML file at runtime to generate the UI instead, so you can tweak that XML file without having to touch your code.
/Janne
Trust the Computer. The Computer is your friend.
Didn't the Gnome Usability study done by Sun cover a lot of the shortcomings of the current GUI? It showed that the GUI was indeed created by geeks for geeks.
The report can be found here.
In the last few weeks, my hosting co's ftp software has been randomly giving me errors that suggest it doesn't know how to list a directory, put or get a file. Not that I need any of those features anyway, so I did some research and ended up installing ncftp (Mac OS X installer pkg). I realize ncftp's not a new program, but I am amazed.
It has everything I've ever wanted in an FTP client: speed, easy-to-use "bookmarks" (no more dumping passwords into clear .netrc files or entrusting them to Apple's security-hole-prone Keychain), status reports on transfers, and I can even use wildcards to up/download a whole mess of files at once without having to sift through ftp's man pages. Everything works intuitively, and I suspect there is much more I will discover just by using the tool.
I guess that's what a great UI is -- one that you can use and learn without having to RTFM.
(Before you reply in defense of the RTFM concept, I agree that there are types of software that should not be used until one has RTFM, but it doesn't hurt to give the FM a great UI.)
I've read many programmers views and opinions of UI. What they say and what they do are two different things. I mean, i'm about as qualified as any programmer to comment on UI but no matter what Havoc or anyone says about Gnome and it's usability I disagree terribly.
1. Things are as usable and only usable when people can generally agree on operation or functionality. If only 10 people agree on usability no matter how smart you believe you are, it won't be usable. The most usable applications, cars, planes, clocks, or whatever got that way through the users being able to say, "I want this and I want that". Just because you don't think it's a good idea or it will slow down performance or whatever doesn't mean you should keep those ideas out or wait to act upon them, especially simple things. This is what I see on the Gnome usability list.
2. There is no such thing as a beginner, intermediate or advanced user when it comes to usability. Sure, people need to become accustomed to a new interface but the interface should always be made so that a total newbie could walk by and get the hang of it in little to no time at all.
3. Suns usability team created CDE; have you used CDE? Was it usable to you? Ok.. I won't talk about that anymore and no offense to the Usability guys I'm sure you know more about this than I do but CDE just was not a usable product.
If you want usability in gnome I think you have to start with the basic shit. Like havoc said no one likes doing mundane work but until I'm able to drag something from Nautilus or GMC into my menu or for that matter edit my menu without being root Gnome is less usable.. It's the tiny things that count and I think that Gnome in general has neglected the tiny little things.
Would you rather jump through your window to get out of your car or use a latch mechanism to open the door?
How on earth am I expected to come up with decent user interface? I'm a geek, I don't even have a decent human interface!
It is strange how many OSS fans relate to such things: On the one hand, they do not accept strict guidelines that tell you how an application has too look or behave - for them it is taking away their "freedom". OTOH, at the same time they're very strict and disciplined when it comes to following technical guidelines like RFCs, IEEE and W3C standards. No, I did not say hippocrats. But I did think it.
Okay, I was thinking about this offline and I wanted to add that there's a perfect opportunity here for an OSS startup:
Give it a cool name like "SimpleFace" or something non-frightening like that (i.e. real words).
Then this company would do three things (complying to KISS):
1) Create a set of rules and guidelines for GUI applications along the lines of Apple's Human Interface guidelines. Include all of the most recent theories and practice. Publish this online. Use versions so that people can tell what's the latest draft, etc.
2) Certify apps that comply to the SimpleFace rules. Open Source Software gets certified for free. Certify non-free software for a fee. They get to put a SimpleFace smile icon on their web pages or boxes.
3) Create a set of classes - both online and corporate training - based on the guidelines. Some for free, others for a fee.
Once momentum started building on something like this, corporations would be more willing to switch to OSS software if they knew that training was going to be minimized because the apps that use the SimpleFace guidelines would be easy to use for those already familiar with other SimpleFace apps.
SimpleFace could also actively participate in the other projects as a GUI testing center. Whereas the rest of the OSS crowd might not pay attention to usability and design issues, SimpleFace would be there to help out. Providing feedback, suggestions, or even app dev for those interested.
Why am I thinking "startup" and not just "movement" or "organization?" because I think that something like this is needed now before the OSS movement loses any more momentum in the UI race from companies like M$ and Apple. (Under the theory that a startup could move faster than a committee.) How many Unix heads do YOU know that are switching to Mac OSX because their GUI is awesome? Lots.
-Russ
Me
While I agree with much of what you write, I think the distinction between "average" users and "power" users is an important one. (I dislike "beginner" and "experienced" because that's not really the issue; often, some beginners will immediately want to learn all the tricks, while some experienced users will never need them.)
To take a prime example, and one of my pet peeves, consider the interface for your file system. On many systems, you can have a CLI with commands to do things like copying or renaming files, creating directories, etc., and you can have a GUI interface with folder windows and so on. Most users are happy using the folder windows most of the time, experienced or not. I'd much rather browse my file system with something like a tree view and file list combination than with a CLI and constant use of ls or dir commands, and I doubt I'm alone here.
OTOH, suppose you want to create a new folder at me/one/two/three/four/new, and currently all you've got is me. It's faster to open up the CLI and use a command that can make five directories in one go than to create one in the GUI, open it, create two under it, open that, and so on. Anyone who's tried to rename "*.doc" to "*.bak" using a windowing GUI is probably familiar with the problem, too: a few seconds at the CLI, a few minutes in the windowing system. And hey, when's the last time you saw regular expressions being used in a GUI? ;-)
So I think it's fair to say that some applications are universally required in some form, and that sometimes, different perspectives on the same functionality are more useful to different people (or to be more correct, are more under different circumstances, and it just happens that some people encounter those circumstances more than others). They key thing, though, is not so much the functionality -- you can rename a file in either a CLI or a GUI -- but the way(s) you provide that functionality to the user.
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
Since mpt's (Matthew Thomas) website seems to be down, I'm mirroring his first 9 points here:
There are another 5 points that he added today, but weren't in the google cache.
If you're interested in his writings, please check his site after it comes back up from being slashdotted, as he clarifies some points that upset some people.
"Why Free Software usability tends to suck"
I've been having a discussion with someone from IBM about whether it's ever possible for for Free Software to have a nice human interface.
In theory, I think it is possible. But in practice, the vast majority of open-source projects are also volunteer projects; and it seems that the use of volunteers to drive development inevitably leads the interface design to suck. The reasons are many and varied, and maybe one day I'll turn this into a long and heavily-referenced essay. But in the meantime, here's a summary.
1. Dedicated volunteer interface designers appear to be much rarer than their paid counterparts -- and where they do exist, they tend to be less experienced (like yours truly).
2. First corollary: Every contributor to the project tries to take part in the interface design, regardless of how little they know about the subject. And once you have more than one designer, you get inconsistency, both in vision and in detail. The quality of an interface design is inversely proportional to the number of designers.
3. Second corollary: Even when dedicated interface designers are present, they are not heeded as much as they would be in professional projects, precisely because they're dedicated designers and don't have patches to implement their suggestions.
4. Many hackers assume that whatever Microsoft or Apple do is good design, when this is frequently not the case. In imitating the designs of these companies, volunteer projects repeat their mistakes, and ensure that they can never have a better design than the proprietary alternatives.
5. Volunteers hack on stuff which they are interested in, which usually means stuff which they are going to use themselves. Because they are hackers, they are power users, so the interface design ends up too complicated for most people to use.
6. The converse also applies. Many of the little details which improve the interface -- like focusing the appropriate control when a window is opened, or fine-tuning error messages so that they are both helpful and grammatical -- are not exciting or satisfying to work on, so they get fixed slowly (if at all).
7. As in a professional project, in a volunteer project there will be times when the contributors disagree on a design issue. Where contributors are paid to work on something, they have an incentive to carry on even if they disagree with the design. Where volunteers are involved, however, it's much more likely that the project maintainer will agree to add a user preference for the issue in question, in return for the continued efforts of that contributor. The number, obscurity, and triviality of such preferences ends up confusing ordinary users immensely, while everyone is penalized by the resulting bloat and reduced thoroughness of testing.
8. For the same reason -- lack of monetary payment -- many contributors to a volunteer project want to be rewarded with their own fifteen pixels of fame in the interface. This often manifests itself in checkboxes or menu items for features which should be invisible.
9. The practice of releasing early, releasing often frequently causes severe damage to the interface. When a feature is incomplete, buggy, or slow, people get used to the incompleteness, or introduce preferences to cope with the bugginess or slowness. Then when the feature is finished, people complain about the completeness or try to retain the preferences. Similarly, when something has an inefficient design, people get used to the inefficiency, and complain when it becomes efficient. As a result, more user preferences get added, making the interface worse.
Where a project is heavily influenced by a company under commercial pressure to ship a usable product (such as Netscape, Eazel, or Ximian), you'd expect the interface to improve as a result. But in such projects so far, it would appear that the opposite has happened. I think this is partly because the companies involved aren't large enough to employ designers who are both smart and stubborn, and partly because the business model of the companies involves maximizing the revenue (rather than the user satisfaction) gained from the interface.
From the article: I don't have any genius definition of "good UI"; I'm not a UI expert.
Super. I stopped reading right about there.
The article lists these issues as why Free Software UI sucks.
Hello? Where is the #1 reason?
Sure, developers write things for themselves. Developers write things for their co-workers. But do developers of Free Software really go out and research the goals of their users?
In looking at Linux user interfaces, I see that most tools merely tie some toolkit strings onto the underlying code so that it can be manipulated. The current thinking seems to be that if the underlying driver can do something, expose that ability directly on the command line or in a preferences dialog box.
A great case-in-point is cd-burning software. Type (cdrecord --help). The typical GUI wrapper is just the Gtk equivalent of (cdrecord --help). A massive soup of options with little help for people who don't know what a leadin is, don't care what a TOC is, don't understand how the lovers Romeo and Joliet got into CD-burning, and don't understand whether they want to fixate the disc or not.
Instead, turn it over.
Make some archetypical example users of your application. Nate the newbie. Seth the secretary. Judy the junior admin. Devin the developer. Whoever it is that needs your help to accomplish their goals, get to know these people.
A useful CD burning tool doesn't need to expose everything the driver can do. Add music files here. Add data files or folders here. Might you want to add more files at a later date? Burn the disc.
In Alan Cooper's words, "don't make the user feel stupid."
A user interface needs to start with the user, and proceed to the interface.
[
Don't get me wrong, Apple do some good work with UI design, but to pretend that they have the most intuitive UIs is naive. When I first started using my friends Mac, he had to sit next to me and constantly remind me to close the app manually, which button means right click, and so on.
People waay overrate the Mac as GUI perfection. Open software shouldn't just copy it mindlessly.
Guidelines are guidelines. They are not hard and fast rules.
... need more examples?
/.ers about copying MS and how "wrong' it was.
Standards are standards. You screw with the implementation of a standard and your application is worthless.
You screw with the UI and it may be ugly or less user friendly, but it still works.
Most developers follow the basics regardless of OS - File, Edit, View, Help is always the last menu item on the menu bar. "File|Open", "File|Save", "File|Print"
IIRC, the last time someone emulated MS and followed guidelines (Ximian's evolution) there was an outcry from
Dammit, make up your minds!
And we won't even discuss the "Look and Feel" lawsuits in the early 90's when people emulated other UIs.
I don't have a solution, but I certainly admire the problem.
The real problem is age and how "applications" are taught in schools, the enterprise and classes.
Schools teach children to use applications specifically. No one sits down and explains to them the concept of a file and actions that apply to a file (open, save, save as, print...) or editing (copy, cut, paste, etc.. )
If the process of educating people in the realm of computer use included a more abstract view of computers and how they work, the average joe schmo wouldn't need to "relearn" every time a new UI design came out, they'd be able to reason through it.
We moved our 8 year old daughter and 14 year old son from Windows to SuSE and Gnome, respectively. With the exception of not knowing the names of applications that do what she wants, she can get around just fine because we've taught her the basics, without being specific to an OS. She knows how to manipulate files and open applications, she understands that web browsers and can use IE, Netscape, opera or Galeon with equal ease.
This ease of adaptation is partially due to commonlality of UI implementation across applications and platforms, and partially due to their education @ home, which focuses on exploration and understanding the computer rather than a specific application.
Of course, if schools/enterprises did that, M$ would lose its edge because users would no longer be frightened to death when presented with a word processing app other than Word, or a browser other than IE.
I don't have a solution, but I certainly admire the problem.
IMO the UI of KDE is getting too complex (I know it better than Gnome). So the task is to clean it up, give useable defaults and simplify it. Especially the KDE-menu and the KontrolCenter should be cleaned up.
But what should be removed? What is a good default? Let's ask the user. KDE could collect information on what is used and how the prefs are set, and send it back to the developers.
I think noone would have a problem with that as long as: The info is anonymous, only sent with explicit consent, and it is stated clearly what information is sent.
'Perfection is achieved not when there is nothing more to add,
but rather when there is nothing more to take away.'
(Antoine de Saint-Exupery)
You can increase the apparent simplicity and focus of an OS
simply by consolidating five menubars into one.
--| INTERFACE DESIGN > A SINGLE MENUBAR |-----
>> WHAT? Give me the summary.
A SINGLE MENUBAR AT THE TOP OF THE SCREEN that changes according to
the current context (window) instead of a menubar for every window.
Setting this as a User Default will improve Linux's ease-of-use.
Placing a single Menubar along the top of the screen:
1 - Makes it faster and easier to hit.
(no mouse overshoot to slow things down)
2 - Eliminates clutter in the interface.
3 - Reduces ambiguity (and hence - user error).
--| DISCUSSION |---
>> LINUX MENUS WORK GREAT NOW.
>> WHY SHOULD WE DO SO MUCH WORK TO CHANGE THE ACCEPTED DEFAULT?
In programming, if you compute a static variable within a loop - it is
highly innefficient - it slows down the loop. You optimize code by pulling
all the computes you can out of the loop and processing externally.
Interface design is the same. If a user has to click: A, B, C three hundred
times a day - it would make him 3 times as efficient to collapse those three
steps into a macro and execute with one keystroke. Making things less steps
for users optimizes the UI just like computing static variables outside the
loop optimizes code.
Since Menus are one of the most frequently used items in an operating system,
optimizing something small in this frequent behaviour equates to a Big savings
for the user over time. Therefore getting the menus right is one of the most
crucial and fundamental UI decisions that must be made by those implementing
the OS.
Linux currently imitates Windows' menubar implementation of putting a menubar
in every window. UI studies show this is not the optimal way of implementing
menus in an operating system. Linux can beat Windows in menubar GUI by providing
the option of a single context-sensitive menubar. There are several good reasons
for doing this:
1 - TARGETING CONSTRAINT
How easy it is to hit a target - virtual size.
2 - CONSISTENT PLACEMENT
How easy it is to remember "where" a target is.
3 - SIMPLICITY KEEPING FOCUS
Elimination of extraneous controls that are not
relevant to the current task at hand.
>> See the rest of this posting - Why Single Menubar
best regads,
john.
I've heard many such arguments before, but I can't help thinking that you're mixing up a good idea (simplify the menu system) with a particular implementation that you're stuck on (top-of-screen menus, a la MacOS). How about a single, context-sensitive menu accessed from a right-click with the mouse? No, wait, we've already got one of those. So, how about having an application menu and a context menu off a right-click, with subsequent right-clicks alternating between them? And so on...
While I'm not necessarily advocating any of these ideas as "better" than the top-of-screen layout, they would appear, at least superficially, to have many of the same advantages you cite in your article: reduced clutter, easy to find (always where your mouse pointer is, some eye-catching animation to make it obvious when you click?), etc. Surely what is needed is a comparison between not just the status quo and a top-of-screen system, but between many different basic ideas, to see which are more intuitive and easy to use for the guy in front of the keyboard/mouse?
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
Why do geeks and especially graduate students insist on refering to themselves by their three initials, such as the article's author mpt (Matthew Thomas)? My theory is that they are vain and pretentious. To assume that THEY ALONE would be uniquely identified by some three letter abbreviation is quite an assumption of their self-importance..
cpeterso
The installer is always the first part of your UI that the user sees. Unfortunately, it may also be the last.
In many cases the question of "why should the end user be installing anything in the first place?" is totally ignored. No-one demmands that cars must be end user servicable. Or expects the typicall office worker to install their own network, telephone and power sockets, let alone assemble their own office using bricks, wood and plasterboard.
But suddenly when it comes to computers it's vital that everything be end user installable (even if it results in making the job of real sysadmins considerably harder.)