Slashdot Mirror
Jakob Nielsen Talks About Usability in FOSS
dokey writes "In an interview with Builder AU, usability expert Jakob Nielsen gives his opinion of usability in Free and open source software. The article echoed what Jon "Maddog" Hall said earlier this year in a keynote at Linux.conf.au -- "Programmers Are From Mars, Users/Managers/Companies are from Venus". Is it time to pay more attention to end-users?(who aren't geeks)"
Don't expect usability from a programmer.
Separate program logic from design and let a designer do the interface. Much happier for everyone involved
This is the core focus for applications. The End-User must always be factored in, regardless of who that is.
For example, I may develop a quick little utility that let's me interface w/all the X10 in the house. I make it text-based commands, since I need no fancy interface.
Now, change that to Ma and Pa Kettle. Try to sell them the text interface and they call it crap. Add a whiz-bang interface showing all the connections in the house as the appliances/rooms they reflect and M&P buy it.
More IT apps fail from lack of interaction with the end-users.
"Is it time to pay more attention to end-users?(who aren't geeks)"
Not only is this mentality wrong, it's also holding OSS usability back. Geeks are end-users too. If good UI design is targeted at computer novices, as is widely assumed, then why do so many technically talented people love OS X? Answer: Because usability gains for "our grandmothers" are also usability gains for we geeks.
And this is way I use OSX. Usability beyond compare, commercial and open source apps, java, and windows integration.
The power of Unix, the ease of use of the Mac.
OSX makes me money today with increased productivity and access to best of breed apps.
Linux may get there one day...In the mean time i need to get work done TODAY.
Welllll.. considering that without end-users IT wouldn't have a job, it does seem fairly important to pay as much attention as possible to end-users.
If you have to ask that question as an IT person, you are already a few steps behind.
Read the EFF's Fair Use FAQ
Most OSS is written by geeks as a personal hobby - just because they like writing code.
IMHO and experience, designing and implementing a GUI is one of the more boring, cumbersome and uninteresting parts of programming, something like writing office or business applications (atleast for me).
I don't see why a hobbyist would do something he didn't like.
An Indian-American Hindu committed to non-violent thought/speech/action alarmed by the global explosion of radical Islam
Really, I think end-user usability is an area for companies like redhat, mandrake, suse, etc. (even Lindows). Not that it wouldn't be great if more programmers were able to consider the non-geek users of their programs (or if they have trouble doing that, getting someone to help), but honestly, that's not the real way good usability with open source programs is going to develop. Companies like redhat are the ones that are really capable of pulling together hundreds of open source projects and making a product unified enough that a non-geek can manage it. Sure, there are non-commercial distros like Debian that do a good job at this, but it requires a lot of volunteer work and I would argue the end result of distros like Debian still isn't appropriate for many "regular users" (not that I'm putting down Debian, there are plenty of advantages to it and it's actually my distro of choice).
That's not funny, it's correct.
:2.
There's nothing wrong with an OS/application that only geeks can use. Just don't try to market it to non-geeks, and there's no problem whatsoever.
I personally don't want my OS and applications dumbed down to the level of other OSs. The lack of control and options in metacity, for example, is shocking. It's almost getting to the point where you have to swallow default configs if you want the "user-friendly" distros to even work right at all.. For example, I can't turn off Nautilus unless I don't care that my background doesn't get properly set to my root window, something that should not depend on nautilus at all. (and doesn't, I can go manually reset each time I restart X, without starting nautilus).
I won't even get into the hassles if, god forbid, you want to run a second X session on
If anything, the lame attempts of programmers to second guess what the end-users want, locking them into defaults, and not testing non-default configs, is a horrible trend in general.
I've had enough abrasive sigs. Kittens are cute and fuzzy.
Sorry but the fact that this question still needs to be asked is a damning criticism of FOSS development.
Despite aiming to extend the reach of FOSS distros into the desktop developers still write software that most users can't use.
This gets brought to the community's attention quite frequently and despite this the core point remains unexamined and unanswered:
Geeks who write FOSS software aren't the ultimate market for those tools (or at least they aren't if you want to help spread FOSS) and until tools and software is written for a broader market then Linux will remain a server OS.
And while we're at it can we all drop phrases like "Joe User" and its ilk? Perjorative terms describing what is your actual target market don't help you create better software for them.
Step 1) For the love of God, stop making skinned applications. Use the UI-consistent widgets, they're dirt cheap, I promise. Skinned apps make me want to scrape my eyes out.
Mike Hoye
Apache impressed people with its English-style configuration directives that have influenced other developers to switch to such logical formats. Another example: the Postfix MTA is becoming more popular and many users say they enjoy using it because of the straightforward configuration, compared to the m4 mess of sendmail. "It has to be complicated to be powerful" is no longer an excuse.
free/open source software is that the original developer does not have to focus on the user interface; Since the code is freely available for modification, someone else with better UI skills can improve it.
No data, no cry
This guy has a big UI name but this "genious" paint all open source with the same brush. Personally I think Apache has best GUI every - its easy to read flat file. Open Office, KDE, Gnome are very polisished but lots of stuff isn't.
Also, the reality is that people need to think more like computers. You cannot be a blathering idiot and expect and optimal experience from any piece of electronics or software. Don't cite OSX or Windows, they also manifest deep system details at high levels.
Yes we can hide, obscure and wrap in metaphors, but this implies a loss of control, which I am not sure most of the actual users of this code want.
(sig) "I think the [MS Word] paperclip is a great idea. - Miguel de Icaza"
Your sig could not have said it any better!
I find this kind of article mystifying. I find mandrake 10 to be oriented towards the end-user, for I AM an enduser. And I get work done.
I bet all the posts on this page could be found in the previous articles harping on the "linux needs to be friendly to end-users" meme; but people just haven't realized yet that there ARE distros out there which are friendly to the end-users.
Good point taken. I hope I'm no troll or flamebait here, but have you seen KDE or GNOME lately, as well as their applications? They almost look like replications of the Windows interface. Isn't leaving Windows and learning something new part of the "benefits" of switching to Open Source? I think that the Open Source developers should build a brand new interface from the ground up, that is different from the other interfaces out there, but also useable enough so that way non-geeks would be able to use it with minimal trouble.
What I mean is this. Say you're a hypothetical non-geek Windows user who is using KDE or GNOME. You notice that the interfaces look very, very similar; the minimize/maximize/close buttons are in the same spot, the bar where your applications go works quite similar, and everything has a bit of familiarity. But say you want to go further. Then you'll hit some rough spots, because KDE/GNOME doesn't work exactly like Windows does, even though it looks very similar to it.
But what if I gave that same user a completely different user interface, one that the user has no experience in. Yes, the user would have to learn how to use the new interface, but if the interface is well designed enough for usability, the user will master most, if not, all of the aspects of the user interface in very little time. Plus, because the interface doesn't look like anything that he or she seen before, the user wouldn't expect "well, it worked here in this environment, so it should work the same way here."
This guy keeps saying the same things over and over again. Why anybody would pay him $10,000 (his starting price) to review their site is beyond me. Instead, someone should make an 8-ball with his 30 stock tips in it: "Don't have a link to the homepage on the homepage." "Don't have dark text on a dark background." "Have a search field in plain sight on the homepage." "Make your pages liquid." and so forth
I think the better question is. Why aren't more distributions handling these issues? Remember way back when? When programmers coded for their itch. And distributers pick and packaged what they needed. Sanding down the rough edges, and doing the jobs no one else wanted? So whatever happen to that? Were's the articles holding their feet to the fire? Why just programmers?
Repeat after me:
/= dumbed down /= lack of control
Usability
Usability
Usability is the process of making something usable, not making it unusable. Usability is the process of giving control, not taking it away. Usability is elegance in interface. Your uninformed attitude is exactly the problem computer programmers and users have these days. There is a process of making something useable, and from what it sounds like you are confused as to the desired outcome.
The sad thing about people with this attitude is that you would rather see a program with elegant code and an inelegant interface because you somehow think it's more powerful. We as coders should be sticklers on elegance in Code and in Interface.
This all ties into a more basic problem with computer programmers; communication. We need to learn how to communicate with the rest of the world. I don't know how many times I've been in a business meeting where I have had to deal with users, managers, and sales people and after the meeting they have told me how amazing it was to speak with someone who was technically trained, yet knew how to speak to a layman.
This is the exact same thing here, we expect the layman to learn our vocabulary and now you want them to learn our esoteric ways of using programs. We spend years learning how to break complex problems into small logical problems which can be solved. We solve these problems using complex logical diagrams and patterns. Now as it is our job to break these problems down into solvable problems, it is also our job to synthesize the results into a useable dataset. Part of that usable dataset is actionable results, as well as useable interfaces to access those results.
Please, for the sake of your job learn some usability. If you don't someone else will end up maintaining your code and getting your job, and they will be asked to make your code more useable. Heck, they might even be asked to make the code do something you already have it capable of doing, but no one can figure out how to make it do that. Have you ever heard of that problem (MS WORD).
Fantasy remains a human right; we make in our measure and in our derivative mode... -- JRR Tolkien
Is it time to pay more attention to end-users?
It depends on your target audience. For a specialized library maintainer, a user means another specialist in coding.
But some people do not care about others in normal life, why shoud we expect from such to be different in software design? If you are a nerdish geek, you don't value a distorted reality of Clicky'n'Picky ordinal users much high. So there is a need to develop some spiritual qualities, empathy and compassion. Without these, there is no mastery of any craft, not only of software. Craftsmanship maybe, but no mastery.
But certainly I never had compassion for corporations and corporate users. They understand only money. Let them pay for features they want.
There you are, staring at me again.
Yes, yes, yes. A thousand times yes.
As a software engineer myself, I find the lack of attention to the user interface with end users (even other geeks) terrible.
Let's face it: I don't have the time or energy to learn the ins and outs of all the possible software out there. 90% of the time, I want the base functionality, and don't want to have to learn how to set 10 things, just because I want to do 1.
I'm sorry, but most of you programmers that think that an effective user interface isn't important are either ignorant, lazy, or both.
Take a User Interfaces class. Not only will your end-products improve, but you will also get some insight as to how other users may be thinking, and what they're looking for.
The most important thing you need to do before you begin the act of creating anything is to Understand Your Audience. I guaruntee, your audience will not follow the same thought processes you do.
~D
This sig has been enciphered with a one-time pad. It could say almost anything.
UI designers aren't any more likely than programmers to hate their work and never want to do anything similar in their spare time. The reason that OSS projects don't usually have UI designers as regular contributors is the amount of knowledge necessary to change a program's UI that isn't in the standard graphic design curriculum. In the commercial world, UI designers generally work by having the authority to tell programmers what to do; in the OSS world, they have no way to get this authority, because they don't have the skills for the entry-level gathering of respect.
In order to have good UIs, we need to involve people who can design them. In order to involve them, we have to empower them to make patches on their own. And that means arranging for UI coding to be completely obvious, and separate from the inner workings of the program.
I don't see an easy solution, because if you don't clone, then reviewers and users complain that the app is missing feature X, or that it works differently than in Microsoft Office, and therefore the app unuseable or unsuitable. If you do clone, then the critisism is about perpetuating the bad UI. If you offer the feature, but change the UI, then the complaints are that the learning curve is too high.
Which is the better of the evils?
I appreciate your attitude; it makes it easy for me to steal your job. =)
Seriously, I just can't understand this kind of thinking, although I encounter it all the time. If you're writing utilities for yourself or for a group of people very much like yourself, it's no problem. But if you're writing commercial software, you're not writing for yourself. Your whole livelihood revolves around solving other people's problems. Expecting your customers to adapt their way of thinking to your way of coding is just piss-poor customer service. You want their money; that means you make it easy for them, no matter how challenging that may make the coding task for you.
Oddly enough, I came to these convictions not through coding, but through years of work as a DJ. No kidding. When I started out, I had all these pretensions about educating the great unwashed in what good music was. And you know what? I got the conceit beaten out of me very quickly, as I cleared dancefloor after dancefloor for the first two months.
I soon realized that my job was to play what the crowd wanted to hear. And if their tastes had been informed by 30 years of top 40 radio, tough luck for me. My job was to figure out, at any given gig, what kind of crowd I was dealing with and play accordingly. And it's worked wonders.
Interestingly, I came to learn that if I do that well enough, the crowd learns to trust me. They're so happy with what I'm playing (after 13 years, I virtually never have a bad night) that if I slip in something new, they'll usually give me the benefit of the doubt enough to dance to it anyway. That's right: I have more success introducing new music now, than I ever did when I was looking down on the people who were cutting the cheques.
The same applies to software. I seem to be a rare case: someone with real interaction design chops, who has also written a C compiler. But it seems like a natural marriage, because what proper usability research does for me is confirm that I'm solving the right problem in the right way.
I think Eric Sink has an article or two about this where he distinguishes between what he calls developers and programmers, but I'm too lazy to Google for it.
Three things that help make the conflict easier. Highly modular design with good API's. A good scripting capability properly exposed. And plugins, plugins, plugins.
You can't please everyone, but you can make it easier for people to please themselves.
And while we're at it can we all drop phrases like "Joe User" and its ilk? Perjorative terms describing what is your actual target market don't help you create better software for them.
"Joe User" is not a pejorative term. "Joe Luser would be, as would "Joe RatB*st*rd", but there is nothing inherently negative in "Joe User". He represents the canonical end-user (go figure) who doesn't care about how the computer works so long as it does. Actually, when it doesn't work he still doesn't care about the inner workings, he just wants the IT guy to get in there and fix it. This, believe it or not, is a completely reasonable approach.
Lighten up, Francis.
I want to drag this out as long as possible. Bring me my protractor.
It's not that developers aren't to blame, but rather, it's how you'd expect developers to be. What FOSS needs is a free, open-source equivalent of the QA/Validation/UI Design department.
This is one of the things that I've always said FOSS isn't good at doing - QA/Validation/UI design.
Most FOSS programmers work on projects for the love of coding. A break from boring work projects, home life, and to show thier geek pride. A mental workout.
QA, UI design, etc are often the ultimate in repetitive drudgery. Designing and coding test frameworks for larger apps is often more challenging than coding the application to be tested. It's slow, tedious, detail orientated work. The payoff is small, measured, and non-glamorous.
The big FOSS projects - I call them the "name brand" ones - get some of this just by sheer number of volunteers. The Linux kernel. Firefox. OpenOffice to a lesser degree.
But the thousands of other projects - they get a programmer who just programs 100% of the time. A seperate volunteer to write up some minimal docs and a man page. That's it. Refactoring code to be more user-effective? Eliminating ambiguity from documentation? Producing high-quality production level software packages for many platforms? Nope. Rarely done. Why? It's the crap work that FOSS programmers are trying to avoid in the first place!
Many of the Microsoft developer bloggers have reported that they spend less than 50% of their time coding. The rest is designing and documentating, refining, refactoring. After that, it's off to a team of testers and documentators.
The point? Who wants to volunteer to work that you normally have to pay people very well to get done in the first place?
Being the old-fart that I am, (ok I'm just 30 but I feel like an old fart) I started with BBS's, a 300 baud modem and a C=64 around 1986.
I eagerly upgraded to a 386DX/40 and started using DOS v5.
From there I went to Win3.11 and then an addon called Dashboard (made by HP IIRC).
All this time my computer and UI upgrades were fun, and something that I looked forward to.
Then I tried Win95. Ack, I hated it. I couldn't uninstall it quick enough.
I got used to Win95 (never really "liked" it), and followed to upgrade path like everyone else.
Win98 was better, Win2k was good. I enjoyed how 'tight & clean' everything felt, and I still thinks it's the best looking OS that MS made (including XP in classic mode).
XP (default) made me gag, and I couldn't change the settings quick enough.
I have always 'tweaked' my OS (from DOS days of hacking the io.sys, msdos.sys, and command.com, all the way through till now)
I have tried using most of the linux distro's and it feels anymore like it's just more work to try to turn all crap off that Joe-Programmer "thinks" that Suzie-Soccermom will like.* I have tried using a Mac,and I don't like it. I have heard that it's the best UI for folks who have never used a PC before, and I must admit that this 'old-fart' won't ever touch it if he has the choice.
Anyhow back to my point, I left it somewhere around here. I have recently tried using iTunes.
Untill now I have been using WinAmp v1.8 and then I moved on to FooBar2000.
Tight, small, simple, no fluff. I loved that program, but I thought i'd try something new.
iTunes:
It's great for searching, (even better if you have good ID3 tags)
I still need to learn/use it more, but I think I like it. (The secret is to forget that the DOS world ever existed, don't you dare use Windows Explorer to do anything usefull, and be a Suzie-Soccermom x For Dummies idiot.)
But other then that, I think I like it.
What I want to know: Am I just an old-fart who is stuck in his Carmudgenly ways, or are good UI options being dropped in favor of candy-coloured eye-goop, that serves no enhancement of the computing experience other then the "I wanna see if it can do this" mentality?
*I have tried using XFCE but I couldn't figure out how do do much. The terminal with vi & links & mutt were more intuitive. =)
What needs to come first: A geek writing for a geek. An artist who see the vision that the original geek wrote. Or a geek writing for his sister. (not mother, that is why we have all this eye-candy and Help-Wizards)
My vote: leave the art for the artists
the code for the programmers,
and the easy to read files for the hackers to hack.
Between those 3,a good combination will be met.
"The price good men pay for indifference to public affairs is to be ruled by evil men." ~Plato (427-347 BC)
Sigh. I don't know where to begin on your misinformed rant, so I'll just address some points that stand out at me:
If users got smarter about computers, programmers wouldn't have to spend so much time on making it nice, pretty, and easy
Usability does not automatically mean pretty. Usability means that the interface behaves as expected, and in a consistent manner. (ie. you don't make a widget that looks like a check box but behaves like a radio button) Pretty is for graphics designers to worry about, not for usability designers. In fact, often the prettiest interfaces aren't the ones that are good in terms of usability. Think of all the nice looking Flash websites you've seen, now think of how easy to use some of those were.
Computers aren't supposed to be friendly, they're supposed to work properly consistently
And that is a large part of what usability is. The application performs properly and consistently given user interaction. Quick, what's the command line option to read config options from a file in program foo? Is it -o? Better hope that's not the command line switch to output the results to the file. How about getting help in program bar? Is it -help or -h? Or how about --help or --h? These are the types of things usability is concerned with -- consistency.
Yes, ease of use is important, and it can't be stressed enough. But, laying all the blame on the users is misguided at best. Most people don't use computers the way programmers do, and they don't want to spend the time to do so. Besides, I'm sure there are plenty of programmers who'd prefer a nice consitent and intuitive interface when they encounter a new program.
There must be the potential to do the UI or GUI in a radically different way, and maybe make it adapt to the expertise of the user, so that there is not just a minimalist shell for experts or a full bloated GUI for beginners. There might be something to learn from Plan 9, at least it is different.
But it seems to me that already the useability and the problems of Windoze are well-developed in FOSS, some new concepts of user interaction might be useful. For example, the mouse. (I use a trackball, the Logitech spotted ball type, because it is better, I have a mouse on some of my machines, the principle is similar.) Is the mouse relevant, should we use a touch screen (probably not, because of fingerprints, unless you want to spend half your day cleaning it...), maybe a graphics pad, eyeball tracking, a panel of knobs and switches...... Now the screen, text is text, and that will not change, but do we need icons and toolbars to edit it? Maybe extra mouse buttons could be more efficient? (WordPerfect for DOS was a truly excellent program in its day, I never read the manual, it was all done by a template on the F-keys, far better than what we have now.)
The problem is one of both input and output. It is difficult for a small developer to devise a new display device but not so difficult for simple input devices if complex mechanisms can be avoided, or improvised from existing bits. How about a two-ball trackball? And what could you do with the second ball? I ask because I see that when my thumb is not on the ball, it could just as easily be resting on some other control, if there was one. Maybe some foot pedals?
As for output devices, sound is already there, and a nuisance in the wrong circumstances. But, maybe some visual things like extra lights and meters (maybe bargraph LEDs) could live in the space above or below the screen, so as not to waste precious pixels, but attract the user's attention. (I really hate when everything grinds to a halt because some kind of dialogue box has popped up on the main screen and promptly been hidden, a problem that can surely be fixed!)
Chewing over these sorts of ideas, I am starting to think that maybe the F-keys could have programmable captions, so the menu functions are down on the keyboard. This would be done either by a LED matrix in each key, or replace the whole row of keys with a long, narrow touch screen LCD or plasma display.
Just some random ideas, others might be able to devise better, even without fancy hardware.
Maybe Jakob is colour blind because I find it difficult to believe anyone commenting on usability who is worse at web design than me! ;-)
I find the two equally sized columns on his site quite confusing. Its difficult to tell which one to look at to find the information you want (and there is always the question of why there are two columns in the first place). Wouldn't it just be much better to have a smaller category bar and then a detailed information part beside it?
then who is the program written for?
If you're going to write a program to be used by somebody, doesn't it make sense to take them into consideration?
FOSS is nice - but what good is Open Source when there's so much extraneous CRAP in the (indifferently commented) code that modifying it isn't worth the bother? What good is Free software when it costs more in time and trouble getting it configured than its productivity is worth?
FOSS is great for technology geeks. It isn't worth a flip (for the most part) for the person that just wants to Get Something Done - primarily because of the lack of standards: how many Linux package managers are inter-operable? Why do dependencies matter so much in Linux apps?
No, I'm not trolling - I'm a Suse user for the last 6 months. But I keep a Windows machine around for those too-many situations where the Linux equivalent (when there is one) of a Windows app simply sucks too bad. Usability and consistency from the user perspective is one area where Microsoft is kicking Linux' ass.
--- Asking inconvenient questions for over 30 years...
One class I'm glad I took in college. It realy opened my eyes to usability and how to make something usable and a better understanding as to what other programs have done wrong. Elegant code should have an elegant interface and learning what goes into making an elegant interface is very important. True, not every program needs an interface at all but for the ones that do its not hard to follow some of the simple rules for making something usable. A lot of the material would only take someone 15 to 30 minutes to go over and understand, and not the 3 hours of class I had to sit through. If you are ever going to make an interface please please look into things like the ten usability heuristics.
this is the most important sig ever! In your face 446154!
The whole concept of Usability is a bit of a canard. For the 99% of the people on this planet in order for something to be usable it must act and look exactly like a MS product. If it does not then they can't use it. Of course making your product look and act like an MS product is sure to get you sued but that's another discussion altogether.
People who measure usablity measure wrong things. They don't measure how easy a program is to use they measure how easy a program is to learn. There is a subtle but profound difference between the two. It may be easier to learn something if there is a tabbed interface with a dozen tabs on it and the user can waste 5 minutes looking for the option he wants but it is by no means easier to use.
This is central dillema. Programs like vi, emacs, sed, awk, find etc are very hard to learn but once you have learned them they are easy to use. They make you more productive. When it comes to usablity nobody seems to care about the people who have taken the time learn something, they all want to concentrate on grandmas who can't tell the difference between turning off the monitor and turning off the computer.
evil is as evil does
Usability is the process of making something usable, not making it unusable. Usability is the process of giving control, not taking it away. Usability is elegance in interface.
Not quite. Usability is the process of making something usable for one set group of people.
You can try to make this group as large as possible, but you will NEVER have an interface that is usable to all groups. I find the MacOSX UI to be less usable than the KDE UI, just because the way I think does not coincide as well to the way the MacOSX UI works.
What bothers me is that usability experts (along with a bunch of blowhards that think they are experts) seem to think that there is "one true interface" and that their concept of usability will work for everyone. The best you can do is say "this interface is optimized for the novice user" or "this interface is optimized for the long time unix guru". If someone says that an interface is ideal for all users they are lying.
Software is complex. Horribly complex. According to Fred Brooks, software is the most complex thing mankind has ever created.
Yet people still demand that this complexity be simple. IT CAN'T BE DONE! Microwave ovens are easy to use because microwave ovens are simple. In comparison to software, automobiles are easy to use simplistic devices.
Simplifying the interface only frustrates those users who want the power and complexity of the underlying software. It rewards the ignorance at the expense of experience.
You can make software usable, but you don't go about it by slashing away at the functionality, or hiding away the controls in an undocumented morass of registry entries. You do it organizing, adjusting and streamlining the interface according to the common workflows (plural) of the user.
Don't blame me, I didn't vote for either of them!
Don't expect usability from a programmer.
You're making the same mistake as various high profile advocates who seem to think that usability is just one single thing. It's not. Usability has many different aspects, and the importance assigned to each of those aspects varies across different target groups. Usability is not just something required by granny. Programmers and managers and accountants and 4-year old Joey and granny all require high usability, and it's a complete mistake to think that non-programmers are the only users to whom the concept of usability applies, and that therefore programmers can't produce the goods.
As a software developer, I expect high usability from my dev tools, and that includes powerful integration between all elements of the toolkit (instead of simplicity), and easy visibility of all component parts (instead of hiding detail on purpose). Neither of these are wanted by granny, but it's a total mistake to then conclude that important general issues of usability like consistency and layout clarity are of no interest to me. They are, and the tool programmer is the person best placed to understand that, and to deliver it.
To simply say "Don't expect usability from a programmer" may sound cool, but it's incorrect. It's incorrect because usability is a multipart issue, comprising a large body of domain-independent elements that underpin access to one or more domain-specific object sets and relationships.
Tool programmers are exceedingly well placed to develop high usability in the domain-independent parts (such as symmetry and clarity) since these require an analytic mind, as well as in the domain-specific parts that apply to the programming domain. The only area where they will often lack competence is in application domains outside of their personal sphere of knowledge. Well, nothing new there --- that's why additional input from domain experts is always required when writing a non-trivial app.
Does this mean that a programmer can deliver excellent usability in an educational app for Joey, unaided? That's unlikely, unless his or her domain expertise includes toddler education. However, the programmer has oodles of the usability expertise needed to deliver elements of usability like clarity and symmetry and effective feedback, because they apply to all target audiences, including programmers.
None of this excuses incompetent design from inexperienced coders of course, but that's a different subject altogether. Only a competent software engineer (both amateurs and professionals) will ever deliver a quality product, barring accidents.
"The question of whether machines can think is no more interesting than [] whether submarines can swim" - Dijkstra
No, the poster was subconsiously telling a good point:
/= lack of control
Usability
(Usability is divided by lack of control and stored back into itself)
In other words, the more lack of control, the smaller the usability becomes.
The poster was being a rude ass, because while the points he made about usability were true, the points he made about the parent's ignorace were bullshit. The parent post had been about interfaces that were bad precisely because they took control away from the user.
There are a large number of poeple developing software now who think that more options equals more confusion and therefore everyone should do things the default way and like it. Unfortunately, Miguel is one of them, and that's why the new Gnome sucks.
Don't label something "offtopic" unless you know the topic well enough to tell what's on topic.
>>"Is it time to pay more attention to end-users?(who aren't geeks)"
The fact that such a question can even be asked tesitifies to the arrogant lameness of many (not all) F/OSS hangers-on and developers who whine about Microsoft's enduring popularity yet continue to produce or extol software that only a geek would use.
If you make something people don't like using, why are you surprised when people don't use it?
Of course, if they started writing software for real people, the tinfoil brigade would have to abandon its two favorite excuses for the failure of F/OSS to take over the world's desktops: 1) The great Microsoft corporate conspiracy; and, 2) Stupid Users.It is much easier to posture as a victim of both Microsoft and users who are too dumb to use your software than it is to start paying attention to other people.
-- Slashdot: When Public Access TV Says "No"
amen- and this is why the one button mouse on the mac is so friggin' retarded. they may have done a study way back when that showed people had an easier time with one button, but people who have learned how to use multiple buttons are way more productive. when i sit down at a mac, it's like having my hand chopped off and navigating with a nub. some things are worth learning. what's needed is effective methods for teaching them, not dumbing down things.
Of course, Gnome seems to lose out on all these grounds. Whenever I'm forced to use it, I find myself grumbling that it's nearly as bad as its MS Windows prototype.
There are two possibilities here: (A) you are trying to bait me; or (B) you haven't used Gnome in a long time. Because anyone that seriously suggests that MS Windows is its prototype is _seriously_ misinformed. I suggest that you check out a more recent version, or try to bait other people.
Oh, and while I might be a proud Gnome zealot, I should also point out that xfce4 is a wonderful desktop environment and much more lightweight than a full Gnome installation.
501 Not Implemented
An easy way to put this is:
;) ) then the new drivers would be instantly put off, likely never to even attempt to drive.
Beginners and advanced users are the exception, not the norm. Make software that's easy to use for a intermedite, make it easy enough for the newbie to not throw up their hands in defeat, and open enought the expert has things to learn and use.
The car example is more apt then you let on. A car is very complex. Internally. The face given to the user is simple, but if you open it up and tinker there's a lot of complexity there. Most won't, but if your inclined to do so it's possible. If your skilled at cars, you can change the engine timings and add/remove parts for better performance, but it's still easy enough to use for a end user that they can sit down with it and it "just runs." If they locked things down so no one could change the parts of the car, the experts wouldn't be happy because they could no longer have anything to investigate or tinker with, and if they only stuck with the complexity (hey, just try and teach someone to drive with a manual clutch and see how enthused they are about driving
Better UIs aren't about limiting choices, but about making choices easier to make and use. UIs aren't about making complex things simple, but making complex things accessable. There's a big difference.
The worst part was that it ALWAYS took a few seconds to orient the mouse. No matter what, when you grabbed it you grabbed it in a slightly different orientation every single time. EVERY SINGLE TIME.
And all my Mac friends are "oh, look at the design, it's such a cool design, it's not a beige box, ooo, it's designed." Blow me -- I can chuck that beauty FAST if it's going to cost me in usability. And as far as the beauty goes, garish translucent colors may be great with the teletubbies set, but I never personally saw the appeal. "Lime green" is fine for chewing gum, but I can throw it away after I'm sick of it.
Of course, you kind of have to throw the iMacs away anyway, since they're still not user-upgradeable to a CPU of value. Perhaps it's just easier to toss them when they're already a sickened color of lime green?
John
.
usability expert Jakob Nielsen
Now that's an oxymoron about a moron!
Newsflash Nielson, you are the only person left connecting to the internet at 14.4kbps... the rest of us like embedded images. And yes, on occasion frames are useful.
Such features you advise against using were added to HTML/XHTML for a good reason - they allow better (more efficient) learning and task completion through greater human computer interaction.
Most of your usability heuristics were meaningless even when I studied them years ago at university. I wasn't the only one to think so.
You are a has-been who needs to think about the users of today, not the users of 14.4 kbps internet connections, on 486s with VGA displays.
Until you revise your heuristics, I will not heed them, nor anything else you say. It's a shame when someone who was respected previously continues to enforce their very dated ideas on a subset of the tech community who listen - and are unable to see the flaws and show signs of independent thinking.
--BladeMelbourne
I understand the unix philosophy perfectly, and you've described exactly what I'm describing as the problem. The unix philosophy of first making a black box backend with a documented programmatic interface and trying to keep that completely seperate in design from GUI front-end that's sprayed on at a later point.
User interaction takes place across the entire computing process, not just in the "pretty little front-end" that most programmers think it does. Your choice of algorithms, the names you give files, what engineering tradeoffs are made--everything is going to have some affect on the user experience.
No matter how elegant the programmers think they will have made something, if they try to make the technical part in total isolation from the usability part, they will leave out something critical, and one or more of three bad things are going to happen: the programmers will have to go back and rewrite zillions of lines of code and totally rework the architecture and/or the usability people designing the UI will be massively constrained in what they can do because of the shortsightedness of the programmers and/or there will be lots of legacy UI that confuses users and provides inefficient interaction but is kept in for some or other technical reason (usability guru Alan Cooper refers to this as "scar tissue").
While the MVC design pattern, which has been successfully used to create usable software, does make some attempt at seperation of UI (View) from code (Model), to exploit this pattern to make the software usable and feel truly integrated, you have to design the view first. If you design the model first and the view with the optimal usability breaks the model or the model can't be accessed fast enough, you're screwed. To be able to access your model fast enough or in the right way with your view, you have to make design decisions and tradeoffs regarding how the model is built. How these design decisions are going to be made will depend on how the user accesses the view. You can't simply build a model then try to attach a view to it.
I hope I've clarified my point of view a little.
Ergonomica Auctorita Illico!
OK all you developers, here's what you should think of when you hear the word "usability".
Get a randomised group of your product's end-users. If your program is for sysadmins you'll want to get sysadmins, and if your program is for novices, get novices.
Set them a series of tasks to perform with your application.
Watch them try and perform these tasks.
Stifle the urge to scream "No, you fool - it's over there" as they fumble around the design that you thought was so brilliant. Instead, take lots of notes.
When it's finished, work out where the common problems are, and then fix them.
Rinse and repeat with a new set of users, until they all get it.
Note that this has nothing to do with arguments such as features vs. simplicity, or GUI vs. CLI, or newbie vs. experienced user. It's just a practical guide to smoothing out your application.
After you've done this with a few apps you'll start to get a sense of how to incorporate good usability from the start, but remember, there's no substitute for testing with real live users.