Slashdot Mirror
How To Fix the Poor Usability of Free Software
flosofl writes "Matthew Paul Thomas has an entry on his blog called Why Free Software Has Poor Usability, And How To Improve It. While this advice is helpful and may indeed lead to improvements in many open source programs, the guidelines may be much more difficult for smaller projects. From the entry, 'Free Software has a long and healthy tradition of "show me the code." But when someone points out a usability issue, this tradition turns into "patches welcome," which is unhelpful since most designers aren't programmers. And it's not obvious how else usability specialists should help out.'" Thomas has been developing the ideas in this essay for years. The critique is comprehensive, listing 15 challenges in the way software projects, and in particular free software projects, are structured, with suggestions for improving each one.
Usability is mostly a function of what the user is used to (no puns intended). I find working from a command line to be the most efficient way to get things done, which is in opposition to most of the world. I don't really think it's possible to quantify "usability" when to most people it's best rendered as "similarity to Microsoft products."
The kind of additional functionality added for usability reasons are usually looked down on because they can fall into scope creep, but I think they're quite the opposite. I think most coders look down on these kinds of suggestions because they don't affect how they use the program. And, truly, most people who work on open source code do so because they themselves want the functionality they're coding for.
To them, if it does the job, great. And I think many of them have a similar response to usability problems as those asking for ports to different operating systems, or even a binary: "Not my problem, it works for me and that's enough."
Not to mention that, in many cases, what increases usability to a larger audience is reducing efficiency to the programmer who designed it to suit how they work.
Mainly that people who are interested in coding free software and people who have a great understanding of ergonomics and aesthetics in software are usually just not the same people. I've known plenty of coders whose idea of usability is to configure it for their personal preferences and that's it, but on the other hand, I am sure most people who really understand what is needed for usability couldn't code "Hello World!" in BASIC.
http://twitter.com/OLDTELEGRAM
Perhaps this article signifies the movement that has occurred with open source software. Whilst I'm sure it's been around a long while, there has been a huge increase in what's available in the last few years. Open Source software is maturing as most things do when they get older.
I'm happy with the 'get it working first - then make it pretty' approach taken by most.
The Mothership
UNIX programmers (the majority of FOSS developers) design software the way that they would want it to be used. It makes sense to other programmers and it is actually probably the simplest way to operate if you have the base knowledge. Users, on the other hand, focus less on the architecture of the software they are using than on the front end. Windows and Mac OS X systems and applications are easy to use because the front end has been designed to meet all usual purposes, even if it cuts back on the functionality. Linux and most UNIX systems and applications are harder to use because they are built with the architecture of the code in mind. A good UNIX program can easily work with other UNIX programs, and a good UNIX program is made as general as possible to maximize speed and reduce bloat as the program advances. A 'good' Windows program is made for only one cycle, not the entire development lifetime. Firefox is a good example of a program that meets both the UNIX and the Windows definitions of a good program. But Firefox is very rare, and there have been multiple revolts over de-generalizing the code for a single release.
I think application programmers should keep the Firefox success in mind when they develop code, even though it will be much more expensive and time consuming than the UNIX mentality since they will have to keep stopping what they are doing to release and polish versions for users (essentially dead forking every couple of months).
I'm going to take issue with this. Basically you're saying if you can't do X, then your critique is useless. Just because you can't sing doesn't mean you can't critique other people's singing. Just because you don't know how to make a car doesn't mean you can't critique that horrible dashboard layout.
Okay, I know these are unpopular things to say, but I feel they need saying. These are just my opinions.
(1) "Usability" is in the mind of the user. If you learned how to use some other system first and now expect that any other way of doing
things isn't "usable" enough, that's just plain old resistance to change. It says more about you than it does about the usability of the software in question.
It seems you've never used emacs, little one.
And no, it doesn't say more about me than the software if I find that almost all GUIs in Linux are shit and that the command line is more usable.
(2) "Designers" who can't code have absolutely no business "working" in software. If you think you really know how an interface should work and look, then learn to code it. Otherwise, you're just a critic of the kind that the NYT doesn't hire.
"Right."
And neither have "coders" who can't "design" something the "average" "user" "thinks" is "usable" .
Bull crap. An architect doesn't build the building, the carpenter does. An electrical engineer working for the power company doesn't hang the lines, but they layout and design them.
The same thing can go for almost any profession, software included. I don't code and no desire to code (I'm a chemist and have no interest in that part of computing), but I can tell you when the interface sucks and what could be better.
My opinion is, people who won't accept criticism from others because "you don't code," or "you don't know what you're talking about" are nothing but elitist.
Gone!
My suggestions: start a Usability Level Group where one can see which level of usability the application has ( for platform X).
Things to consider (remember: using starts with considering installation):
-does it compile cleanly?
-is it pre-packaged?
-is it in the standard repositories?
-is there a manual and man page
-are there examples which can be followed
-(if relevant) are there screenshots
-are all options of the application available in the GUI
-let people vote about the quality of the above
First you have to obtain a means to measure usability (by the users is best, I guess).
nosig today
Usability isn't supposed to be tied to the way you're used to do things, but to how intuitive it is.
Let's take an old tired "cliché", if you will. Having to click on a button labeled "Start" to then choose "Shutdown" isn't obvious and must be learned.
An old version of Quicktime had the volume control as a rotary dial. Yeah, that went well once translated into mouse control. That's why it was gone by the next version or so.
Make clean interfaces with well-organized controls (keep it to a minimum, to what's required for the current task), label things properly if needed (not everyone knows how to use your programs) and don't overload the users with choices (have a "normal mode" and "expert mode", if needed).
Other than that, use the OS's own widgets and don't force your "pretty graphics" onto your users. Slashdot's own form buttons come do mind (the Preview, Quote Parent, Options and Cancel buttons really seem out of place with the Aqua form widgets and probably with all the other OS widgets as well).
At the bottom the article links to John Gruber's "Ronco Spray-on Usability" article, which also provides a lot of background on the challenges of good interface design.
In the original article, I think the most important point is number 8 - "Scratching their own itch." I can see how programmers interested in, for example, having a stable and scalable web server would work on Apache. I don't see the same passion coming from a human interface designer to fix, for example, the horrible user interface for joining wireless networks on desktop linux.
In my opinion the only way the user interface will get fixed is if Ubuntu or another distro pays for expert user interface folks to fix UI issues. I don't see the volunteer community being up to the task.
- "When you want something with all your heart, the entire universe conspires to give it to you" -Paulo Coelho
(2) "Designers" who can't code have absolutely no business "working" in software. If you think you really know how an interface should work and look, then learn to code it. Otherwise, you're just a critic of the kind that the NYT doesn't hire.
Why should software be different from any other industry? Just because the barrier to entry is, in your opinion, lower? The people who design houses don't build them. Sure, they need a solid foundation in what can and can't be done, but architects and interior designers work to a mutually beneficial end with builders, carpenters and plumbers, etc.
(1) "Usability" is in the mind of the user. If you learned how to use some other system first and now expect that any other way of doing
things isn't "usable" enough, that's just plain old resistance to change. It says more about you than it does about the usability of the
software in question.
You are a good example of the "works for me" mentality in the open source software community. "If it works for me, then it must work for anybody else, and if it doesn't, it's their fault".
(2) "Designers" who can't code have absolutely no business "working" in software. If you think you really know how an interface should
work and look, then learn to code it. Otherwise, you're just a critic of the kind that the NYT doesn't hire.
I'm sorry, what? Did you just say that if designers can't code, they shouldn't contribute? I thought this open source stuff was about the fact everybody could contribute to the program if they wanted, but apparently I thought wrong. Apparently only uber-geeks with a masterful command programming knowledge can work to improve open source software.
Design is important. Not everybody wants to learn the idiosyncrasies of software; they want it to "just work". The moment everybody thinks that way is the moment open source software gets better.
That article hit it on the head. There's 1001 programmers in the world, who are excellent coders and whip through the strings like a first chair, but there's very few project designers in freeware. They concentrate so much of function (which, yes, is critical!), but forget about ergonomics and userability (especially *how* end users can and will use their product, and ways to cut out excessive keystrokes or right clicks). The end users winds up getting a proggie that can function well, but such a chore to operate (or even painful, if it not ergonomically friendly). As we more and more get "connected" to computing, it's no longer just being on a keyboard or using a mouse an hour or two a day. Now it's more like 8+ hrs. Programmers need to consider the impact of their software, and beyond how it functions itself, but the whole project. That's where product design is so crucial, and something not just best left up to management to figure.
(2) People who can't cook have no business eating food and complaining when it makes them puke.
Why does my post history abruptly stop? I want to laugh at the stupid things I posted as a kid.
You seem to confuse usable with usability. Just because something can be used, doesn't mean it is the best option. By your logic we would all be using rocks to pound nails because, "It works, you just have to think a little bit." Being intuitive means that people want to use it that is the point. Unless of course you don't want people to use your product and if that is the case, why are you publishing it publicly?
Your second point is rather funny to me. I wonder if you would say, "If someone doesn't know how to design an engine they have no business designing the rest of the car(oblig. car reference)?" People have specialities, that is how society works now.
Finally a red herring is irrelevant, we are talking about Linux not windows. I don't really like windows either but that is another discussion.
I am a UI designer by trade, and many is the time I have thought about wading in to a F/LOSS project in order to improve the usability of the interface (last one I considered was IPCop). While I agree with most of TFA, it doesn't seem to emphasise the real point for me, which is that UI design for free software requires radically different skills *from the designer* to that which are necessary in the commercial world.
Because people are so tolerant of awful UI, good UI designers are all about persuasion, charm, leadership and inclusiveness without losing focus. To achieve this commercially is not easy, but at least somebody has hired you in an expectation that you will do this work. Grabbing a bunch of elite coders and trying to persuade them to change their stuff is a massive challenge, even if you have VoIP, virtual whiteboards, etc. I would not expect maintainers to understand, appreciate or tolerate my intervention, mainly down to the reasons the article cites, and I'm not sure I'd be able to persuade them otherwise. Usability is not obvious and often requires a leap of faith, an abandonment of the wrong kind of complexity, and very often a lot of pain.
Still, the more we have these discussions, the better, and I hope the article gets read by a lot of Slashdotters for that reason.
"And the meaning of words; when they cease to function; when will it start worrying you?"
1) "Usability" is in the mind of the user.
There's some degree of truth in that, but since most people have essentially similar minds it makes sense to assume that certain types of operation make sense to the vast majority of people. Past experience can lock people into a certain conceptual mindset, there's no denying it. But the holy grail of usability is that which most closely reflects the way in which we have evolved to think.
All computers are essentially tools to enable us to do things we otherwise would not be capable of, or would take much longer without. The best computer systems are the ones which interface as organically as possible with that which we are capable of. It's common sense.
(2) "Designers" who can't code have absolutely no business "working" in software.
That's ridiculous. If it weren't so absurd it would be offensive. Look at the credits for any major software release from the commercial realm. Let's take games, for example - in the entertainment industry, where if something is not 'usable' it is not fun, coders are outnumbered somthing like 20 to 1 by other types of developer, be they writers, artists, testers, etc. Hell, let's take the credits from GTA IV, the video game. They take HALF AN HOUR to scroll, when you complete the game. What percentage of those HUNDREDS of people do you think can code? Even to a reasonable level? Five to fifteen percent at the outside.
When you need a job doing, you hire the person with the skills to do that job. You DON'T hire someone with the skills to do that job AND the skills to code. Sometimes that's not even desirable, and at best it's overkill.
Mod parent up. The whole source of this problem is that most programmers can't design (or follow UI guidelines), but they think they can. On the flip side, I've seen a lot of designers who can sort of code makes some really god-awful programs that look great that are less optimized than doing it by hand.
I can't design and I know it. But I still know when someone else's design either works or fails utterly, and I'll give the designer props/shit accordingly. Typically, coders are very poor designers and designers are very poor coders. There are the rare exceptions of course, but they're off making too much money to devote time to free software (the single exception that I know of being the designer+developer of Quicksilver).
Widely-used Free software occasionally picks up enough steam to get some people who can really design on board (read: Firefox), but by and large, Free software tends to be developer-centric, menu-driven apps that work very well if you can figure out how to use them. As a developer I often can, but I still tend to suggest people use the paid equivalent if they ask simply so they don't come back to me every hour asking how to do that next thing.
How are sites slashdotted when nobody reads TFAs?
Poor usability? Is there really anybody who thinks that Internet Explorer 7's user interface is better than Firefox 3's?
I'm getting tired of hearing this over and over again. For example, in the past 7 years, GNOME has invested an insane amount of effort in usability. Go read about all those professional GNOME usability studies that Sun has funded. Also, go read Ubuntu and "desktop environments", written by the same author who wrote TFA. In that article, he criticizes people for wanting to include a configuration option in Ubuntu's installer which asks the user whether he wants GNOME, KDE or XCFE. He argues that such a choice is simply too confusing to most non-technical people. And indeed, people like my dad and mom don't know, or want to know, what GNOME is.
In the past 7 years, GNOME has done its best to address exactly that kind of criticism. Almost every single feature is scrutinized with usability in mind. GNOME has been removing more and more configuration options from the user interface in order to make things easier for the average user. In fact, they've done so much their best that the technical audiance, i.e. Slashdot/OSNews/Reddit, is constantly flaming them for removing config options. Yet this same audience is flaming them for not being usable.
KDE, too, has invested a lot of effort in usability. But what's the community doing? Instead of offering helpful feedback, perhaps mockups or even professional usability studies, they're flaming the developers. By flaming, instead of offering useful feedback, they're discouraging the very people who made the software from improving it. And you're wondering why they're having a hard time?
Go figure.
Humans have overall tendencies in what they find easier and harder to use. For example most people find it much harder to memorize lines of commands than to look through a set of icons, hence one of the reasons why GUIs are popular. There's real empirical research that has been done on this, some by psychologists, some by companies like Apple. While you may fall outside the norms for various reasons, that doesn't mean they don't exist.
You also need to be careful in thinking that because you've taken the time to learn something, that means that it is easy. For example I drive a manual transmission vehicle. I have no problems doing so, it is second nature to me, no more problematic than an automatic. However, I am not going to say it is as easy. I remember a rather frustrating learning period when I was getting used to the feel of a clutch and how to shift. It is easy now, but only because I have a lot of experience. It is NOT an easier way of doing things.
I find this kind of thing fairly prevalent in the OSS world. You'll need to do something and someone will say "It's easy!" and then give a couple commands to run. To them, it does seem easy, because they've trained themselves on it, however that isn't. To a new user that's very hard and uninviting.
Ignoring this issue doesn't help free software. Telling people "It is just as easy you just have to learn it," when it isn't doesn't help, they'll just ignore you. The author is trying to say that OSS people need to stop with this attitude that it is just as usable, or that usability doesn't matter to popularity. If you want OSS to start to become the dominant way of doing software, you have to make it as easy to use for the non-technical masses as possible.
(1) "Usability" is in the mind of the user. If you learned how to use some other system first and now expect that any other way of doing things isn't "usable" enough, that's just plain old resistance to change. It says more about you than it does about the usability of the software in question.
That is of course true if you are talking about design by the decree of an individual, but that is not "design" in the way most practitioners define it. The currently accepted approach is User Centred Design, which basically means that the cumulative indications of many target users are derived through various research techniques. The outcome of this research is modulated by the designer in coming up with the design, but fundamentally, the designer's own opinions are irrelevant.
The upshot of this is that (for example) if a CLUI is found to be the way to go, then a CLUI is shall be. If it's voice-control the users need, then that's cool too. Notice I said "need" there, not "want." Here by dragons.
"And the meaning of words; when they cease to function; when will it start worrying you?"
I assume he was forced to respond to them, because otherwise he wouldn't have been paid.
Those using pirated Tinysoft signatures(TM) are a real threat to society and should all be thrown in jail.
The issue is more general than that. The usability experts who can't code *can* improve usability, by telling the developers what to do.
It's more of an issue of *just* criticising, instead of offering constructive opinions. If all you can do is say "this sucks" but not say why or how it can be improved, then I agree, you have no business in software. If, on the other hand, you can find a way to improve it, I'm sure many people will welcome your advice and implement it.
Send email from the afterlife! Write your e-will at Dead Man's Switch.
There seems to be a whole movement who's against the "patches welcome" statement. I fail to understand this.
I'm an open source developer. Look at it from my point of view. I've written software that people find useful. It's not perfect, but it's useful. Then, one day, someone criticizes my software:
Person X: [...] this and this sucks [...]
Me: patches are welcome
Person X: what? what an unhelpful response! no wonder open source sucks, and you suck too!
Now, tell me. I have a job. I maintain this software in my free time. Why should I devote that time to you, for free, instead of, say, hanging out with friends or seeing a movie? You're not paying me for this software. You probably would go away if I ask you to hire me. What exactly do I owe you? I already made the source code available. Why do you criticize me for not working for you for free? Why don't you do it yourself, or hire someone to do it for you? If you can't do either of those, why don't you contribute documentation, mockups, or something else that's not technical but is still useful? Do you expect a baker to give bread to you for free when you criticize his breads for not being tasty enough?
No, you can tell us that you don't like an interface, and make suggestions on what you think might make it better for you. Reality? The interface may suck - but that doesn't mean you have any idea as to why it sucks. Add to that? You're suggestions are not likely to be all that good for fixing the design problems. A non-chemist can tell you that the floor cleaning solution doesn't work for them - and that may mean the solution sucks - and they can say "It should be able to do this" - but they can't tell you the way to solve the problem, they may be wrong as to what the problem is, and they may just be, period - wrong. Is that elitist?
People just need to become willing to pay for free software. The problem is right now, most people, even the OSS heads on Slashdot, aren't as interested in free as in speech but more interested in free as in can I crash on your couch. There is this real resistance to paying for open source code. I don't mean things like enterprise support contracts, I mean paying for a copy of software as is done in the commercial software world. Even when it has been tried, it doesn't go well. Look at Sveasoft, for example. They wanted to modify the Linux based Linksys routers, and sell their modified software. However they didn't sell much, because people bought it, recompiled it, and then distributed it for free. This is all perfectly legal per the GPL, of course, but you can see how an attitude like that makes it very hard to sell free software.
Well, if that attitude changed, I think perhaps more groups would be willing to work on it. You could hire designers, artists, etc to work on a project because it is something you could use to generate money. You'd still include the code so people could modify it to their heart's content, however you'd understand that most people were going to pay you if they used it.
Unfortunately, I see a lot of resistance to that. It seems that most OSS people think software shouldn't cost anything every. Well, with an attitude like that, it is going to be more of a hobbyist pursuit.
In my experience, most of the people who complain about these sorts of things do so because the new app lacks some key feature that makes their workflow better. Dismissing someone's opinion simply because they have actually used similar commercial software is stupidity, as it means you are unable to gain wisdom from the study of designs that have come before yours. In fact, it is precisely this mindset that causes user interfaces in free software to almost invariably suck---the whole "this is the way we do things, and you'll just have to get used to it" mentality does not lend itself to learning. I'll probably get modded down for saying it, but it's worth burning the karma if it gets people's attention.
Couldn't disagree more. I would argue that most UI designers have no business coding any more than most coders have any business designing user interfaces. The two skill sets are very different, with very little overlap either in knowledge or in the mental structures used in performing the two tasks. Good UI design is more closely related to software architecture, not coding. You have to figure out how best to lay out a user interface based on careful study of what the user is likely to want to do, careful thought about what things a user is likely to group together as similar operations (menu layout), and careful study of actual users to watch their workflow followed by probing interviews to find out what worked well and what didn't. It is basically scientific in nature. Software architecture is the same way. You're looking ahead to what the coders might want to add, what features the users might want, etc. and designing the overall architecture to accommodate those future needs.
Coding is a different skill set entirely. It focuses on knowledge of what types of methodical steps you have to achieve to reach a goal. Software architects and UI designers are the architects where coders are the construction workers. Expecting UI designers to code is no less silly than expecting your architect to be proficient at hammering nails into boards to build a wall.
Further, a strong case for the separation of those elements is the Mac design model. You have a separate Interface Builder application (well, it's part of Xcode now, IIRC) that gives people the ability to design the UI without writing a single line of code. Then, coders can come in and hook that functionality up to the underlying code. By doing that, it not only allows people to focus on the things that they do best, but also makes it much easier to modify the UI because you can create it visually instead of messing around with programmatic drawing that constantly puts UI elements in the wrong place. I get the impression that some Linux developers do the same sort of thing with Glade, but I've never used it, so I can't draw any real comparisons.
Trust me, getting UI designers to write code is the last thing you want to do....
Check out my sci-fi/humor trilogy at PatriotsBooks.
Your analogy doesn't follow. Better would be:
"How did the carpenter building his own home respond to the (voluntary) suggestions of a professional architect?"
...but that doesn't have the air of such a witty retort, does it.
I fail to see what any of this has to do with socialism. What you described constantly occurs in the free market. It is called "commoditization".
Agreed. Understanding usability is a totally different discipline to coding. One can easily do either without being able to do the other. The problem is that proper solutions to usability problems need proper foundations laid. Complaints about the foundations of usability tend to fall on deaf ears in the Free Software community -- certainly those who care are in the minority.
John_Chalisque
Your high horse is showing. :) If you don't like my GPL'd interface, you are free to design one of your own and hire someone else to code it for you, if necessary. FOSS does not mean, "anything you want, gratis!". It means if you don't like something you have the freedom to change it. I have little respect for those who use the word "free" as an excuse to try to hold up developers with their limitless opinion-based suggestions. Some projects are very open to user suggestions, others are very tied to following a well-defined vision. Neither model is "incorrect". No-one is forcing anyone to use any GPL software "as-is", that's the whole point. It's not so you can get your way while contributing nothing but opinions. Though occasionally you may get lucky like that. :)
Caveat Utilitor
You're confusing graphic design and UI design. They're completely separate disciplines.
Most UI designers I've met are not good graphic designers, and most good graphic designers I've met are not good UI designers.
The command line in Unix is more "usable" because it is older, more mature,
has more features and flexibility, and is more easily extensible. I can
augment a GUI with a few lines of shell scripting with considerably less
effort than it would take to "fix" the given GUI application.
I can make some shell script both easier and simpler than just about
any GUI application and tailor it to my own needs so that it most
closely meets my needs (and thus meets my own personal notion of
"intuitive").
That said, there are still Unix/Linux GUI applications that are
more functional, simpler and easier than their Windows/Mac
counterparts that we're supposed to be cloning. The "chasing
tail lights" criticism is a very good one in this respect because
sometimes neither of the allegedly "better" platforms do it right
or better.
At this point, it's no longer a given that the Mac or Windows version
of some GUI for some sort of app is any better.
Improvement of Linux GUI's should not be limited by what Mac or Windows
applications do or what design dogmas they follow.
A Pirate and a Puritan look the same on a balance sheet.
" Chasing tail-lights. In the absence of a definite design of their own, many developers assume that whatever Microsoft or Apple have done is good design. Sometimes it is, but sometimes it isnâ(TM)t. In imitating their designs, Free Software developers repeat their mistakes, and ensure that they can never have a better design than the proprietary alternatives. Solution: Encourage innovative design through awards and other publicity. Update design guidelines, where appropriate, to reflect the results of successful design experiments. "
Most people complain if it doesn't act exactly like the proprietary counter part, eg. The GIMP. I bet most the "usability" problems of free software is that it doesn't look and act exactly like the closed-source counter part
I wouldn't go so far to say that a critique is useless, but there is truth in his statement. A lot of usability problems are not just where you place the buttons, but they are much more deeply down in the code structure. Take Gimp for example, one of my issues with it is its lackluster animation support, you of course can try to polish the GUI a bit, but the real problem are much deeper down into the code and need to be fixed there first before you can even start to think about a proper GUI, same is true for a lot of other issues.
Usability in the free software world is simply not just an issue of GUI, but goes down through all layers of the code, since after all, they have to be usable too, both by developers and users. Tackling the GUI is all nice and good, but it really is only a small part of the whole picture.
It's one simple concept:
There are two ways in which software is built. The business way, and the open source way.
The business way is driven by the target of making money. So they try to appeal to everyone. This usually (wrongly) leads to making it as easy as possible, so everyone can use it.
Then there's the open source way. This one has no interest in money, so the creators add, what they like to have in the software. Now usually these are computer professionals, and because they built it, of course it's perfectly usable for them. Unfortunately this means it's very hard to use for non-professionals.
Both ways have their flaws for those that are not in the target group. But they emerged naturally.
The solution is, to let everyone grow to his own level of expertise in the program. We need a program that starts out being as easy as it gets, but grows with your involvement. (=if you work more with it.) Something like difficulty modes in games. Just it's not the difficulty. It's the shortcuts, the special view modes, the application layout, the shown controls, the wizards, and so on.
Of course you can always set that level yourself.
Think of vi, in notepad mode, then gradually growing to emacs if you like. ;) (o boy, i'll get killed for this... hint: i like none of those 3 editors because of the problems mentioned in this post. ;)
The best thing about it: You can make the Gnome people AND the KDE people happy. Oh, and the console/magnet/butterfly people too :)
Any sufficiently advanced intelligence is indistinguishable from stupidity.
It's more simpler than that... Most programmers will go the swiss-knife way, making a really effective cool tool, doing everything, really good, instead of giving the users what they want: never to have to actually invest in it, learning or otherwise. Make it do what it says, and NOTHING else. If you want the can opener too, write another app, or put it somewhere away from the user.
Make it simple, stupid, is btw, one of the common mistakes. MS wizards are simple. Nobody uses them. You still have to invest in the tool to work with it: read each page, make decisions. The rule should be: if you can decide for the user, don't confront him with the question, let the program figure it for the user. Allow configuration, don't force it. Think Skype. Think Ubuntu. Now think xinetd...
I don't want to insult anyone with this, but that whole discussion about who knows what design is "TEH BEST!!!!1one(lim x->0 ((sin x)/x)" is rather stupid. It's based on the logic flaw that there is something absolute in this world.
There isn't.
And that's a good thing.
Now I thought about this quite a bit, and wrote a possible solution to in in my other post.
Any sufficiently advanced intelligence is indistinguishable from stupidity.
OpenUsability
I used to work at the company which started it. It's a platform for free software developers to meet usability specialists, and so far it's coming quite good. The KDE 4 HIG was designed by us ("us" as i still used to work there at the time this was done), and the people working there are certainly bright minded people, but there's always friction at the implementation front. In my experience it's not neccessarily easy to convince a developer that a given usability decision is the right one, even if someone with a background in usability makes the proposal.
Power corrupts the few, while weakness corrupts the many.
The command line in Unix is more "usable" because it is older, more mature, has more features and flexibility, and is more easily extensible.
And also because all these Computer Science / Physics / Engineering graduates that argue how easy is to get things done with a shell so conveniently forget the amount of time they dedicated to learn how to use a shell.
I am personally (much) more comfortable using zsh than any GUI for manipulating files, or other tasks. But what most people tend to forget is that there is a much larger pool of users that are not willing to memorize 200 commands, and read man pages for days and days in order to just use their computer.
If, on the other hand, you can find a way to improve it, I'm sure many people will welcome your advice and implement it.
Agreed. Just telling a programmer that their software isn't usable isn't very constructive. Often times, they already know that, they just don't know the best way to fix it.
One good, non-specific way might be to offer to write an article including a basic set of guidelines for a popular site - say linux journal or linux magazine. Or where ever you think it might come up nicely in a google search, for that matter.
I realize that this might not be a motivation for those who want an immediate return for their efforts - who want specific software X to be more usable - but you never know. Maybe someone who's currently writing software Y, that you've been dying for, will take your advice and make their software contribution that much better.
I suppose what I'm trying to say is that a lot of programmers - myself included - would love it if usability experts would devote some of their time and effort into making our own time and effort more worthwhile to the end users. Heck, even if they don't consider themselves an "expert", if they think they have a few ideas on what would be better, it'd be much more appreciated than a simple comment about how something "sucks".
The wise follow a damned path, for to know is to be forsaken.
One doesn't have to look far to find small but serious usability issues in open source software.
For example, did you hear about Fitt's Law and "mile high menu bar"/ "infinite size widget" effect?
For detailed description, see e.g. this Ubuntu bug.
It turns out that while the Windows and Mac software got this right (at least with respect to scrollbars), massive amounts of OpenSource software (even high profile projects for Gtk/Gnome and Qt/KDE, like Gnumeric, Gnucash, OpenOffice, Konqueror or Kword) add an idiotic small border to their document area that seems to serve only one purpose - prevent this usability effect and make all users' lifes harder.
BTW, I highly recommend Joel Spolsky's "User interface design for programmers" - that's the very least a coder could do to educate himself in the area of usability. The book is very interesting, easy to read and quite short.
If FOSS were a restaurant, it would be of a type that if you don't like what's on the menu you may use the kitchen to make something else you prefer, with your choice of ingredients in stock or BYO. Since I doubt there are any restaurants like that, I believe your analogy fails.
And if you can't cook then you shouldn't eat presumably?
The analogy works quite well I think. Just because you can't do better yourself doesn't mean that you can't tell when someone else does it badly.
The chef makes food that makes me puke. I can't cook. Does that, therefore, mean I can't say the chef did a bad job of cooking? That doesn't hold.
The issue is more general than that. The usability experts who can't code *can* improve usability, by telling the developers what to do.
It's more of an issue of *just* criticising, instead of offering constructive opinions. If all you can do is say "this sucks" but not say why or how it can be improved, then I agree, you have no business in software. If, on the other hand, you can find a way to improve it, I'm sure many people will welcome your advice and implement it.
RE: Bugfix, Usability is a matter of opinion
*WONTFIX*
Usage works for me.
*Ducks and runs*
Try to hack my 31337 firewall!
"Command line for experts, GUIs for casual users" is a false dilemma anyway. Which is why people don't generally use command lines to draw images, compose music or construct cars and airplanes on a computer, no matter what their skill level is. Even the most skilled "Engineering graduates" use, among other software, CAD programs (which have GUIs).
Sadly, you may be right about this, judging by the vast majority of responses from developers in this article thread so far.
Almost as one, the FOSS developers here seem to have responded (paraphrasing): "Nobody is paying me for this work, so I'll be darned if they're going to tell me how the UI should be designed for usability." And even some non-developers have defended that stance.
This suggests that, indeed, there may be no solution to the problem coming from the community of FOSS developers itself.
But what if we were shamed into it?
What if Microsoft, or Apple, came out with a public statement that "FOSS products have extremely poor usability, because their developers refuse to accept usability input." It would be hard to defend against such an accusation, since we have almost no cases of devs accepting input from non-devs.
This would cause a huge uproar, I'm willing to bet. Maybe that would shake us out of this impasse.
"The question of whether machines can think is no more interesting than [] whether submarines can swim" - Dijkstra
Why go through the trouble after your initial effort, if there is no advantage? A lot of free software comes about because of the need, or the personal interest. But once both of those are satisfied, there is no reason to enhance the program.
Comparing Socialism to Open Source software is an insult to both. Open Source developers are philanthropists, which explains why they would go through the trouble just as they would go through the initial effort. Open Source development is not supposed to be about personal gain. I know few people have a strong grasp of such selfless concepts, and so many misconceptions can be rooted to that fact. The real issue is that of priority and time management. No Open Source project is developed with the initial goal of developing a strong user interface. At best the interface is the secondary goal, because an interface without a function is not a program. The goals of the main developers may not match the goals of the market, and since the market has no DIRECT influence over the goals of the developers, these goals may never sync. The Open Source solution to this is, "I you want it, make it." and the flaws inherent to time management now take hold. Even if I want a feature added to an Open Source application, and have the ability to do so, stepping into an Open Source project is no small feet. Since the developers do not put your concerns above their own concerns, and since you do not wish to invest the time to handle your own concerns, your concerns to not get met. Basically it comes down to two things. One, often Open Source projects to not make it easy enough for prospective developers to gain and utilize an active interest. Two, beggars can not be choosers.
Most UI designers I've met are not good graphic designers, and most good graphic designers I've met are not good UI designers.
Spot on. I am a UI designer. I have no clue how to use Photoshop, and I don't need to know because that's what the graphic designers use.
I just wish the "creatives" hadn't hijacked the word "design" (and "creative" for that matter).
"And the meaning of words; when they cease to function; when will it start worrying you?"
EXACTLY! I can learn a programming language and write a program that does precisely what I want it to do. But that takes a vast investment of time to have a tool which does instantly what I need done. Perfect for people like programmers who might do one thing over and over and over and over... but not so hot for someone who just wants to do something once every 3 months.
The bane of the command line program is this: ">"
I sit there and stare at the little arrow. I want to copy a file. But all I can see is ">" What does ">" mean? Maybe I should type in what I want to do "CopyFile"... "command unknown". Great... well I'm out of ideas. Yes the interface might be faster... if you don't have to open a MAN file every 10 minutes because you forgot if it was cpyfile or copyfile or cpyfle or copy_file or copy-file or... whatever. The point is. Command lines are like code. They will do exactly what you want them to do once you know the magic incantantation with the right pronunciation. But if you know what you want to do but have never used the software before you're SOL. This is why I love node based tools. When I'm learning a new programming language I have no idea what classes and functions exist. I might even know the exact tool I need "I need to find the position in a string where "hello" is found". But translating that into a class name is a game witchcraft and endless help document scimming until you happen to find an arbitrary function name which does it.
GUIs show me my choices. Yes they show me my choices every single time. But I like to know what it is I can do. A BAD gui doesn't show me my opportunities. It buries it in a menu which is as bad as burying it in a command line command somewhere. But even a GUI is better than a command line while learning because when you finally do find the command you want to do... you can act on it instantly! No closing the MAN file reciting "'copyfile 'filename' -f -s-t-u #silent *underhanded" in your head hoping you don't forget it before you type it in.
Again many developer tools can operate on command line because the functionality barely changes from version to version. In all of the software I use every release adds hundreds of new features I need to learn and I need real time feedback on changes I make... I can't wait to execute a command to see if it's right.
Take SQL as a perfect example of a command line tool. SQL has barely changed in its command structure in 15 years. Of course you're super fast at writing complex SQL scripts that deliver exactly the information you need! You've been practicing those exact same commands for 15 years! What if SQL radically changed every few months? And what if instead of only a few dozen commands chained together it was 10,000 tools and settings in a single application? You cany very quickly get to the point in most software where it is simply impossible to use it as a command line tool and expect a user to use it without a MAN file permanantly open next to it.
I've spent 3 years learning MaxScript for instance for 3DsMax. Which is its command line toolset. It can take me a week to create a script which I can do in 20 seconds using the GUI. Once I write the script it might take an artist half a second but even I completely forget the name of a function I wrote earlier in the morning "What was it again? GetObjectIDFromDatabase or was it getObjectfromDatabase... what was the order of the function calls again? What was the name of that function which... I wrote it myself! And I still have to refer to my own help file to remember what the name of 90% of my commands are. It's unreasonable to expect someone to remember the command names and possible flags for 200 functions... and that's a primitive script. And even if I did expect someone to memorize all 200 commands... they would just have to memorize another 200 the next month when another tool is added to the toolset... and another 200 the next month after that... and another 200 the month after that.
With my first major contribution to an open source project, the author essentially said "patches welcome", but he said it differently:
"I would definitely consider a patch that did that."
And, as I kept talking about it, but not actually sending it in -- my monkeypatch was pretty low-quality, and it'd take a weekend to polish it:
"I'm really starting to like this syntax of yours."
So, I was actually encouraged -- it wasn't confrontational, it was encouraging.
So, just as I would tell Person X not to simply say "This sucks!", but to offer a helpful suggestion, I would also tell anyone who would respond to think about how to help them get it implemented.
So, for example, if someone's a designer, but not a programmer, and you've got a programmer who you know wants to contribute, but he's not really sure what to work on, hook the two up. Or, with your example:
Why don't you do it yourself, or hire someone to do it for you? If you can't do either of those, why don't you contribute documentation, mockups, or something else that's not technical but is still useful?
Why don't you offer these up in a FAQ or guidelines somewhere, and mention them in your stock response? Simply saying "patches are welcome" is actually unhelpful, unless you can write a patch -- and even then, it simply comes across as standoffish.
It's the difference between "I can't bake that for you, but here's a recipe, and I can sell you some of the ingredients," and simply saying "Do it yourself."
Don't thank God, thank a doctor!
Have you actually used AutoCAD, say?
Yes I have. (I'm an avid Emacs user too) You're right, the command line in Acad is great, but it's the combination of the command line (and its scriptability using AutoLisp) with the UI that makes it truly useful (e.g., as you say, the fact that each time a point is required, it may be entered numerically as well as interactively using e.g. snapping). Acad was written by judicious and wise people. If it had been written by pure click'n'drool advocates, it would only have a GUI. If it had been written by die-hard "GUIs are for losers" Unix freaks, it would only have a command line.
That's definitely true, most people that code want their programs to be used and as such are unlikely indeed to leave usability issues in when they know how to fix them.
I'm not really sure why open source is getting blamed here, commercial programs are often times just as bad or worse, and at least with open source, I can use it for a few months or even years before deciding if I want to contribute.
Sometimes knowing all the ins and outs of a program makes it harder to make an interface that is useful for those starting out or that don't have all the information. Ideally the learning curve should be relatively gentle and long enough to deal with necessary complexities.
Having a gentle curve that is too short ends you up sort of where Windows is. With the program making most of the decisions and with the tools to override things hidden in a hard to access area. Assuming that one can even override them in the first place.
The issue is more general than that. The usability experts who can't code *can* improve usability, by telling the developers what to do.
It's more of an issue of *just* criticising, instead of offering constructive opinions. If all you can do is say "this sucks" but not say why or how it can be improved, then I agree, you have no business in software. If, on the other hand, you can find a way to improve it, I'm sure many people will welcome your advice and implement it.
RE: Bugfix, Usability is a matter of opinion
*WONTFIX*
Usage works for me.
*Ducks and runs*
Note to self: fork codebase. Send snarky message at 1.0 release. ;)
If I mod you up, it doesn't necessarily mean I agree with what you've said, sorry.
It absolutely amazes me how many people like yourself get modded +5, Insightful in every single discussion like this, when you're all dead wrong. It amazes me how you think you're being logical and can go to incredibly great lengths to justify the continuing elitism of "if you don't know how to build the car you have no business driving it" kind of attitudes, which is exactly what you're espousing. Did you build your own car? Do you know how every single piece of it works? Can you recreate it from scratch? If not, shut your stupid pie hole.
This idea that you have to be the world's foremost expert in a particular field in order to be allowed to open your mouth is just so unbelievably ridiculous that I can't understand how it keeps being perpetuated so strongly even on a site that is supposed to be full of relatively intelligent people.
You're all constantly using obscure corner cases to try and demonstrate that any end user who ever criticizes the work of a "coder" is an idiot and wrong in all cases simply because they don't understand the precious code. Sure, users often misunderstand what the actual issue is with a program that's not working for them, so what? The fact remains that there is an issue, and blaming the user every single time solves nothing.
The longer attitudes like this get perpetuated, the longer most open source software will remain the underdog that most non-coders won't touch with a ten foot pole because it's so baffling or aggravating to use. What all you elite coders need to come to grips with is that you are too close to the code. You understand the code too well and it blinds you to the real life usability problems. You don't realize how much your knowledge of the code warps the way you see the interface. You have to learn to forget what you know about the guts of the software and look at it with fresh eyes, like any new user does.
The real question here: If you aren't making the software for people who don't know how to code, what are you doing putting a GUI on it in the first place? That is after all the entire purpose of a GUI in most cases, is it not? To make software accessible to and usable by people who don't know how to write the code themselves?
Jeebus cripes, folks. Get over yourselves. Stick to writing command-line stuff if you don't want to respond to interface criticism or suggestions like a reasonable human being.
Oh, and stop using Firefox as if it shows how great all open source code is. It's one application that has been worked on by teams of very talented people for several years and is supported by a business. Of course it's one of the best, but 99% of the open source software world falls a few miles short of that. Face up to that fact and you'll be better for it.
Great point.
They are taking about UI and usability as if its a solved problem. Its not even close to a solved problem.
A good example is my mum using windows vista. It was more than different enough from XP that she could not use it at all (we got as far as, "this is firefox, now you can use the internet"). I find word imposable to use, it never does anything *i expect* it to do. Then there the whole host of tasks that are not simple to visually represent on a screen.
One of the easiest system i have ever used was a older radar system from a F16 and IANARO (Radar Operator). It had buttons around the side that told you what they did much like ATM machines.
Personally we need a lot more experimental design rather than just blindly sticking to current UI dogma. An example that comes to mind is perhaps the wii.
If information wants to be free, why does my internet connection cost so much?