User Feedback and Open Source Development 327
Earl Shannon writes, "With the new release of Sendmail I was looking over Sendmail.net and
came across this essay called It's the User, Stupid. Author Mike Kuniavsky states a very important question if Linux wants to make inroads on the desktop as an open source solution. How can the open source development model obtain the necessary user feedback to development interfaces that the user will intuitively able to use?"
Re:Why is mounting nescessary? (Score:1)
MacOS mounts disks. It's just better at making the process seem transparent. Thus, the system is aware of which disk is which and will yell at you if you try to write something out to "Disk FOO" and shove in "Disk BAR" by mistake.
BTW, this awareness of the disks unique identity is something that we would do well to emulate in Linux.
How to take over the world in 5 easy steps. (Score:1)
Now once you're completed, tally up your points to see how you've done.
Deja vu all over again (Score:1)
Worse, we appear to be losing the race as a competetive server. It isn't just Microsoft's paid lackeys who are producing benchmarks showing inferior performance. IBM, who supports Linux, ran their own multithreading tests and Linux fared rather poorly. IBM also offered code which the Linux kernel developers could incorporate under open source, as I understood it, which would improve Linux's performance. I haven't heard what happened to that offer.
I am afraid we are listening too much to ourselves, there are plenty of us to listen to, after all, and not listening enough to the rest of the world on how to improve Linux and it's interface.
Perhaps Red Hat should not be paying programmers but instead should be paying users to use Linux and provide critical feedback.
my example is usually Grandpa (Score:2)
I don't think it's exclusive to OSS people either, just about anybody who wants to explain complicated things uses a "Relative So-and-so" name. I'd imagine it also comes from the old mentality of thinking women couldn't do anything except cooking and cleaning. Now, we say women can't understand computers instead of saying they can't understand cars or something like that.
Re:What intuitive is (Score:2)
I can tell you something (from Tog, actually) about 'intuitive'. The early Apple usability testing to determine 'intuitive' was not theoretical- it was experiential. They would literally sit people who'd never seen a computer before, down in front of (for instance) checkboxes, and say "Do stuff- and then tell us what these things do!"
Interface elements which could _not_ be figured out without help by intelligent but totally inexperienced people were changed until they _could_ be figured out, just from fiddling with them and seeing what happened. That's the bedrock upon which pretty much all GUI was built. (The Xerox GUI that inspired all this was actually a _lot_ more like Linux- it was basically Smalltalk! Contextual menus, no direct manipulation)
For example, Tog has a case study- the 'one or more' control. It's not a checkbox, because it forces one choice to be on always. It's not a radio button because it can have all or several choices on. What does this control look like, and how does it act- in such a way that a totally inexperienced person will (after playing with it) say, "Gee, looks like I can turn on one or more of these options"? It ended up being _square_ radio buttons. Tog had fought this because the turned off state looked like a turned off checkbox. Upon mentioning this to his peers, they replied with one voice, "In its turned off state it IS a turned off checkbox!"
- Turned off one-or-more: clicking it turns it on without affecting anything else.
- Turned off checkbox: clicking it turns it on without affecting anything else.
At that point it was merely a question of setting it up so that if you tried to turn off the last option, another one would turn on kind of like squeezing a blob of mercury that would squirt out to the top or bottom- something that would make people go 'Hey, it is making one option stay on!' without causing them to make up weird rules like you had to use one of the top two options, or something.Interface is _interesting_, and Kaa has summed up 'intuitive' wonderfully with this simple guideline. It's not really necessary for the first try to work if the person can guess what the feature is for, and how it functions.
For a wild eye-opener on this try reading Tog on an old Apple ][ interface issue- how do you get the user to tell you if they are using a color or monochrome monitor? This was the toughest problem they hit! Yes, the answer was a variation on 'display, in different colors, the question "Are these words on the screen being shown in color?"' Hint: monochrome monitors were often green or amber screens- and green is a color ;)
Wheee, interface!
Re:Easy Question (Score:2)
Competent programmers _know_ that they sometimes have to throw out a design or code that doesn't really work, and excellent programmers do so on a regular basis. Many people complained when Raster and Mandrake threw out the code and design for Enlightenment and then redesigned and rewrote it, but it is now a kick-ass WM that has the highest "eye-candy" factorout there. But, on the other hand, throwing out everything about Linux that one guy didn't like, and reworking things even down to the very internals of the file system seems a tad drastic! For one thing, the reason that a lot of the designs that went into Unix 30 years ago are still around, is that they are well-thought out designs that have stood the test of time when other designs have failed. This is a point that I try to drive home with people who bash Linux by saying it is based on "old ideas from the seventies" or something similar. Unix works, and the design of all the pieces is rock-solid, having been fine-tuned, extended and even replaced here and there as new things come along. Is it the best design for every circumstance known to computing? A wholehearted "NO". But the Unix design philosophy and implementation is what works in most situations, so it is what so many people have come to know and love.
It is obvious that you don't know what you are talking about when you confuse the internals of the system with the UI. Journaling refers not to how the files are presented to the user, but how the system itself maintains the files so that they don't get lost or corrupted if the power is cut off.
The way the system works "under the hood" so to speak, is not how it has to be presented to the user. For example, the way that the system displays the layout of files as a "tree" of directories (or folders, for Mac and Windows people) has absolutely nothing to do with the way that a Unix/Mac/Windows computer actually stores files on the disk. If you wanted to have a UI that categorized files according to there type/use and kept them in containers that were operated "assigned" to individual programs, that's fine. Here we separate the UI from the actual operation of the system. That's what Unix people like, by the way, separation of data from presentation/manipulation of that data.
Also, just because you do not understand Unix and it's history, don't criticize it. The text based UI's have evolved tremendously over the years as we went from batch-oriented cardpunch machines to terminals to workstations, and the shells and text tools of today are very rich, powerful things. You denigrate them because you do not understand them. A GUI is good for many things, but there are some things that simply can not be done in a GUI environment. I like the ability to chain together half a dozen command line tools in an interactive shell session to perform complex tasks that I simply would not be able to do in a GUI program. I also like web browsing and graphic editing and other programs that are best suited for a GUI. I use several terminal windows alongside GNOME/KDE/X programs because I like the best of both worlds.
As far as competeing for the home desktop, well I'm sorry, you must have confused us for a tightly knit group of people. Where did you (or anyone else for that matter) get the idea that _every_ Linux user wants to "compete for the home desktop". That would be nice (IMHO) but not necessary, and groups like KDE and GNOME are trying to do help out, with the help of money from VA, Redhat, Corel, and SuSE. I use my Linux box to _WORK_ on, it is a tool. A lot of times that work is fun, because I am a geek. I also have a windows box for games, so I guess it is a $2000 playstation or something.
As far as your last cheap shot about DOS/Windows and Linux/X, please remember that Win3.x _attempted_ to provide a GUI and simulate a multitasking system on top of a weak single-tasking DOS kernel (mostly by working around it) and failed miserably.
Windows 95/98/ME attempts to provide a more robust multitasking system, but ties the GUI to that multitasking system. Windows NT/2000 also tries this, and succeeds more often that 98. Unfortunately, the GUI _IS_ the system, so you can't have one without the other. I like how parts of NT are designed, but I can't drop in another UI to replace NT GUI, nor can I leave out the GUI altogether and get any meaningful work done. It would be nice if NT allowed one to go directly into a CLI and did not waste any CPU cycles on the GUI. Linux provides the system, X provides the GUI, and both are very well-designed for their targeted goals, and I can interchange them as necessary. Your "uber-GUI" that you describe above is doable on X without replacing the underlying OS layer. If it aint broke, don't fix it!
Thoughts on Linux UI (Score:2)
Unless you'd like to claim that Windows isn't ready for the desktop...
And then it occurred to me that I have a slightly different definition of "using" than everyone else. I mean doing things like word processing, or browsing the web, etc. Actually getting work done.
I do not mean installing the OS, or getting drivers to work, or installing software, etc. Those I call "administration". The implicit assumption is that the user is also the administrator- and that the box must not only be easy to use, but also easy to administrate. Professional admins need not apply.
In a home environment, there is some legitimacy to this thought (although I'd debate it- how often to YOU have to go over to various relatives or friends houses to fix their computers?). In the corporate world there is NONE WHATSOEVER.
Consider for a moment how many positions are available for Windows administrators (certified or not). With a network of even as few as 100 desktops, you need a professional, trained admin. Very rapidly you need a team of them.
Or should grandma be able to administrate a network of 2000 desktops, half a dozen file/print servers, and a million dollar database server?
Once you accept that even small corporations have professional admins in residence, then it isn't a problem if Linux _requires_ professional admins. In the market it's likely to penetrate, the admins are already there. The budget is already there. And Linux is ready for at least that desktop (the home market will be a longer time in comming).
Open-sourced user-friendliness (Score:2)
Many of us have non-technical friends. They can be an excellent resource in helping to make a program more user-friendly. The trick? Listen to them! Ask for their feedback on what things they find difficult to do, what things they would like to be able to do. The fact that they are non-technical is an advantage here, because it means that the only real way for them to be able to effectively use the program is if it is easy to learn.
The real trick is, of course, making the program easy to use as well as easy to learn, and that means optimizing the program for its primary mission. It's important to avoid creating a "swiss army knife" since that will not only make the program more difficult to learn but will force the developer to concentrate his effort on something other than the main purpose of the program.
Programs that are simple but powerful are rare, but are among the best finds out there. I think that simplicity and power in a program aren't mutually exclusive when the program is done right. One cheap (and perhaps relatively easy) way to make a program powerful and simple at the same time is to create the user interface so that only the most common functions are readily available in "normal" mode, and arrange for the rest of the functions to be available perhaps via a command line (the program will be a lot more powerful if it has a built-in scripting language) or perhaps via an "advanced mode".
Just remember that large arrays of buttons and tons of menu items will make the program more difficult to learn, so it's important to concentrate on making available (at least in the default UI mode) only the most important functions of the program.
--
Of course compilers don't! (Score:2)
But they make a decent attempt at figuring things out (even though doing it perfectly is impossible) and as a result can do quite a bit of optimization.
Likewise many more options can be graphically indicated than most people think. Ask an OS/2 fan some day about the Workplace Shell.
Cheers,
Ben
Cop-out alert! (Score:2)
They are not equivalent.
One program cannot figure out what another one is doing. This is called the halting problem. However we have an entire class of program known as a compiler that typically attempts to do it anyways and figure out how to make the program faster. Sure, it cannot work in general, but it can work well enough to be very useful.
Similarly it is easy to say, "Oh, this is hard. If you cannot do X, Y, and Z then you shouldn't touch this." Sometimes that can even be true. (I don't want to trust any network whose security was set up by an automated program and then forgotten.) But in many cases it is quite possible to produce a good user interface that can do a lot more than one would expect. The value of this cannot be underestimated.
An interesting admission from a friend who is an old Unix hand (in fact he was a kernel hacker before the days of Linux). A couple of years ago he saw a demo of Photoshop in the store running on a Mac. He doesn't use Macs. But he likes photography, so he tried using the demo and found the program friendly and easy to use. Since he had a copy of Windows at home he bought a copy for Windows, took it home, and couldn't figure the darned thing out! Same program. Two operating systems. One has a good user interface, one a so-so one, and the difference showed.
Consider that story the next time you want to feel all superior about user interfaces.
Cheers,
Ben
Apple Human User Interface Guidelines (Score:2)
--
Re:It's a stupid title, stupid (Score:2)
As in,
Breathing for F@ckwits.
SendMail Configuration for F@ckwits.
etc.
I do hope no one is overly traumatized by my language. I wouldn't use the @ except that then I'd just traumatize those who are offended by 'Fuck'...
Opps. Just can't win...
--
Flawed assumptions here (Score:2)
Additionally, while it can be difficult, it is possible to incorporate feedback from "ordinary users" (or at least slightly adventurous non-programmers) into the open-source development process. Particularly since the new beta release, the GnuCash mailing list receives quite a lot of mail from non-programmers asking questions and commenting on the project.
Re: the *real* intuitive interface (Score:2)
now you know what shape to give to your OK buttons.
Interfaces :-) (Score:2)
The only intuitive interface is the nipple. Everything else is learned.
I think you missed the point (Score:2)
Hey, moderate parent up! (Score:2)
More 'lookatmeI'mwritingaboutopensource' antiganda (Score:2)
When people talk about Open Source products, you hear
about their speed, their efficiency, and their features. What
Only when people who aren't actually part of any real projects talk about
it, do you hear nonsense like that.
you don't hear is how innovative their interfaces are.
Why? Because they're not. At best, products created by
the Open Source movement offer workable imitations of
popular commercial interfaces; originality is rare, and
In the cases where the commercial interface is good and interface is
part of the design goal, (gimp vs. photoshop, for instance), this might be
partially true. However, even with a perfectly intuitive interface, very
few commercial applications will give you the benefit of ALSO being able
to configure your app up the wazoo.
In the case of something like apache vs. IIS, the apache 'interface,'
while being a flat text file, is _extremely_ easy to configure. It is also
completely well commented, documented, and easy to get free support for.
There is _also_ a gui-style configuration utility, if your definition of
'intuitive' is 'gui.'
routinely found in the underlying code. This presents an
interesting dichotomy: why is the best software writing
organization on earth unable to produce innovative
interfaces, when small commercial software companies do
so with regularity (if not always with commercial success)?
This is not an interesting dichotomy, this is bullshit. OSS is not, by any
means, 'the best software writing
people, for solving problems and scratching an itch.
The answer is relatively simple: The Open Source
movement has no feedback loop to end-users, and no
imperative to create one.
Bullshit, and bullshit. I read the entirety of the gimp-devel
and new-httpd lists every day. Those lists spend entire days hashing
over tiny changes to the interface. Your entire premise is that these
projects are coded without attention to user interface, and that shows
that either you've never been involved in an open-source project, or
you've been invovled in some that work in a totally different way than the
ones I've seen.
I vote for the latter - I think this article is a fine example of
'me-too,' 'hey-mom-look-at-me-i'm-writing-about-open-source
Guess what? Like all the equivalent tripe, it makes me ill.
The majority of Open Source software is still written for
programmer-users: the systems are made with flexibility -
not usability - in mind. Enough hooks and parameters are
Bullshit. Are you going to tell me GNOME and KDE are written for the
programmer?
But that's only a small slice of the world's software users.
Most people want a product that works right out of the box.
Gimme a percentage of applications that you think work 'right out of the
box.' The fact is that _most_ software, OSS or not, still sucks.
Commercial software actually sucks MORE, because it is more
cash-efficient to add new features than it is to fix old bugs.
I'll go ahead and
before this stupid article interrupted me, but I do wanna say one more
thing:
Don't confuse an interface that seems obscure to you with lack of
attention from the programmer. Just because YOU don't get it, doesn't mean
it wasn't very carefully designed to work exactly as it does.
Re:Intuitive Means Windows (Score:2)
Quitting programs - there's at least 4 different key combinations which will accomplish this, but each program only accepts one. (Alt-F-x, Alt-F-q, Alt-g-x (in Microsoft pinball where the file menu turns into a game menu instead), and alt-f4 occassionally.
Microsofts tabbed dialog boxes used to be nice, when there wer just a few screens worth of options. But now, when there's 10 or 20 tabs all crammed into one small window, it's utterly confusing.
If you want to create an interface that good enough, then by all means, copy windows to the T. But if you're looking to create a "better" UI, you'd be best to look past windows towards BeOS, Openstep, Mac OS, and Mac OS X.
Re:Open Source Interface Guidelines (Score:2)
So the real trick is to recruit some Lusers. With the hype OSS has recieved, you'd think it might be possible to get some "regular joes" to participate.
Look perhaps to the graphic designer community. Here is a non-technical community that is generally sitting in front of a computer all day. They understand 2-d design and layout, and also computer-human interaction. But they're not geeks.
I honsestly don't know how to organize such a venture, but maybe somebody else does. just my nickel.
It's the User, Stupid vs. It's the Stupid, User (Score:2)
That said, I'l like to point out some errors in the article. The first is that commercial programs often comes up with innovative user interfaces. This is some rare times true, but most often, commercial applications are must-get-it-working-before-deade-line-programs. Those are never innovative. Most commercial programs have very clouded user interfaces, filled with toolbars and buttons, just confusing the user.
There are two simple guidelines to help free software projects on this point; ask your parents about the interface. They'l probably be users, _and_ like you enought not to ask you for money
--The knowledge that you are an idiot, is what distinguishes you from one.
Re:You can't make it "intuitive" if it isn't. (Score:2)
Nowhere did I say that people shouldn't have access to the full power of their computers.
However, I did say, and continue to say, that you cannot abstract away all the difficulties without losing all of the power, too.
Policy-based routing, along with special cases for proxies for certain services, is powerful. You cannot make it "intuitive" in the sense of "accessible to a naive end user".
There is certainly a lot of excess complexity in modern UI's, and it should be reduced. However, never make the mistake of believing that you can somehow magically make something complicated so easy that a naive user can understand it without effort.
If you look at modern UI's, they're often much worse than older ones, because we've started getting used to them, so now there's all sorts of underlying things you need to know to even *begin* to make sense of a Windows system. "Move your mouse over the grayish areas to find pictures you can click on" is not an "intuitive" concept.
Should non-techies have access to the full power of their computers? Should non-mathematicians have access to the full power of analytic geometry?
I have no problem with people having access to anything they want, but it is *logically impossible* to make the interface simpler than the task it performs.
"Average" people, right now, have access to a great deal of computing power, and a great deal of information, that they didn't ten years ago. We're making progress. However, just as people who want to drive need to spend a fair amount of time learning about cars, people who want to use computers will still, always, need to learn how.
Natural language? Still takes time to learn how to interact with a system, what its limits are... It's always there. *People* have a learning curve.
Re:You can't make it "intuitive" if it isn't. (Score:2)
I think the problem is trying to eliminate the wrong complexity. We try to make it so that an "end user" can easily do something, like routing or network admin, which is simply *not actually an easy task*.
Screw that. Let's try to get them something they can *USE*, maybe some word processing.
Re:Cop-out alert! (Score:2)
And I never said it wasn't worth doing UI's right, just that "intuitive" is often meaningless, and that we should remember that the systems we have now on, say, Linux, *allow you to do things*. If we take away those options, of course we can make a very easy interface; eventually, you can simplify any GUI to a single-click interface, which doesn't work.
Symbols in interfaces (Score:2)
I've been thinking of some alternate user-interface ideas, and one possibility I picked up from reading Tog (or was is Nielson?) was that of using "official icons"-- namely, ISO standard international symbols-- as a good, consistent visual supplement to the interface. (These symbols, I believe, are seen a lot in European countries. I don't think they're used a whole lot in the U.S.)
Problem is, I've looked everywhere, and I can't find any references for such symbols. The closest I've come to is this site detailing IEC 417 [chiba-u.ac.jp] (which is why e.g. the "Play" and "Pause" buttons on media players are all marked the same), but that's about it. The ISO site [www.iso.ch] helped, but not by much (their search engine sucks rocks).
So, would anyone here know of any links detailing said standard international symbols, or at least some relevant ISO numbers?
(P.S.: I already have ISO 7000 - "Graphical symbols for use on equipment")
Slight problem (Score:2)
There's just one problem, however . . . when I submit my name/e-mail to the announce list, Zope sends me a login/password dialog. Authorization fails. There's a bug rattling somewhere in there
Re:Is it just me .. (Score:2)
Re:You can't make it "intuitive" if it isn't. (Score:2)
Re:Common misconception(s) (Score:2)
I generally like your post, but I'm not sure I agree with your logic on this part. It's trivially easy to find mechanical devices where you move something down to move something else up. If the widget you describe didn't survive, I suspect it was because it bet on the wrong horse, not that it violated any natural principle.
> Most Linux programmers seem naturally disdainful of graphic interfaces and therefore are slapdash in implementing one.
I think this may have been true in the past, but I also think we're seeing what we might as well call a "new generation" of Linux programmers who aren't at all disdainful of GIs. Whether that results in good GIs will be interesting to see.
--
Re:Haiku? God bless you! (Score:2)
As they're fond of pointing out over at c.o.l.a., the only truly intuitive interface is the nipple; everything else is learned.
The obvious conclusion is that we should discard the outdated point-n-click metaphor and replace the GUI with a truly intuitive LUI (Labial User Interface) using a grab-n-suck metaphor.
However, although it is easy to imagine replacing that 19" monitor with a 36" set, and although the LUI would surely be fun to use (or at least comforting when the inherent complexity of the machine upsets you), I have not figured out the best way to use the LUI for such mundane tasks as data entry.
p.s. - Imagine the rash of "one suck shopping" patents and "look and feel" trademarks this technology is going to spawn!
--
Preventing redundancy... (Score:2)
Emmett, man, do a search on Slashdot before you post a new story that contains such an old URL. It says right at the bottom of the page on sendmail.net that this article is from late January. I don't mean to flame you, but if you do that search, it'll probably save you a lot of hateful email in your INBOX.
Now, the hundred other people who are going to flame emmett, just save it.
Re:Common misconception (Score:2)
I wholeheartedly agree. I'm a very technical user, but installing things in Linux, even when using RPMs is still harder than installing DOS or Windows programs.
DOS was easy because all you had to do is put the files on your hard drive in some random folder and they worked. Windows generally had some kind of install program that did the work for you. Unfortunately windows made removing software you installed a real pain sometimes, but at least you could get it there.
With its logical hierarchical filesystem, and a standard way (actually a few different "standard" ways) of organizing things, Linux should be an easy platform to install/remove software for.
But it's not. Certain packages require other packages. They require certain libraries. They are distributed in different ways: tarballs, RPM, .deb, whatever. Then, once they're installed, there's the problem of configuration.
When a typical Windows app is installed, if it needs to be configured it will force the user to configure it either as part of the installation process or as something run the first time the program is started. With Linux software, often you have to get out your fave text editor and mess around with a config file, often written in some obscure way, until the program is configured however you like.
While this method does often ensure much more customizability than you get in a Windows app, the fact things don't work "out of the box" gets pretty annoying.
A low cost solution to the user feedback problem. (Score:2)
Ugh. I think I speak for all of us. ;-)
As to the question of "how do we make the GUI more intuitive?": we just need to extend the Open Source model. "All bugs are shallow", right? Think of a user as being one of those "solitary" developers, and set up a way for them to feedback into the system. Perhaps Linus can require that all GUI code come with a mechanism -- say an HTML page that includes a mail form -- to give feedback to the developers of that GUI. Or if the developers are loath to embed their email address, perhaps a forwarding box could be set up somewhere *expressly* for the purpose of receiving and routing feedback. The mail form that comes with the GUI could come with a Subject line already set up (or with some hidden info that encodes what the subject is), so that once the message arrives at the forwarding box, it could easily be sent on to the proper people. Thus the feedback loop is closed and it's a win-win situation for both developers and users.
hardware problem - there is no good way on a PC (Score:2)
The hardware ought to be fixed up, so it tells the OS when someone pops a floppy in, and prevents the user from ejecting the disk when it is in use (with the main button, though there should be an auxiliary mechanical button for emergency use, just like a CD-ROM).
Linux systems can be configured to automount CD-ROMs, because CD-ROM drives don't have a completely braindead design like PC floppy drives.
Dual interfaces (Score:2)
The think i'm thinking is going to be needed is a very lightweight and pervasive object model (NOTE: This does not mean C++ necesarily, but does not exclude it...) By lightweight i mean that there aren't many levels of unnescesary and painful inheritance and bulling-around. By pervasive i mean that in at least it's most minimal definition, it is a common element to all parts of the system, from widgets to programs to whatever.
Also a simple but powerful embedded language (NOT for performing major tasks. Infact it should not have loops or other structures that would encourage such EVIL!) but for acting as the glue for connecting parts together.
This would have a lot of the advantages that M$ claims that OLE/VBSCRIPT have, but we can learn form their mistakes, avoid their pitfalls, and not have to work around ajenda item 1 being "produce code that is incompatable with the rest of the world to flex our monopoly".
One of these days i'm going to start this project. I'm one of those people who is ever-annoyed by slow GUI's (infact i've been called a Text-Nazi by my friends for my continued use of JOE, PINE, LYNX, and because i categorically reject all HTML e-mails...) so my first priority is to provide and efficient and practical interface with equal access to both text and GUI users.
I figure i'll think about this more over the next while (seeing as i don't have much time for non-work programming these days anyway...) So in any case if you have any input (i'm not ready to start this yet, but i would like more input for my brain to stew in) feel free to email. Just to get a guideline, of all the GUI models that i've seen, the best (conceptually, the implementation could have used a little help) was on the Amiga.
User Feedback loop? (Score:2)
That is entirely up to the developers. As someone on their way to releasing a GPL'ed music program for Linux, the last thing I want is to make the interface suck. There will be copious reminders to the effect that if you want something changed or have a feature/interface suggestion TO PLEASE MAIL THE AUTHOR. Just because the users in my case won't be programmers doesn't mean they can't contribute meaningfully to a project. I think many people are scared that if they can't program, they can't help an OSS project. This is not true: there's nothing more motivating to a developer than receiving lots of e-mails that say "great program but it would be nice if I could use the function keys to switch between windows."
For applications there are plenty of strategies to improve UIs:
The rest of you seemed to have missed the point... (Score:2)
Actually, I think the article should've been posted as an "Ask Slashdot" instead of being a "news item" (which has been discussed before, as someone has already pointed out).
It is a good question. From what I have seen, some open-source projects openly discourage regular users from submitting suggestions on user interface improvements [flamebait] (you GNOME/KDE/Linux zealots have only yourselves to blame...
Other OS projects are structured such that only developers/programmers have any say as to the design of the system. Obscure mailing lists with awkward majordomo commands certainly make it difficult for the average joe to participate, and it doesn't help when the rest of the participants are developers who have no sympathy for the poor guy because he can't "hack it".
I'm hoping great projects such as SourceForge(is that right?) stuff will open the communication lines, and blast the doors held closed by these "open source is for everybody, but to heck with the user" hypocrites.
Open source has to be truly open-source for everyone...not just the programmers, who, by necessity, have a very narrow few of the system they are designing. In fact, when you allow the people who will actually use the program in, we may actually get around this "the source is everything" mentality and gravitate to an "Open Design Project", where everyone works together ont he specification, design, AND coding of the system.
Too allow the people without the programming expertise to participate, you'll need to add an extra cycle or two to the phases of an Open Source project...requirements gathering (you must ask what users want) and requirements verification (is this what the user wants?).
Excuse my ramblings...I just think that the term Open Source is just too limiting.
If you can make sense of this, paraphrase it so that my befuddled brain will know what I am talking about.
Re:You can't make it "intuitive" if it isn't. (Score:2)
In some rare cases, these phrases may have utility, but by in large you're just asking for trouble if you let them pass your lips.
Take the typical desktop metaphor. It is not "intuitive". It is better than intuitive. First I haul a docuent out of storage (which can be made fairly intuitive). It floats around on the screen, but i can "minimize" or "hide" it and bring it back; this is not intuitive, but it's very useful. In most X based GUIs, I can "pin" a document window to the screen (not intuitive, but useful). WHen I'm done, I close the window (how did a document become a window? Is that intuitive?) and it goes right back where it belongs, I don't have to root around for the right place to put it back. That's not something somebody unfamiliar with computers would expect.
That doesn't mean that programs that are unnecessarily hard to use get off the hook though. Probably every program ever written could be better, but the problem is that making life bearable (much less "intuitive") for Aunt Millie is just not an itch most programmers seem to have.
Re:Symbols in interfaces (Score:2)
Of course, I can't seem to find the same info online, but I hope it is at least a start.
Ways of doing it... (Score:2)
- Know the audience.
- Know what the audience will want to do in the software.
- Know how the audience is going to want to do it in the software.
- Lastly, decide how to code it.
People decide whether or not to use something based on it's interface. So design the interface first. That will make them use the software. Then, if you've done that job properly, the way you code the software will determine whether or not people LIKE it, and continue to use it.Cooperation with Psychologists (Score:2)
As CS students / graduates seem to contribute much to OSS, why not try to cooperate with Psychology students in order to establish GUI / CLI evaluation projects. The students could work on real world problems, the user-friendliness of the software might benefit.
As mentioned above, this seems to work in departments of CS and Physics, so it might be worth trying.
non-programmers' feelback => flame prune. (Score:2)
A "clueless" user asks some questions in a forum (Usenet/slashdot/irc/...) and get RTFM'ed before he has a chance of figuring out, where to get The Fine Manual. When he asks how to make apache do this or that people reply "vi access.conf" and expect him to in a flash of light be totally sure what to do.
A "clueless" user who is not unixified yet asks: "Why is X configured so many places?", "Why is there an stty, a termcap, a keyb.conf, an xkeymap, a resource file floating all over?" or another finger-on-sore-spot question and immidiately is flamed as Microserf of Gates lover or other verbal abuse.
A "clueless" user has a need for a program to do this or that. He is not a programmer but quite knowledgable in his field of profession, and poses an idea for an OSS project. Some replies that "If he wants this $&?! program he can do it him self!", and some gives some suggestions under the parole "if you don't program, you don't know what you are talking about."
. . .
My girlfriend is a fashion modeler and uses programs under another OS to make models for sewers. She don't know a thing about programming but all about clothes and asked me, how such a modeling program would come to be in an OSS world. She is the "clueless" user of computers, but the skilled modeler, who desires to contribute to the OSS with her knowledge if she can convince a programmer to transform this knowledge into programs.
If feedback an input from users are weighted solemnly on the user's computer skills, the OSS community will never go beyond making programming tools.
Re:Intuitive Means Windows (Score:2)
A good example is anything which contains a lot of text. You have to say so much, that typing is much much faster.
Re:Why is mounting nescessary? (Score:2)
vold under solaris or magicdev under linix both automatically detect the insertion of cd's and floppies and mounts them for you.
Re:Open Source Interface Guidelines (Score:2)
you raise some good points:
Actually, this is exactly what Microsoft has done as well. In order to earn the "Windows 95 Compatible" logo for your software, it must meat specific interface requriements. Things such as what happens when you hit the tab button, and how custom dialog boxes should be laid out. One this about Windows programs is that, by and large, they are extremely consistent, even between vendors.
I don't feel that this is necessarily the way that the open source community needs to go. I don't want my KDE programs to act like my GNOME programs, and neither will act like emacs, no matter what we try to do (although many emacs movement keybindings work inside Netscape dialog boxes...).
Yes! Exactly. But now that you and I have recognized that, what do we do...?
darren
Cthulhu for President! [cthulhu.org]
Dare I say it? LOOK at MS-Windows (Score:2)
Microsoft deserves credit where it is due. No-one doubts their marketing prowess, or ruthlessness either. I believe they have put considerable effort into UI design via expensive user panels and focus groups. They certainly haven't put effective effort into OS design, which has become recursive layers of kludge frequently going random. But there is no reason that we should not incorporate User Interface findings to the extent possible. Furthermore, it would ease transition.
To the specific question about OS incorporating user feedback, as a modest OS developer (cpuburn) I feel particularly qualified to comment. I get some user feedback, and if it seems like a good idea to me, I will incorporate it.
But if I don't like it, forget it, and I may be capricious. One MS-Windows user wanted start & stop buttons added. I firmly declined, even though I conceed it will improve ease-of-use. I prefer the user learn about TaskMan. If he wants buttons, let him add them. The code _is_ GPL.
Experienced computer users want ease of use too (Score:2)
Re:What we might actually DO about this (Score:2)
Under WindowMaker, options can be set, depending on context, by right clicking on a docked applet (like the Wharf) or by loading wmakerconf. Want a docked applet to automatically load on startup? Right click on it and check a box. Want to change your backround? Wish to use a different font in your root menu? Load up wmakerconf. With AfterStep, all these options are easy to set if you which file contains each option. On Freshmeat, there's something called AS TOOL [freshmeat.net] that sounds promising (from the brief description) as a graphical configuration tool, although the linked Web site doesn't talk about it. Damn.
With the recent developments in AfterStep's theme configuration, it seems that AfterStep is moving closer to an "end-user" GUI. Once a graphical configuration utility is implemented, all that is left to do is implement some type of desktop metaphor (not necessarily whored from Mac OS, mind you). A graphical tool such as this wouldn't be too hard to design, I would think.
As for open source and the design of GUIs, it seems that we all want something different. Granted, most of us want configurability, but some want to use graphical tools, while others prefer text files. To make Linux a more viable "mom" desktop environment, designing some type of forum would be a great idea. I have a feeling, though, that it would run into many of the problems that are currently plauging Slashdot: trolls, karma whores, etc. (I don't see how the 31337 first posters would fit in, though.) Solutions to these problems would have to be worked out so that usable GUI standards would be set. And who's to say that every programmer would follow the guidlines? It doesn't happen under Mac OS, an OS that has relatively stringent (but friendly) guidelines for GUIs (see [apple.com]
http://developer.apple.com/techpubs/mac/HIGuide
Clearly, something needs to be done. User feedback is a start. I don't think there are really any surefire solutions out there. Linux desktop environments will evolve just like the more traditional user interfaces have.
Re:copying (Score:2)
not a very logical operation.. Just put someone who never used a computer behind a mouse, and have him start a game, with a link on the desktop. first he'll have to get used to the mouse. but before he finds out doubleclick could take a while.
//rdj
"Aunt Millie" (Score:2)
The person you're trying to reach isn't necessarily female, and not necessarily a fool. Everyone can benefit from good UI design, otherwise this would all be wasted effort. Remember the theory from college "make the common case fast"? Well, this is fairly similar: "make the common case obvious". Advanced bells, hooks, and whistles are wonderful, but their prominence in your design should befit the frequency of their use. That's one thing I think we generally do pretty well at Microsoft, although it sometimes requires a lot of bitching and moaning before the natural instincts of our devs for obfuscation and tech talk can be overcome
-konstant
Yes! We are all individuals! I'm not!
Re:I totally disagree... (Score:2)
In fact, this was the feature I was hoping to see most when I downloaded Helix Gnome. I was quite let down to see that the menus at the top are just 4 menus that never change, not the menus of the program you're using.
--
Re:Intuitive Means Windows (Score:2)
--
Re:Intuitive Means Windows (Score:2)
--
Re:You can't make it "intuitive" if it isn't. (Score:2)
<br><br>
THIS IS THE PROBLEM<br>
<br>
There are two different kinds of complexity here. There is the complexity of how a given task is performed, and the complexity of what the end result is. I don't believe that these are in any way inherently correlated to each other. Complicated processes can produce simple results, and vice versa. <br>
<br>
In the first case, the user needs to be able to express what they want the final state of the machine to be, rather than tell the machine how to get there. In the second case, it's going to be simpler just to tell the machine what to do, and let it trust you that these steps are towards some desirable end. <br>
<br>
Given the correct tools, many difficult tasks are easy. Given the incorrect tools, many easy tasks are hard.
Being all things to all people (Score:2)
He approached it from several different angles. He explained why the programmer, with his intimate knowledge of the capabilities of the software, the data formats, the interfaces, the controls, the options, is the last person in the world who should be defining the interface that a non-programmer user will use. He explained the importance of seeking out representative users and observing what they do rather than just asking them. And he said something that stuck, "The user is always right."
I used his own material to tear apart the all-GUI-all-the-time interface that has become the norm these days. I pointed out that the same things that make user interfaces approachable for the novice, and diminish the memory burden for the occasional user are often impediments for someone who executes the same task hundreds of times a day. If that person is also a programmer, with the skills to take a scripting language or a powerful set of configuration options and work some minor miracles, then the lack of those capabilities is keenly felt. For me, the joy and power of the Unix model of the world is that the interface I use daily can turn my repeated tasks into shell scripts that capture my knowledge of how to do it and relieve me of that burden.
A friend of mine commented in the late 80's that Unix had a lousy user interface. I replied that the shell lacks many of the things that people look for in a user interface, but as a programmer interface it is one of the best ever designed. I likened it to a readable JCL (he was a mainframe systems programmer). There is power, and an assumption that you can figure out what to do with it.
But there is no need for one interface, either a ubiquitous shell or a full-time GUI to be the single interface for an OS. Companies selling Linux to the desktop market can build powerful GUI installers and desktop environments on top of great open source tools. If the scriptability and the configurability is abandoned, Linux will lose the mindshare that moves it forward. It will lose the programmer-users who have come to it because it meets our needs. We can create the environment we want. We have shown the world that we don't have to settle for any software but our own. But giving Mom the GUI desktop that helps her find her e-mail twice a week, visit a couple of e-commerce sites, and do her taxes does not need to change the underlying engine.
Open source is already many things to many people. Everyone who has ever contributed a significant enhancement to an open source project has made his environment unique for a while developing it. The average user doesn't have the time to do that level of tweaking. But it has already been demonstrated that with the right set of usability features, you can sell it to many average users. Desktop open source can simply be open source with the GUI tools that casual users want.
Impossible (Score:2)
What about a 'driving' interface? Driving a vehicle, be it a bike, or a car, or a ox-cart is a behavior learned by pretty much standard across all cultures. What kind of interface could we build that would confirm to the actions and behaviors learned whilst driving?
Compassion (Score:2)
Anyway, a compassionate user interface can be built, but it doesn't have much to do with the great pioneering work on Graphical User Interfaces that was done at Stanford Research Institute which was embellished by Xerox PARC and then commercialized in a degraded form by Apple. It has more to do with the way a teaching program figures out where the "student" is coming from, and then adapts its communications to the level at which the "student" is operating. As the "student" becomes more expert, the compassionate system, like a good teacher, raises the level of the conversation to the point that it challenges the "student" -- keeping the game interesting without being frustrating.
It's probably important to have some general sense of the user's frustration level as a primary metric in any compassionate user interface. Since people are fond of the word "annoy" these days, maybe there needs to be a global GUI attribute called "current_user_annoyance" which would be a primary contributor to a cost function in an adaptive algorithm for a compassionate user interface.
Re:Intuitive Means Windows (Score:2)
I've never seen a windows app that only allows one way to quit.
Alt-space-close, Atl-f4 are STANDARD on ALL windows applications. It is very rare to find any application that overrides these.
Then there's Alt-F-X which is extremely standard across almost all applications too.
And Alt-G-X is very rare, sure pinball has it, name another though.
Your ignorance (on purpose or not) makes me disregard everything you say.
Re:Intuitive Means Windows (Score:2)
The X(close) button on the top right of a window is also there 99.9% of the time.
I find it funny how so many unix people here actually complain that windows gives you so many ways to do things, so what? The average user only needs to know one (most use the close button on the top right), power users can use whatever suits their needs at the time.
Giving heaps of options (ones that don't clutter up the screen) is neither counterintuitive or stupid. I doesn't confuse any users, since it never shows up, and it's not 'hidden' as such since the most obvious ways to close a window are available.
Re:Easy Question (Score:2)
Esperandi
But its okay, put your blinders on, keep walking towards the cliff.
Re:Common misconception(s) (Score:2)
My point here was that in a situation where, to move something up, you can move a "handle" either down or up, moving the handle in the same direction will probably seem more "intuitive" to most people. In mechanical devices (think of a bow's rudder) often you see a direct linkage which helps you understand the relative movements. On-screen you don't have that sort of aid.
Also, of course, people can get used to anything - even to a command line :-). We're trying to find out how people who've never seen a particular widget before are likely to try to use it the first time. I agree there are many cases where there might not be any huge advantage one way or the other, but anything helps.
Re:Howto make better interfaces (Score:2)
Disclaimer: I am a Linux user. I like Linux. I have issues with Linux. Deal with it. Here goes.
Maybe this isn't obvious to me, but why is EaseOfUse != Powerful when it comes to software interfaces? I just don't see the problem here, except that people are too lazy or too time-pressured to develop a decent interface.
For my (only half-decent) example I'm going to use the software that was written for my scanner, a Umax 610P. I love my scanner interface. (Kudos to whoever wrote it if you are reading this.) The interface has two modes, easy and expert. This is a compromise, but one that works well in this case. The easy mode is basically two buttons, Preview and Scan, with a simple, easy interface that allows you to crop what is actually scanned. The Expert Mode is a well-laid out, very simple interface that presents all of the options that the scanner can handle. It is clear, simple, and obvious, even to people who don't know anything about imaging. The only problem is that this software isn't Open Source (AFAIK), which is the only thing lacking in an otherwise excellent piece of software.
The reason I like this software so much is that it takes care of two of the three levels of user, one of which I happen to belong to. The three levels are:
NovicePower-User
Professional/Developer
In this case, I fall into the Power-User category, someone who needs to use most of the features of the scanner but who doesn't have the time to program his own interface, etc. Now the deal with this is that EVERYONE , at one time or another, falls into all three categories. NO ONE can be a professional and developer on every piece of software they use. Therefore, one has to design most software with at least the Power-User in mind.
And that is the crux of the matter. I think that a lot of programmers hold the view that if someone is too lazy, doesn't have time, has no desire, or is too dumb to understand a complicated interface shouldn't be using their product in the first place. Now, before I get flamed, there is a place for this sentiment, and it is a valid view. But don't let it blind you to the benefits of making an easy-to-learn, powerful interface that more people can grasp. After all, we're trying to benefit everyone, that is the thrust behind Open Source. And if you develop for the Power-User, i.e. other developers who must use the product but don't have time to deal with learning the ins and outs of the product, they will bless you, and Linux can continue in its inexorable march to world domination
Linux is not widely accepted on the desktop because it is a PAIN IN THE ASS to learn. The help files suck, particularly for people who are just learning the interface. Microsoft's help files suck for the opposite reason -- they don't assist the knowledgeable user with difficult tasks. The Linux and Microsoft command lines makes perfect sense -- if you know the commands, which have to be memorized. Editing a text file is easy -- if you know the format and how to lay out the file. If you don't, you have to figure it out from the pathetic documentation. This is possible for a smart person (my first experience with Linux was setting up the XF86Config file, ooh fun), but is time-intensive and frustrating. Editing the Registry is just hopeless, due entirely to the crappy interface (can you say...weak?). The GNOME desktop interface is counter-intuitive to a Microsoft-trained user (which is most people), but on top of that it does things that make no logical sense. I have yet to figure out the Alt-Tab sequence of window-switching, as it appears to be random (Just switch 1-2-3-4 guys!). It probably makes sense from the viewpoint of the code, but it doesn't make sense to my eyes and hands, which is what matters when I'm using it.
You know, it seems to me that the rules of designing a good interface are simple:
1)Don't mess with what the user is doing. Microsoft is particularly bad about this (ever had your start bar disappear when another app refreshes the desktop?).
2)Keep things consistent and logical, at least within your program. If your program interfaces with the desktop (Explorer, KDE, GNOME) then stick to the conventions. You guys who write the conventions, make them make sense!
3)Don't hide functionality from your user. Everything should be simply laid out, in a logical format, accessible by both mouse and keyboard. Everything configurable in your software should be here, not in some random registry setting or text file -- that kind of editing should be reserved for software modification or emergencies.
4)Don't present everything to your user at once all smashed together (Exchange 5.5 config menus, anyone?). Logical design, dammit! You're a programmer -- if you don't understand logic, just give it up now. It isn't easy, I know, and programmers are naturally lazy -- so design the interface to be as fast and as easy as possible, which means paying attention to learnability, layout, and keyboard access.
5)Talk to your users -- all of them, from fellow developers to the Joe off the street. They may have crackpot ideas, they may have good ideas, but they are the reason you are there in the first place. Get out there and talk to them. One user's comments are waaaaaayyyy better than none, and the more you get, the better off you are.
Lack of useability is YOUR fault, not the user. Don't go down the Microsoft path of denying users power to make things easier. Fast, easy, and powerful IS possible in my opinion, you just have to work at it. Learn! And remember, you may be using someone else's software tomorrow, and you'll be wishing that they had spent the time to give you a good experience...
AetiusTextfiles vs GUI config (Score:2)
Why the heck does not more developers mix GUI and text?
*Store* everything in editable format (preferably XML style). Easily accessible for the admin. Throw a GUI shell over it. Make some labeled drop downs and checkboxen to explain the effect of the settings and to provide a non-expert way to fiddle with the file. Make damn sure that the connection between GUI and text is documented.
My favorite windows text editor (Kedit [kedit.com]) is a good example of how to mix GUI and text. Every setting, keypress and menu command has a command line equivalent. My hands seldom leave the keyboard, since it is much faster for me to do a command line "c/foo/bar/all *" then to fire up a searh and replace dialog and type "foo" in one edit space, "bar" in another and check the appropriate options (every line, every instance on each line). However, a newbie would certainly use the menu.
Hey, has anyone defined a DTD for .ini-files? After that it would be rather easy to make a generalized .ini-file GUI.
(or has that been done allready?)
Re:Intuitive Means Windows (Score:2)
>trashcan to eject it?
No, no, no, no... this can be easily explained.
When Apple designed MacOS, they thought of the desktop as a temporary repository for files and folders. In that vein, they created a "Put Away" command...
You can drag a file or folder to the desktop, work with it as long as you want, and then select "Put Away" (command-Y) It will go back where it started.
Now consider a floppy disk... a floppy disk is a physical item, so putting it away would be putting it back in the drawer, or the box, or whatever. If you select a floppy disk, and then choose "Put Away", it will eject the disk.
The Eject command also ejects the disk... *but* it retains the contents in RAM, "keeps it mounted", so to speak. This is because early Macs had one floppy drive, making copying from one disk to another a complicated procedure.
Anyway... point is, when harddrives appeared, no one remembered/knew the function of the Put Away (which always seemed unclear anyway...), and Apple added the trash can 'shortcut.' Now the problem is that the trash can represents "delete" in all cases *except* a disk.
But, hey, the rest of the GUI kicks ass, huh?
(BTW, Apple also changed the Eject function now to "Put Away" by default, unless you choose "Eject and Stay Behind.", the keyboard shortcut for which I forget at the moment. Contextual menus also solve this in a nifty, neat fashion.)
Feedback in not the only reason ! (Score:2)
I agree that's an important reason, but not the only reason.
IMHO, the problem comes from the facts that
very good programmers and experts in ergonomics are two very different jobs
creating an interface is more an artistic work than a programming work : here again, artists (designers, graphists, colorists) are more competent than pure programmers.
The non-open source firms pay experts in ergonomics and artists to make their products more attractive for the end-user. There's nothing like this in the open source circuit. Usually, the same guy works on the code, the interface, icons design, etc. The exceptions are rare.
Now, I don't see it as a flaw in the open source model : artists and experts in ergonomics can work together with the programmer and open source their work too. But for a mysterious reason, it just doesn't happen... Hey ! It's not too late !
Stéphane
??? (Score:2)
Also, what would you have it do if there are multiple partitions on the drive? And they are different filesystems? Symbolic links...I suppose then we must have a
If you want the behaviour of the OS syncing the disk before it is ejected, you must:
A: use a syncronous filesystem, sacrificing speed.
B: replace PC floppies with something like Mac floppies. PC floppy hardware can NOT do that, unless you want to do A (I don't).
Lastly, please explain how I can do the following using your symlink theory; I'm very interested:
mount -t nfs foo.umbc.edu:/usr/local
smbmount
Re:VA LINUX and REDHAT stock to fall (Score:2)
Both are in continued steep declines. This is the usual pattern after a speculative bubble. The real question is where they'll bottom out. Both are unprofitable, so none of the usual financial metrics apply. The theoretical bottom for a money-losing company is zero. Live by the hype, die by the hype.
The insiders can cash out after six months now. The restricted period used to be two years, so the company actually had to become a success for the insiders to profit. No longer. Watch the insider trading reports. [insidertrader.com] So far, nobody can sell, but wait.
Note: I have no holdings or short interests in either company.
A gross misunderstanding (Score:2)
Right.
This can't be resolved by making interfaces intuitive, any more than we can make graduate-level math accessible to children by using "intuitive" words and pictures to describe it. Eventually, we have to accept that part of what we want to do is educate the users a bit more, so they can figure out what they want to do; at this point, the interface can be designed for efficiency. Expert-friendly is the way to go.
Wrong.
This reflects a gross misunderstanding of what user interface design is all about. It's not about graphical user interfaces. It's about allowing low-risk exploration of the options with constructive feedback, so that the user will converge on something that works for them in a short time. Read Alan Cooper [cooper.com] for some insight. Or play a good video game, thinking about how you learn how to play it.
Until the open-source community gets this, Linux on the desktop is going to suck.
OSS User Feedback (Score:2)
VA LINUX and REDHAT stock to fall (Score:2)
all persons, living and dead, are purely coincidental. - Kurt Vonnegut
Defeating the purpose (Score:2)
I know that not everyone wants to learn how to use a system. Linux developers can go ahead and try to please those who don't really get into their systems, I don't mind.
My concern is this: do I still get the old interface? Think about it. It's already happened. I'm using X right now, and it's hell, but there's apps for it that I need to use, ones that would otherwise be developed for the CLI that I love.
---
script-fu: hash bang slash bin bash
Don't Bother (Score:2)
[buzzzz..] A: What does that mean?
B: That's a dial tone. It means you can punch in the phone number now.
[rwxr-xr-x] A: What does that mean?
B: Those are the permissions on that file. It means that the owner can read, write, and execute the file, but other users can only read and execute it.
The rest is left as an exercise to the reader. Intuitive is a bogus concept.
Re:Intuitive Means Windows (Score:2)
I long for the day I can sit in front of my computer and say:
"Computer, what do I have on the books for today?"
or,
"Computer, obtain and install all of the current patches and revisions for yourself. Give me a report when you are done."
or my favourite,
"Computer tell me why this scanner isn't working."
A good UI is the lack of it. When it comes to a user interface, less is definately more. Most users want to be able to use their computers without having to jump through hoops. They care not for complicated menus, or cluttered toolbars, jumbles of icons, and they certainly aren't literate enough for a command line.
The day the end-user can talk to his computer like he talks to his co-workers is the day that that the UI battle is won.
Something old, something new... (Score:3)
Second, we all know that UI programming can be a dreary task. This is where graphical UI designers (like Glade for Gnome or Constructor on MacOS) come into play. Using these tools the UI design is far less boring (or time-consuming for that matter). It's even almost fun. Once we have programmers not dreading UI programming, they'll put more effort into it.
Third, UI guidelines for apps. It would do a lot of developers good to study the Mac, BeOS, and NeXT guidelines. These people spent a lot of money coming up with their UI's, and each has some very good points. From these, a coherent set of Linux UI guidelines could be created. There will always be anti-usability zealots who insist "no one's gonna tell me how to design my program!" but the fact remains, UI designs are there for a reason.
Finally, the metaphor. The more I think about it, the more I think the desktop metaphor needs to go. It's not appropriate on Unix-esque filesystems, because of the almost maddening complexity. It's not even appropriate on Windoze. MacOS only gets away with it anymore because so few people go near the System Folder. Unix also has the additional problem that filesystems are a lot more "fixed" in nature than MacOS; it's a lot easier to break something just by moving it. So basically, what we need is a new metaphor, one which is more appropriate given the filesystem. I don't know what a good one would be, though I've heard some intriguing stuff about using a tree before. I'm not sure I like it, but it's an idea, and those are what we need.
One last thing. People talk about just "helping people to get over the learning curve." They talk about a learning curve being a "one-time event." The fact is, programmers have a responsibility to the users to make that learning curve as small as possible. And learning curves are not one-time events, not if every UI you come across is different. That's why there are UI guidelines; if most programs look and feel pretty similar (given their purposes), then a very large chunk of the learning curve becomes a one-time event. Think about it this way: because of the Mac UI guidelines, I can pick up the fundamentals of almost any Mac program immediately, without ever so much as glancing at a manual (at the absolute least I'll be able to quit the program without looking at a manpage, which is more than I can say for vi or emacs). In about ten minutes, I'll probably have the basics down. And if I want to learn more about the program, I still can; people have this idea that the Mac UI is somehow limiting because of its guidelines. But the guidelines aren't what makes it limiting. It's the people who make the software.
Re:Intuitive Means Windows (Score:3)
That is only true for existing Windows users. Granted, there's a lot of those. But there's also a lot of people who have not used a computer at all, or have been exposed to other interfaces in addition to Windows. For those people, a Win9x-like UI (especially the start button) is going to be very strange. IMHO, the older Win3/Mac/OS2/Amiga/ST/etc.. interface where you click on icons, is a lot easier to grasp than that hidden menu where you have to do the "start" thing, and then make a menu selection, before you can see what programs are available.
If you think the Windows UI is good for novices, I suspect the "novices" you interviewed were actually experienced Windows users.
---
Old News, already posted (Score:3)
--
Intuitive != Windows (Score:3)
This problem is endemic to the software industry. No one (or very few) are willing to spend the time and effort it takes to design a proper interface.
It's hard. I suck at it. Better to have an actual interface designer specialist design the interface, have the programmers write the back end, then stitch the two together.
What intuitive is (Score:3)
I'll give you a working definition of intuitive: A feature is intuitive if on the first try it behaves as the user expects it to behave. See? Nothing about genes, nothing about instincts, nothing about learning.
Dragging a sheet-of-paper icon to a waste basket to delete a document is intuitive for me and probably for 90% of the Western world. We know what is a sheet of paper and what is a waste basket. It doesn't matter if we learned this: we have this knowledge by the time we touch the computer. However, say, for our friendly tribesman Mumbo from New Guinea the same action would not be intuitive at all because it's likely he's never seen a wastebasket in his life and doesn't really know what it means.
In other words, intuition is in the eye of the beholder. An interface is intuitive if I can apply my already-acquired, previously-learned knowledge to the new domain.
And, by the way, user interface design is a big and very complicated field. Most Slashdot readers are no more qualified to comment on it than to judge the performance of a surgeon by watching an operation. Of course that never stopped anyone, me included...
Kaa
Re:Intuitive Means Windows (Score:3)
You mean like dragging a floppy disk to the trashcan to eject it?
A low cost solution to the user feedback problem. (Score:3)
Ugh. I think I speak for all of us. ;-)
As to the question of "how do we make the GUI more intuitive?": we just need to extend the Open Source model. "All bugs are shallow", right? Think of a user as being one of those "solitary" developers, and set up a way for them to feedback into the system. Perhaps Linus can require that all GUI code come with a mechanism -- say an HTML page that includes a mail form -- to give feedback to the developers of that GUI. Or if the developers are loath to embed their email address, perhaps a forwarding box could be set up somewhere *expressly* for the purpose of receiving and routing feedback. The mail form that comes with the GUI could come with a Subject line already set up (or with some hidden info that encodes what the subject is), so that once the message arrives at the forwarding box, it could easily be sent on to the proper people. Thus the feedback loop is closed and it's a win-win situation for both developers and users.
User Interface Research (Score:3)
A good, intuitive user interface is not only totally relative, it also depends on the past experiences of the user in general. I, for example, find a command line interface intuitive, but I've been using Unix for almost 10 years. My parents, who have been using PC's for a few years now, find the Windows95 model (start menu, folder icons for directories, etc) intuitive. Some former co-workers used Macs exclusively for a dozen years--guess what they liked best?
But everyone knows this already. This is not news. But does matter.
We can try to find the common themes here -- if there are, in fact, any common themes to be found when you compare bash to the Finder -- but that will probably not be very fruitful.
We need a huge focus group to discuss user interfaces. We need to get the opinions of people who live in different countries and who speak different languages. We need to get the opinions of people with backgrounds in multiple OSes. So why doesn't someone put together an open source "Research" project that attempts to do precisely this? A site like slashdot would be ideal -- it encourages interaction, posting your own comments and feedback is easy and convenient, and it is widely read.
How does this strike people? Is this a viable things to do? I know this is one of those areas, like documentation, where many open source developers and users are traditionally lax. This is unfortunate -- it is one of the more important aspects of any program, open or closed source.
darren
Cthulhu for President! [cthulhu.org]
Easy Question (Score:3)
The problem with this in the Linux realm is that when a grandma sits down and comes back the next day (you can NOT help them in any way shape or form if you're trying to determine how intuitive it is, else it becomes a test of how good they are at listening to you) and tells you she absolutely hates everything about Linux, the testers tend to slay the grandmother in cold blood for speaking out against the holy relic Linux.
This is not a troll, it is a call to reality. if you wish to continue to improve something you need to know when it is time to destroy what you have and start over. Yes, you love your window manager, but to improve it sometimes you have to destroy it and ignore everything you liked about it and just go down a new path. The guy that answered questions on here a week or so ago, the user interface expert, he had some really great ideas. And he hated Linux. So why not take his ideas, destroy everything of Linux that contradicts it, and see if maybe what comes out on the other end is better overall?
Thinking about his ideas, I think it really is a complete tear-down and re-build sort of project. Not even the filesystem can be spared. Journaling? Who gives a flip, in his new concept of using computers (I hate the word paradigm) journaling is stupid. So scrap it. Start over. Quit referring to file by filenames and extensions and a bitfield of permissions. Don't look at those things in a new way, get rid of the old way! Store files based on arbitrary category names, you have a bunch of song files, well, call them song files then. You boot up and you want to look for that song file you have that was made sometime in the 60s by the guy whose name started with B? The machine should not provide this kind of functionality in an application, this should *BE* the system. And no, you can't search by regular expressions, give it up. What about progams and such? Container categories (like song is a category) would cover this, holding the executable stuff. Well, what if someone on the Internet calls their files "music" files instead of "song" files? Easy, when you go to download one of em, it tells you the new file has a "music" flag on it. You can either add "music" as a recognizable trait for files in your system, or create a translation system for your system that will always read "music" as "song". Community standards will emerge, but if they don't it doesn't matter, maps will take care of it. No more systems programming. Everything will be going through this very high level system. You don't open a file, you try to open a class of files or a property within the same container as the program.
Hell, throw in some of Ted Nielsen's ideas which boil down to hyperlinking between portions of a document. Defining document portions shouldn't be that tough and it makes it all possible (I haven't read too deeply into his stuff, but from what I've read this seems as if it would have solved his problems).
For once in your life, I beg of you Open Source world, innovate! Let go of the archaic, obscure Unix past that sucked donkey balls for UI and do something new. You will never (and I mean never) compete for the home desktop unless you do so. If you eventually do, it will only be because you finally became as bloated as Windows. Everyone bitches because Windows ran on top of DOS... hello? X runs on top of Linux, wake up!
Esperandi
Seriously and honestly, this is not a troll, and Open Source developers need to read it.
Intuitive Means Windows (Score:4)
No, what "intutive" really means is "like Windows." Having worked with all 3 major platforms for quite some time now, I've found that what most people really want is a Start button and Explorer as their OS. Disgusting, no?
Obviously, you and I aren't most people. That's why we're reading Slashdot. But trying to get your grandmother to use anything but Windows, which she's used twice, is going to scare her.
So that's how we do it, that's how we make an intuitive GUI. Imitate Windows.
Gosh, that's an awful thing to have to say.
Been there, done that. (Score:4)
In a nutshell, the point of the debate was: Who is Linux targetted at? The developers of Linux are the users of Linux - the users of Linux become the developers of Linux. This is the way it has been before the IPO of AllThingsLinux.com
I have to ask, has the intention of Linux changed? Is it no longer software of the people, by the people and for the people? Has it become a supplier-consumer relationship?
If it's still the former, then the developers are the users and vice versa, and it's a stupid argument. If the latter is true, and the developers are the Morlocks to the users Eloi, then what Linux is all about is dead.
Linux WAS about solving real problems. Performance, technical issues, doing things 'right' without market pressure. If the focus must shift to 'end-users', and to providing 'unwashed masses' with a comfortable experience, then that goes contrary to the spirit of Linux - at least as I see it.
Let them eat cake, and run Windows and MacOS, I say! If they want to use Linux, they'll have to learn regular expressions.
In fact, out of the box is exactly where this end-user convenience should come from. Let the people making money on Linux distros add that value. They're the ones who depend on a growing user base. "Hey you, in the red hat! Are you listening?"
The core community is it's own user base and doesn't seem to care too much about auto-configuration wizards and user-friendly dumbification. If they did, those features would be there by now. See how it works?
Paradox of the Active User (Score:4)
"The "paradox of the active user" is a concept introduced by John M. Carroll and Mary Beth Rosson (then at IBM, now at Virginia Tech) to explain a common observation in several user studies done at the IBM User Interface Institute in the early 1980s (later confirmed by many other studies, including my own): Users never read manuals but start using the software immediately. They are motivated to get started and to get their immediate task done: they don't care about the system as such and don't want to spend time up front on getting established, set up, or going through learning packages.
The "paradox of the active user" [vt.edu] [PDF,66k] is a paradox because users would save time in the long term by taking some initial time to optimize the system and learn more about it. But that's not how people behave in the real world, so we cannot allow engineers to build products for an idealized rational user when real humans are irrational: we must design for the way users actually behave."
Source: http://www.useit.com/alertbox/ activeuserparadox.html [useit.com]
The paper is old, but still very relevant. It was written before Gooey [apple.com] Tarbabies [microsoft.com] achieved World Domination. I was really surprised to discover that many of my current user interface issues have actually been thoroughly documented and processes for (potentially) surmounting them outlined.
Why is it that since we've known about this for so long, so little apparent progress has been made?
My short 2bit answer is the evil upgrade treadmill - everybody is so busy preparing for and researching the Next Big Thing, they don't have time to refine and polish the tools already under our noses.
You can't make it "intuitive" if it isn't. (Score:4)
Frankly, a lot of the "desktop" market is people who would not be able to administer sendmail if it understood English, because they don't know *what they want it to do*. They just sort of want, you know, the thing where the other thing isn't done unless it's supposed'ta.
This can't be resolved by making interfaces intuitive, any more than we can make graduate-level math accessible to children by using "intuitive" words and pictures to describe it.
Eventually, we have to accept that part of what we want to do is educate the users a bit more, so they can figure out what they want to do; at this point, the interface can be designed for efficiency.
Expert-friendly is the way to go.
Completely missing the point... (Score:4)
To provide something new, we need to have a more direct link to what the users of a particular application want. This is something that the commercial houses can and do spend a lot of money on (Aqua, anyone) but in the OSS realm, so much effort is spent in just making the thing run, or better yet, play nice with others (not that there's anything wrong with that), that any UI improvements are an afterthough at best.
We are in a position to take the UI paradigm in any direction we want, but this opportunity is raerely being seized.
At least, that's what I got out of it. Anyone else?
Re:You can't make it "intuitive" if it isn't. (Score:4)
This is the mentality that allows many technical people to grin vaguely when Sun talks about replacing our desktop powerhouses with brainless terminals that place the power of public speech back in the hands of a rich few. It's also an understandable reaction of people fed up with trying to make their passions and motivations clear to lay people, the majority of whom are 5 or 10 years behind the people here. But ultimately your viewpoint is short sighted, because, in the very tradition of open source itself, you can never tell who will have the next brillian idea. There is no guarantee that it will be a techie, and frankly in certain fields of human endeavor such as painting and literature, it's a good bet that it won't be.
Humanity is on the verge of an explosion of creative thought and expression. We are the only people in the world who can make it happen. Please, I know you are an intelligent individual: don't turn your back on what is probably the greatest service your could render humanity in your lifetime: bringing the power of computers to average people.
-konstant
Yes! We are all individuals! I'm not!
Re:The author isn't grokking Open Source (Score:4)
I've seen this a lot around here, mistaking what is easy for the average technical /. reader for the average user. Linux is very well designed for its current user base. Its various UIs are far better than Windows for its current user base.
But what people really need to have hammered into them is that this is not at all the same as being well designed for the average person. For me, you and most other Linux users, being able to just edit the config file with vi instead of wading through a bunch of menus is a dream come true. For the average person, this is hell.
There is no one perfect UI. There are UIs that are good for techies and UIs that are good for nontechies. Don't expect them to be at all the same.
The "Open Source" model is probably the supreme way of getting feedback from the average technical user. This does not mean that it is at all good at getting feedback from the average nontechnical user.
Re:Common misconception(s) (Score:4)
Firstly, "intuitive" is a slippery word. There's "intuitive for power users", "intuitive for somewhat experienced users", and "intuitive for newbies". Some would say the last category is the empty set.
Metaphors are the key. Read John Lawler's 1987 lecture "Metaphors we compute by" [virtualschool.edu] for a quick intro on metaphor and metaphors in computing. The situation has unfortunately changed very little in the last 13 years. George Lakoff's book "Philosophy in the Flesh" [amazon.com] shows how metaphors actually are the basic working units of the mind, and that all basic metaphors are based on sensory-motor concepts - in fact, sensory-motor neurons very probably do double duty as metaphor processors.
So, as long as one bases GUI metaphors on basic sensory-motor stuff - things like "time is space-like" (progress bars), "nearer means on top" (overlapping windows), and so forth - you have some chance of being more newbie-intuitive. I've used a prototype ancient GUI where scrollbars worked the other way around; the thumb moved down to scroll up for some reason the designer considered compelling, and it was pure hell to use. Needless to say it didn't survive.
Now, something I've noticed in most (thankfully not all) replies here is a restricted understanding of what a GUI should do. Yes, having icons represent files is useful; installing by running a single program and marking off some options is useful; using menus is often useful. But that's only a small part.
I've released an application for the Mac OS recently. As long as one uses the standard system calls, one gets the expected GUI functionality for basic items - that is, menus work like a Mac user thinks they should, windows drag, roll up, close and whatever. But I spent very little time on that - thanks to a neat C++ framework called PowerPlant - and spent much time making sure other things worked as Mac users are used to.
For instance, placement of the exact hot spot in cursors is important. Shift-click selection of long sections of text is important. Exact timing and graphical progression of drag-and-drop is important. Wording, defaults and back-out options in dialog boxes, sound cues, selection behavior - the list is very long. And the extra time spent on subtleties was rewarded by a five-star review where the reviewer said "I love using this program, but it's often hard to say why unless I watch very closely".
When I'm using CAD software I'm often forced to use Windows NT, and frankly, it's terrible. People argument there are Microsoft UI guidelines, but it seems most people either don't know them or think they're unimportant. For instance, in the PCB layout program I'm using right now, if you select a library component to place on the layout, you select the component from a list - OK, the cursor changes to a translucent image of the component - also OK, but if you want to click on the scroll bar to place the component somewhere else, the component is placed _under_ the scroll bar with no visual indication that the scroll bars are inactive! If you click on a tool palette the component is placed under the palette! If people don't think this sort of flagrant misbehavior is important, are they likely to worry about more subtle things? No way...
So, what the original article says about "skins" being just skin deep is very accurate. Most Linux programmers seem naturally disdainful of graphic interfaces and therefore are slapdash in implementing one. And reaching consensus among a large group about any particular GUI feature is nearly impossible. This is definitely a field where the "absolute dictator" method is the only one which may work - granted it may also fail spectacularly.
That was never the point of open source (Score:4)
Is there a difference? You bet!
Windows 98 has to be written to the lowest common denomonator of user. Limit configurability and leave that to the programmers. It made it easy for anyone to walk up and use.
OSS (take GNOME, which I'm using now) is highly configrable. My bottom panel is probably guaranteed to not look like anyone else's, and if someone else walked up and used my machine, they'd be lost trying to figure it all out. Heck, people get messed up enough since I have "focus follows mouse" and "auto-raise" on.
Does this make OSS harder to use? There's a learning curve to figure out the interface, but not a whole lot. The concepts between Windows 98 and GNOME are similar, which were mostly developed 20 years ago.
Take another fun OSS example - Emacs. There's a steep learning curve, but those that get past it swear by it and use nothing else. It's probably a dismal failure when looked at in a general usability standpoint, but for each person that customized Emacs to work the way they do, it's a success.
Re:Intuitive != Windows (Score:4)
So intuitive, in fact, that that should read "you and me ."
Chinese is a wonderful language; the grammar is amazingly simple and easy to master. There are exactly three pronouns (four if you're reading instead of speaking) and there is no concept of tense at all. I studied it for three years in high school, and although I've forgotten most of the words, I can still remember most of the grammatical rules.
OK, so what does this have to do with designing UI's? The answer is that, IMO, UI's need to be more like Chinese. They need to be simple and have easy, unalterable rules that exist in ALL situations. Apple was very good at this. Microsoft never was. X interfaces are absolutely awful. Apps written in different toolkits, or in raw X all look different, there is no standardization of interface items, control keys, etc. The Apple Human Interface Guidelines (sorry, no URL handy) were revolutionary not only because they described how something should look (only one widget API) but also how it should feel. i.e., you can expect this widget to ALWAYS behave the same way. This is what makes MacOS intuitive, IMO, and what makes learning MacOS apps so easy. (except for Microsoft MacOS apps, since they've tried, and failed miserably, to simply put their abominable UI on the Mac desktop.)
So now that I'm done rambling, I'm not saying we should immitate MacOS - I'm saying that in order to be intuitive, there needs to be standards. The problem, of course, is that users of Open Source projects generally like to have choices. If I want to write a graphical app with Qt instead of gtk, I should be able to. If I want to use a set of nonsensical, inconsistent grammatical constructs like English instead of Chinese, I should be able to. The answer here, IMO, is that Unix OS's are not for the casual user. It was never intended that way, and I think we're kidding ourselves if we think we can make it useable for regular people.
Just my $0.04.
Haiku? God bless you! (Score:4)
Command line power
yet some prefer point-and-click
What's intuitive?
Is it just me .. (Score:5)
Intuitive != Learned (Score:5)
What has happened is that Windows has become part of peoples' learned expectations.
Much as with English, people have learned about its warts and aspects of non-intuitiveness, and have figured out how to work around them.
If something is truly intuitive, this means that there is no learning process required. The thing in question simply works the way people expect.
UNIX has the merit that it is a simple enough computer system that some people can get a sufficiently accurate model of its operation so that it becomes possible to predict what it will do.
In contrast, as soon as you strip the veneer of "learned things about its behaviour" off of Windows, it's a richly complex system whose behaviour is much more difficult to predict. (The lack of source code or other disclosures don't help either...)
The above approach to "intuiting" about Windows and UNIX take a rather different tack than the usual, assuming that the individual will actually try to deeply understand the system. It replaces the "black box" with one that is expected to be understood.
Rather unlike the usual model of trying to know nothing about what is going on behind the curtain...
Howto make better interfaces (Score:5)
People growl at the thought of having to edit a text file to make an adjustment or configuration. Geeks say "Awesome - text file" and whine to people to just learn how to do it.
Teching the masses is not the point and will never be the point. The masses will not learn and any software that is predicated on a painful interface will be opverthrown by software that is pretty and easy to use.
It's not what any of us wants to hear, that free software utterly fails to companies like Microsoft that spends millions of dollars on research with people who are not geeks, who are not programmers, who are not even proficient with computers.
Money is not the point. research, forethought, and feedback is the point. There is reason that Apple and Microsft have fixed UI models. They recognized that the biggest weakness of most programmers is intuitive UI design.
Programmers and geeks as a whole are extremely intuitive people, and that intuition allows us to make tremendous leaps of the non-obvious. Most users are not capable of these tremendous leaps and fail to understand. These users are not stupid or even lacking in intuition. One component of intuition is past experience, and if they have not spent a long time around computers then they do not have the necessary reference material.
There are UI guides out there, and there have been some efforts by the GUI people to get coders to follow them, but we all know that they are herding cats because we won't follow anything that somebody else is going to impose. <sarcasm> I don't need those frigging kernel patches that king linus and prince alan keep trying to shove down my throat.
To get back on subject. If we really want to take over the universe (duh) we are going to have to figure out how to make software that is easy to use, friendly, and intuitive to -non-computer users. There is no compromise.
Thank you Redhat, Corel, and all of other distributors that have gone to great lengths to make is easier to install Linux. I mean there are tools around now so that I don't have to manually program my monitors frequencies into XF86config!
enjoy,
chris
It's a stupid title, stupid (Score:5)
Am I the only one tired by titles of 'It's [whatever], stupid'? This always sounds to me like a somewhat veiled attempt from the author at placing themselves above the reader from the get-go, by claiming they have such a clever bit of information that the reader should feel 'stupid' for not knowing it.
More on topic, I have to say there probably isn't such a thing as an intuitive control. If you think, for instance, that a mouse is an intuitive device, you should see 80 year-olds who never touched a computer before try to figure them out.
Rather than considering so-called 'intuitive' controls, the goal should be to develop methods which are built upon existing and well-known ones. Ultimately, nothing is intuitive in controlling a computer (unless we developped Herbert's genetic memory in the last 50 years), but rather part of a slow learning process.
So don't shoot for intuitive; shoot for ease of learning. Mounting and umounting a drive, for instance, isn't intuitive to a Windows user. But it's easy to learn, and once you catch the principle, it's acquired.
Is that more on topic?
Re:Intuitive Means Windows (Score:5)
> Windows."
In my experiance I have to disagree. The real
topic here is "Learning curve". There is no
such thing as "intuitive".
I have seen complete newbies sat down in front
of "Windows" and be completely lost. They had no
idea what the hell was going on. Its not that
windows is "Intuitive" it just has a shallow
learning curve.
In truth...Unix can have a fairly shallow learning
curve for the non-admin. If your job is not admin
of a system, you can be sat in front of a terminal
and shown how to do the few things you may need
to do (reading/sending mail etc) and learn in
a few mins to an hour or two.
There are two problems I see.
1. Windows exposure
Just as they say "LEarning a second language is
harder than the first one". Just as a newbie
leaning french will try to drawn on english to
incorrectly fill in the gaps in his mind, a
new linux user sits down and expects to be treated
to Windows. It is not the same...it is wrong to
expect it to act and respond the same.
2. Admin ability
To install linux and get it up to a state where
it can be most effective, and work well, you need
to be an admin. You need skills that take a good
6 months of real use to even begin to get good
at.
A new user is not a qualified admin. I know I
only got where I am today by shooting myself in
the foot a few times (first under windows, then
under linux).
What is really needed are tools that lower the
learning curve. Things that are easy to learn...
easy for a newbie to get setup in short time...and
do not hide their internals such that they can't
advance beyond the high level tools.
This has been the major falling of windows, and
for me, redhat. The gui tools are either the ONLY
way, with all the limitations built in like solid
brick walls (windows), or hide the internals and
eventually stunt advancement (redhat - albeit this
is from a few years ago..it may not be a fair
assessment today).
As for innovation (from the article). I have seen
even experianced users sitting dumfounded in
front of some of these "innovated" user interfaces
So what if we "copy". Ya see an idea that works..
ya use it. Ya see ideas that don't work...ya
don't use them. I am all in favor of assmililation
of good ideas.
I don't know about most people...but I like a
good stable system that works. I have that in
linux. Am I interested in making linux "Easy for
the newbie" - yea marginally. However...my main
goal is getting my job done. I imagine that that
is the motivation behind most of the "Opensource"
advances. Its either to have fun...or get the
job done.
"Market Share" be dammned. I don't even care.
Why do we need to "Compete" with microsoft
or anyone...can't we just do our thing? If it
wins out and "dominates the market" well um like
hey cool...i'll party to that. If not...well hey
it works for me...ill party to that too.
In nay case...I would like to see an OS built on
the linux kernel that could soften the Unix
learning curve down to something like windows.
I wouldn't use it (don't need it) but I would be
happy to point newbies at it.
I guess what my point is, is that criticizing the
"Opensource" movement for "Not making easy and
innovative interfaces for neewbies" is like
criticizing the government of France for not
providing free health care to people of Zimbabwe.
For me, the goal of "open Source" (Or Free
Software to use the prefered term) is to share
code for universal benefit. Faster development
cycles and "extra eyes" are side benefits at
best (though, great benefits they are).
Common misconception (Score:5)
Most people use only 3-5 of the icons on their Windows desktop, without ever delving into any of the menus. AOL, Word, Internet Explorer is all they know.
For most people, it's all they need to know.
So when we talk of usability of Linux GUIs, there is nothing "hard" about starting Linux programs from the GUI. What gives average users trouble is installing the actual program.
For Windows most installers automatically put the icons on the desktop and the user never has to worry about fiddling with any settings.
There is an immense number of technical things going on with the installation of a Windows program, but the user never ever sees it. DLLs are copied,
The same should also work for installing Linux programs. Install scripts which hide the ugly technical stuff from the user, place an icon on the desktop, and thats all.
Instead of a "better" GUI, Linux needs a better install procedere which lets the user click and go.
Open Source Interface Guidelines (Score:5)