Forgot your password?
typodupeerror
News

Open Source's Achilles Heel 476

Posted by CmdrTaco
from the stuff-to-read dept.
Tony Shepps writes "From sendmail.net comes an essay by UI consultant Mike Kuniavsky, "It's the User, Stupid", on what might be Open Source's worst failing: User Interfaces. In short, Open Source is geeks writing software for geeks, and usability suffers... and maybe that's an inherent problem with the model. "
This discussion has been archived. No new comments can be posted.

Open Source's Achilles Heel

Comments Filter:
  • by Fastolfe (1470) on Friday January 28, 2000 @10:10AM (#1327810)
    This is an idea I've been toying around with.. Most applications have a consistent set of elements and forms. What if we built a markup language out of this, with controls and forms rendered based on a style sheet instead of hard-coded pixel values defined in the GUI form itself? Each widget could be assigned a tag and could be referenced and manipulated by the application, with the results being rendered by the UI "renderer."

    How much of this is already done using HTML and XML? Doesn't Mozilla already use an XML derivative to define its own internal dialog boxes? How difficult would it be to pull *all* formatting and location information out of these things and use style sheets to render it all?

    This would allow us to do things like run "X" apps via telnet, using a textual transformation/style sheet, rendering controls using nice ASCII characters.

    It would also let us *completely* re-do the formatting present in any application's window in a consistent manner. Move all menus to the top, all operation buttons to the bottom right, etc. Applications could come bundled with their own sets of style sheets, with broader positioning and styling done by system-wide style sheets, all the while giving the end user the option to move and resize controls to their taste. Everything could be themable, and I'm not talking just pixmaps for buttons.

    How feasible would this be to do?
  • Want to delete 5 lines? Type 5dd.

    No, that actually deletes 10 lines. :-)

    There was a good manual on technical writing (which I have since lost) that pointed out when you have to bend the grammar rules to avoid this sort of thing. Their example was 'To delete a line in command mode, type dd.' dd will delete the line, but dd. will delete two lines! Quotes are also supposed to include a trailing period. But in the case of literal commands, quotes are just to include the command and ignore all other grammatical rules.

  • throwing the child away with the water

    I belive the expression is 'throwing the baby out with the bathwater', but I imagine there are countless regional variations.

    Your friendly neighbourhood pedant.

  • First, the people who work on UI's in the UNIX world have gone through an intellectual and philosophical sea-change over the past few years. I remember back in 1995 or so, I used to fight on comp.os.linux.advocacy for UNIX/Linux developers to recognize the need for tools with which DOS/Windows users would feel familiar. In the beginning, there was a lot of resistance. Now, we have tools like the editor in the Midnight Commander, which can do CUA quite well. Then, there's xwpe, which has a really Borland-like feel to it. The GNOME and KDE desktop technology is getting very easy for "average" users to handle.

    What bothers me about articles like this is that they tend to perpetuate the stereotypes. The other thing that bothers me is that the very idea has the feel of "we need to find yet another weakness in what these people are doing."

    The February Linux Journal has a GNOME article in which the author mentions a UI team. I've been expecting that to happen at some point. Open Source projects with UI teams--maybe even usability teams---what kind of Achilles' Heel is that?
  • by Anonymous Coward on Friday January 28, 2000 @09:38AM (#1327818)

    Can someone think of an example Open Source project where the developers are not users?

    I think the more appropriate question is can anyone name an open source project where it's users are only it's developers. Obviously the developers of a program in the Open Source community are going to be users, that's only natural, but if all they care about is limiting the usefulness of the program to themselves and not creating a program that can be used by 98% of the population, then the article isn't focused on them.

    The problem that lies in most of the comments is people are getting stuck on the GUI only, which is one aspect of of the entire User Interface. As I'm sure everyone will agree, there are some absolutely gorgeous GUIs availabe for Linux and on the flip side, there are some absolutely horrendous ones. One of the problems that the Linux community will see as Linux becomes more popular with "regular" users is that there is no consistency between the different GUIs.

    However, the article discusses UIs in general and (from recollection) doesn't even mention GUIs. The user interface of a program is more than the GUI, as I stated, it's about what information do you present to the user, how is that information organized, etc.

    As an example, consider the normal installation of Apache and Sendmail for configuring. Neither have a user friendly interface to configure them, sure they're available, but you have to seek them out. For experienced programmers and users working with the configuration files is fine, get in there, make the settings, save and restart. However, when someone from the 98% of the population who doesn't have experience tries to do that it almost always ends in frustration.

    And the README files for most programs only add to that frustration for a new user because they are slanted towards those who know what they're doing and understand the slang. This is the perfect example of creating an "in-crowd" in the Linux community. If you're experienced and you know what you're doing, you're a welcome guest to the Linux community, but lord help those new users who try to ask a simple question because they'll be tossed out of the community amid cries of "RTFM." Yeah, thanks for being helpful. It certainly doesn't help when RFM is wrong, as in a case I ran up against with an O'Reilly book and one of the examples in it...check the online errata? Oh, wasn't mentioned in there, even e-mail the publisher and the author and still didn't see the correction show up.

    The fact is that the developers want to write a program that does what they want and making an easy to use interface for beginners or those less experienced then they is last on the list.

    Good, bad? I won't vote either way, it's just the way it is...right now.

  • by Skinka (15767) on Friday January 28, 2000 @09:39AM (#1327824)
    I see a lot posts saying that the writer has gotten this and this point wrong etc. Seems to me that a lot of people just are not willing to admit the truth. It's easier to say the writer is wrong somewhere and then disregard the whole essay. I understand that a developer will easily get defensive if someone says the programs he has been making the last five years have bad UIs. But denying the problem is NOT the right thing to do. Instead you should try to listen to the persons complaining, even if you don't fully (or at all) agree with them.

    If we pretend that it isn't broken, no one will fix it.

  • Hi All,

    Let's see the evolution of UI...

    1) Plug some wire in some holes
    2) Punch holes into little paper card
    3) Use a terminal to punch holes in little paper cards
    4) Use terminal to type command and see response
    5) Use a device to move a pointer on a ugly graphical screen
    6) Use a device to move a pointer on an ugly complex grapical screen
    7) Use a device to move an animated pointer on a good-looking complex graphical screen
    8) use a device to move an [animated] pointer on a good-looking simple graphical or text screen.

    Guest what #8 is... Hyper Text Markup language... Who build that thing? No it's not a commercial entity but a buch of people who wanted to empower the user with an easy to use interface.

    Guest who is going to make that kind of interface as THE user interface in the next consumer version of their OS... MICROSOFT...

    Most of geek have no clues for UI design... But a handfull of geek did have great clues about UI. With theire great infrastructure skills they develpped a new kind of UI that is powerfull yes simple. They made the Internet a usefull tool for the average (and less than average) user. Now everyone is building on the geek UI.

  • This article would have been true when I first came to Linux but since then KDE and Gnome have come a long way towards providing good consistent GUI interfaces.

    KDE has a GUI which is not that different to that provided to a Win'9x user and should not be that intimidating as such. In KDE [which I use more than GNOME] it can be said that KDE apps much more consistent in terms of style application and operation than almost any other GUI, including Windows. KDE is _perhaps_ less innovative than Gnome in terms of presentation, but this is in many ways an advantage - users who prefer more exciting interfaces can go for Gnome whilst users who prefer consistency [and stability ;-) ] can go for KDE.

    Open interfaces can be quite radical in the sense that arguments can be put forward for changes in direction when it is obvious that things don't work as they are; whilst in Windows older bad designs are often supported, sometimes to the detriment of newer ideas.

  • Yeah, often tech writers don't understand the significance of what they're saying. Writing "click the mouse button" is not good enough any more. WHICH mouse button?

    A good writer can help a good interface better or really, really bad. Maybe what the open-source user interfaces need are better tech writers :-)
  • The command line interface might be simplest as far as implementation and looks, however, most people cannot think at this abstract level (or at least, they never learned it, the newer generation, who has grown up with computers, might have an easier time at it). The "innovative, flashy looks" might be excessive, but at least the GUI provides you with a symbolic interface, something above the abstract level, a visual representation. The average computer illiterate guy can't memorize a bunch of - switches. He wants to see his files represented as a picture of paper, file name underneath, with a visible "directory tree", and if he wants to delete a file, he wants to be able to "drag" the file to the "trash/recycle bin".

    This begins to become a moot point however (as others have pointed out here) with all the advances in gnome/KDE. They're almost ready for prime time. Nice look for the average user, without the commercialized "bells and whistles" feel.
  • It's funny that you cite Gnome, KDE, Mozilla, and GIMP as indicators of a brighter future for Open Source UIs. The fact is, each and every one of these programs suffers from the same mistakes as Windows:
    • Menubars are not placed at the top of the screen, making them harder to hit (remember, a menubar in the middle of the screen has finite dimensions, whereas a menubar at the top of the screen has infinite depth).
    • The taskbar on the bottom of the screen has buttons that do not extend all the way to the edge of the screen, again denying them of a potential infinite depth and making them harder to hit.
    • In many window managers, nondestructive buttons such as Maximize are placed right next to destructive buttons such as Close, increasing the chances that the user will accidentally destroy a window.
    • To proceed from a menu to a submenu, it is necessary to manuever the mouse rightward with surgical precision through a single menu line in order to get to the submenu without accidentally tripping an adjacent menu item. Compare this design with the classic Macintosh menus, which provide a triangular "forgiveness zone" to make it easy to get to the submenu without closing it before you get there.
    I could go on but I think you get the idea. The point, which was well made in the original article, is that programmers are not typical end-users and these kinds of user interface issues do not even occur to them.

    I hate the classic MacOS because it lacks memory protection and real multitasking, but of all the user interfaces in existence, classic MacOS stands out as the one UI that gets things right.

  • So, what your saying is Open Source can make good UI's so long as they have something to copy from?

    How about some examples of where Open Source is leading the field with it's GUI?
  • What is needed here is a good open source UI initiative, bringing together the Academics who are knowedgeable in UI Design in our community and the developers in our community who are working on GUI Design, to start generating a logical, innovative, and consistent design to be implemented throughout GUI software under linux. Sort of a GUI Standards Association to set guidelines on development that would define a consistent interface and methodology of use. Conforming to it would have to be completely voluntary of course, but it might be of great use to future developers to have a body of code already built to perform all of the basic functions that they can draw upon when developing a new program.

    Obviously, this will not impact the currently developed non-GUI programs which are already using their own command systems - I am sure if anyone were to suggest monkeying with the commands which control Emacs or VI there would be riots in the streets and public hangings - religous people can often be quite fanatical about change :)

    Reaching a consensus on GUI design would no doubt prove to be a challenging task - but I am sure we have folks in the community who are both knowledgeable concerning UI design, and capable of approaching the task from a fresh perspective. A lot of research has already been done on this in the Academic world - all we need are folks to actively interpret that work into something comprehensible by developers. :)

    Just my 2 cents worth.

  • Yeah, I agree they still have a long way to go before they get to be completely brilliant interfaces. The point is, they are getting better. And they're getting better because they are open source, not in spite of it.
  • While I can't refute your argument that Windows copied the interface from other things, to me it really doesn't matter whether it was copied or not. What matters is that it IS consistent. Yes, maybe you didn't know that Alt-F4 was the close statement. To me that just says that you never used the little icon in the upper left because every time you click on it it pops down the little box that says "Close Alt+F4" To close a document is usually Ctrl-F4. While I agree that it may not be the most obvious of choices. (Why not Alt-Q or Alt-C or something like that) It IS standard. And that's what I care about. When I want to close a window I don't have to search around or lift my hands off the keyboard, I just hit Alt-F4. I would have to say the same thing for Cut/Copy/Paste. It's a fair standard to have Ctrl-X, Ctrl-C, and Ctrl-V for those functions. Some versions of DOS editors use like Shift-Insert, but that is probably just legacy.
    So while you're argument that it was copied is probably correct, it really doesn't matter. Isn't that the whole point in creating things? To take good ideas from something and improve upon it. I don't credit Windows with creating everything, I will credit them with putting it together fairly well. I have limited use with Linux, although I would much rather see it succeed because I agree with the principles behind it. If I could get everything I can in Windows under Linux, I would probably switch. Unfortunately, we've got a lot of tools that we use that are only for Windows, and we need them to get by.
    Sorry about the rant
  • It's a chicken and egg problem. Text mode interfaces are very user friendly... if you know how to use them. How do you find out what how do look for things in files? How do you even know that "grep" is the tool that does the job, much less how to use it? Well, you use the man pages. How do you find out more about the man pages? Type "$ man man" of course... :-)

    I think vi has a great interface. Want to delete 5 lines? Type 5dd. No menu to find, and very efficient and intuitive, but only if you already know how vi works.

    The point of a good user interface in the "usual" sense is to reduce the learning curve for new users while providing fast, powerful functionality.

  • t this point I think arguments along the lines of "well, Linux/Open Source loses because they have really geeky UI's" is more FUD than accurate. It will become even less accurate over a somewhat short time scale! One metric to testing this assertion it to see how many "normal" admin UNIX tasks (sysadmin or user adminstrative tasks) are being pushed over to programs with UI's than are done on the shell.

    I think the point of the article was that good UI doesn't necessarily equate to having a GUI interface. It's more on how programs have a shared consistent interface. For example, the shortcut to quit in Gnome programs is ctrl-q, in netscape and some others its atl-q, xemacs and emacs set it to ctrl-x-ctrl-c. If I want to quit a program, I don't really want to have to stop a second and figure out what the shortcut is, or end up pressing two or three shortcuts in other to quit. The MacOS and WinXX systems are a lot better in this regard since certain common functions are mapped to the same shortcut in all programs. If I want to quit a program while using those oses I can just hit alt-f4 or apple-q and know that it'll work.

  • It doesn't bother me the Linux is small fries. It can stay that way. BSD can stay that way. It's not going to stop people (geeks) from developing on these platforms. The cool apps/tools will not stop coming through. Depending on what you mean with cool, they could stop coming through !

    My favorite example are games. We think all is well with Linux and games because Loki etc are now porting commercial quality. But the actual development of such quality games under Linux requires that the non-programmers of a software team migrate to linux as well : to edit the video, the story, the dialogue, the puzzles, whatnot. And that will require tools that are easy to use by those non-code guys.. and trust me, artists and editors can be really stupid.

    So there you have a concrete example : if you want companies to build games, their editors will need content editors of ultra easy to use interface. That's an example of cool apps that haven't even started to come through.

    So can you really be happy to keep Linux in the niche, avoid it's commercialization, and at the same time cry out for cooler games and cooler multimedia native to Linux ?...

    Not to mention that a boom of Linux to the desktop would probably a great incentive for OEMs to add support for their scanners, point devices (tablets, ..), printers, modems and whatnot to Linux.

  • I'm not sure if an XML grammar for GUIs will solve the problems listed in the article. Absent user feedback or real standards, there will always be a temptation for programmers to be lazy and take the easy way out when creating graphical UIs.

    However, I firmly believe that an XML grammar for GUI definition is right around the corner. It's just one of those ideas that makes sense.

    Consider, for example, a MSVC++ project. When you create a form and start dropping widgets on it, the IDE builds a .rc file that contains the description of the form.

    If you open a .rc file, it's just ASCII text. The format is human-readable. It could have just as easily been done in XML -- it's just that XML wasn't on the map when Microsoft designed it.

    My uninformed hunch is that we will eventually see "GUIML" libraries which translate markup into native widgets. The concept is similar to Java VMs, but much easier to implement. It should allow GUI apps written in "compiled to native" languages to have a lot more portability than they do right now.
  • > Menubars are not placed at the top of the screen,

    Git the gun martha, it's another MacHead. Right. They're associated with the application they control. The interface is not modal. I'd really love to see the visual chaos that would result from focus-follows-mouse policies.

    > The taskbar on the bottom of the screen has buttons that do not extend all the way to the edge of the screen

    This is one of many reasons I despise the gnome panel and the new KDE one. Not only do they not extend to the bottom, they're now crammed into a grid you have to aim the mouse at. The others being that it's too damn big, and applications still maximize to cover it.

    > In many window managers, nondestructive buttons such as Maximize are placed right next to destructive buttons such as Close

    No argument there, though when using a Mac, I often wished for a maximize button of some sort. Minimize was easy enough (Hide) but it was a mouse operation or a chaotic-looking "unhide all" command to get it back.


    > To proceed from a menu to a submenu, it is necessary to manuever the mouse rightward with surgical precision ...

    Motif displays this annoying behavior of having zero delay before activating a submenu. Gtk+, Qt, and Win32 do not. In Windows, the delay is even configurable, using any number of "tweaker" control panels. As an indictment of Windows, as this was meant to be, it doesn't hold up.

    Classic MacOS did many things right, but it wasn't without its awful warts too. A proliferation of popups that were modal. A chooser interface with a little bitty non-resizeable window for services. Dragging disks to the trash to eject them. Having only one corner to resize windows, often forcing you to move the window around to expose the drag handle first. Mysterious behavior when clicking a label of an icon, causing you to edit it instead of treat it as a normal click (bogus behavior nearly every interface since has slavishly emulated).
  • Warning: the following is an angry rant.

    Everybody keeps wondering why Linux isn't taking over the desktop (and never will). I've been saying forever that since non-programmers don't have a say, it won't ever be useful to them. Geeze, you don't have to be to bright to figure out that most open source projects (that people would love to think would work for the average joe, like Linux) are nearly IMPOSSIBLE for most users to catch on to. Pointing out exceptions just proves the rule. There's no signs of this changing.

    Go ahead Linux freaks, moderate me down.
  • Hmm. Very strong point, but I don't quite agree with it.

    My main gripe is with the implementation idea. You're defining an entirely new language! Why not just stick with HTML?

    Although, as one who is migrating reporting from Access to HTML with a self-maintained Web displayer (doesn't handle any network stuff, but displays HTML properly (tables and all that fun stuff)) I'd say screw it all and just go with a common DLL that you can link.

    It'd be a lot easier to update that way as well.

    Enjoy the show!

    Jezzball
    ls: .sig: File not found.
  • I see several posts arguing that no graphical user interface is needed. While true in most cases, consider the difference in terms of RP Games. I'm sure there are those who'd argue that Zork is still the king of all games (and Fortran is the game-writing language of choice), but most of us would rather play Hack than Zork.

    And what about the graphic tiles introduced for Hack. Now you don't have to know that a brown "d" is a jackal on level 3.

    Bring on Quake, and it's a whole new game. They're all essentially the same, but the difference between a real-time graphical view out the eyes of the character is so much better than "You are in a maze of twisty little passages. #>"
  • Why not just stick with HTML?

    Good point. Actually I would use XHTML or XML instead. This may might be applicable, but I only downloaded the full specs on XML a few days ago and have yet to read them.

    I'd say screw it all and just go with a common DLL that you can link.

    DLL? do you mean shared object. This isn't a Windows machine. Like I stated in my post, I don't want to guess what the utility is doing, and I don't want to look through source code to figure it out. A simple standard config file would work. If you add a new utility and need to add configurations to it. Just place you configurations into the /etc/config.d directory, during "make install", with the considered file format (XML if you wish) and the given utility (GNU Control Panel?) would then list that configuration format.

    I recommend different files in a single directory since you don't want a bad install to destroy current files (Windows Registry anyone!).

    The format XML or what ever, needs to be able to run commands as well. So the user would need to su to root to run their browser or other application that would read these files. Since the files are ASCII, the likelyhood of a virus would be minimal.

    Steven Rostedt
  • Most of our interfaces do suck to some degree, let's not deny that. To deny it would mean denying the need to keep making them better. The fact that our interfaces tend to suck much less than a lot of the competition, well, hehe, that's no reason at all to stop working on it.

    He's bang on the money about the user feedback loop - it's crucially important. But he's wrong to say The Open Source movement has no feedback loop to end-users. What's this [uibk.ac.at]? We need more stuff like this, better stuff like this. The only thing is, I'm not sure the devlopers in question are using this excellent facility to the extent it should be - there are many out-of-date user comments on there, mainly because the wanted features have already been added. In time, if the list isn't kept current users will stop posting to it, in the mistaken belief that it isn't doing any good. But that's just another glitch to work out.

    The thing is, making good interfaces is just another interesting problem for geeks to solve. Define the problem, and we'll solve it. First we'll start with poor solutions, then we'll keep making improving them until they're good solutions, then make them better and better until... well, it never stops. The only hard part of this is recognizing the need. Achille's heel? Far from it, it's just another hill to climb.

    The fact is that it's much harder to make good end-user software than it is to make good infrastructure software - and that's going to make it tough for Open Source software to break out of its server niche.

    No, that's just wrong. Speaking as someone who does both, has been doing both for 25 years, and doing it well IMNSHO, I can say with considerable confidence that creating good infrastructure is much harder than creating good user interfaces, and the stakes are much higher. Without good infrastructure you get a monstrosity like Windows (pick your flavor) or Dos - something pathetically non-functional. Glitzy user interfaces are the hare, and good infrastructure is the tortoise - it takes a lot longer to do the job if you build sturdy infrastructure first, but you can then build your stucture much higher without having it collapse (apologies for the mixed metaphor). In the end, the tortoise wins. Is winning.
  • I think most of the people who are responding to this with observations about GNOME/KDE and X are missing the point. Not once in the article does the author talk about GUIs as such; he talks about user interfaces. Even a command line is a user interface, and some command line interfaces are better than others (or why would people have such strong preferences about, e.g. the shells that they use).
    Nor is it a Microsoft vs. Open Source/Linux thing either; many people who take User Interface design and research seriously think that MS products have huge UI design problems. Dialog boxes that say (in effect) "I've just made a huge unrecoverable internal error, click OK to complete your humiliation. OK?" are rampant in the MS Windows world, and are an abomination from the point of view of UI design. (So, for that matter are the "Click OK to indicate that you really meant to click OK" boxes.) I suggest instead of accusing him of not being clued in on how cool GNOME and KDE are, or saying "GUI? We don't need no steenkin' GUI!", people might try reading Alan Cooper's About Face: The Essentials of User Interface Design to see where he's coming from.
  • I think the author is right in principle, though I don't always agree with his wording. He talks of innovative user interfaces, which is exactly the wrong way to go. What we need are clean user interfaces, and that's exactly the antithesis of UNIX. In text mode, the user experience is a mess even for people who know what they're going. Type "ls --help" and look at the bazillion screwy options for doing something as simple as getting a directory listing. Then look at the man page and you get a message reading "This documentation is no longer being maintained and may be inaccurate or incomplete," right up at the top. "This does not bode well," thinks the newbie.

    X-windows application GUI's are in much worse shape. The much ballyhooed GIMP is a great example. It's filled with all the usual fluff--tips of the day, all sorts of configuration options, toolbars everywhere--but just about every panel you bring up is so brimming with things to tweak that you don't know where to begin. It's a pile of stuff all thrown together with a GUI on top, but that doesn't mean it was well thought out.

    What is desperately needed is a good example from someone who knows what's important and what's not; someone who isn't just trying to show Microsoft a thing or two by duplicating a Windows style interface in his basement coding lair. I've read some very interesting UI design papers over the years. Jef Raskin has much to say. There's also an excellent book from someone who used to be in charge of such things at Microsoft and left when he didn't like the direction they insisted on taking. The key to remember is that the purpose of an application is not to shuffle windows and menus and toolbars; it's to actually get a particular job done.
  • It's not about "skins". Read "The Inmates are Running the Asylum" [amazon.com]. This is by the guy who wrote Visual Basic, so he does know how to program, but in disgust, he's given up programming to work on user interaction design. This is an important book for programmers.

    UNIX has an awful interface. Denying there's a problem doesn't help. Being macho about it doesn't help. Bolting some kind of GUI on the front of a collection of command line programs doesn't help. X-Windows doesn't help. Skins don't help. Needing to open a shell window to do anything doesn't help.

    User interaction design is hard. Even starting from scratch may not help. Java, for example, blew it.

    There are some good examples: The early Macintosh user interface guidelines. Microsoft Word. Nokia cell phones. But not many.

    Today's hint: The user should never have to tell the machine something it already knows.

  • IMO the summary hits it dead on. OpenSource authors are coders.

    There are those of us that can design fantastic user interfaces and come up with nifty ideas, but it's very difficult for them to just enter an OSS project and re-design their interface. Despite the fact that the original interface is crap, many OSS developers like it (which brings us back to the whole "coders have no UI taste" argument) and in some cases are openly hostile to anyone that wants to change it.

    Someone else mentioned that functionality and efficiency is stressed more with OSS software, and what might appear like a UI failing might just be the author trying to stress functionality over "extraneous" cruft. Unfortunately, in many cases, certain usability factors seem either unnecessary to him, or "not worth it" to code, so we end up with applications that are pretty nicely featured, but lack good thoughtful usable interface design.

    I think the main hinderance that prevents UI designers from contributing to OSS projects is that the designer needs to be a good coder. It's difficult for a UI person to step into a project and simply re-design the interface. They have to be able to go into the code and make adjustments at the code-level.

    Naturally, people that are experienced both in coding and interface, usability and graphics are few and far between. That's not to say that they don't exist, but typically they're quite happily employed because most companies know combinations like this are hard to find too.

    "Theming" your application is a nice way to try and abstract the interface from the application. Unfortunately, unless you spend a considerable amount of coding building themes into your application, this just doesn't go far enough. Sure, you can make, say, GTK themes, but that doesn't help you re-design an application's window form.

    What is the present state of "graphical" application builders? I know in your various "Visual" Windows IDE's you can create windows and forms and entire user-interfaces graphically, without necessarily needing to know much about the coding.

    How easy is it for usability and interface people to contribute to your OSS project?
  • I am planning a Microsoft Bob-style interface for the X windowing system. So far I have the following in place: An opening menu where you start off looking at a zoomed out view of your house. Click the door lock to run xlock, click the mailbox to check your mail. Click the door to open a new xterm-style term. This is like xterm but it will instead be a 3d file navigator. Clicking on the window with the happy person peering out at you will spawn a wine process running Comic Chat, and to logout you click on your bed upstairs. I think that this will be the future of window managers, I'd appreciate any feedback
  • "Oh and by the way, most extremly new users I worked with prefered keystrokes to mouse strokes"

    I've found this to be true as well. Years ago I switched out a user's DOS menuing system for QuickMenu, which used icons. I thought it would be easier for him. But he quickly asked me to put back the old menu, since he found it easier looking over the old list of programs and typing in the number listed. Another person I knew used Wordperfect for years right up to WP 5.1. Then she got a new computer with the "new and improved" graphical version, and her productivity plummeted. She went back to WP5.1 and plain DOS on a 286. She still uses it and is one of the leading medical transcriptionists in the California.

    Personally, I like GUIs. But I'm wondering if that's because no two programs have the same keystroke commands. I know that the bottom entry of the far left menu will close the application. But I never know if that command is E&xit, &Quit or &Close. And whenever I'm using emacs, I type 'i' to start typing.
  • by SheldonYoung (25077) on Friday January 28, 2000 @08:53AM (#1327971)
    Some of open sources greatest successes:

    vi
    Emacs
    Apache
    sendmail
    bind
    TeX
    X11

    And how many of them are easy to use? How many of them are have interfaces that are just evil?*

    But hope is looking up. Look at these newer open source projects:

    GNOME
    KDE
    Mozilla
    GIMP

    So, I think the community is doing pretty well giving geek-interfaces for geek tools. The user-interfaces on user tools aren't doing to badly either. They're not excellent yet, but even interfaces benefit from the open source model.

    * Trick question. Just sendmail's interface is evil, the rest are just difficult.
  • MISplice is right -- while KDE et al. may be nice WMs, getting them up can be a huge pain in the ass, as I've discovered to my chagrin this past weekend, when I installed FreeBSD.

    I've got nothing against *BSD personally, but I think that the 'its designed for hackers' complaint is much more true about the *BSD's than it is to mainstream Linux distros like Red Hat, Caldera and SuSE.

    XF86 has a known bug with ATI Rage graphics cards, such as is present on-board on my current mobo. My hsync is completely out of whack, and I can't even start X with something vanilla like SVGA or even VGA16 servers (640x480: mode not defined. no valid modes found. exiting.)

    It must not be a completely universal problem because I did an install of Red Hat 6.1 at work on a Compaq Deskpro EN series machine here with onboard ATI Rage video the other day and it not only came up with sync correctly, it even PnP detected by name the monitor (Compaq V75). I was quite favorably impressed when that happened, as were a couple of other people who had dealt with getting X running in the past.

    The RH 6.1 CD directly booted up on the Compaq, came up to a GUI installer, it recognized the built in ethernet on the motherboard, recognized the video, monitor and mouse. About the only part of the install that I'd say was perhaps beyond what the average person could handle (without reading the book) is disk partitioning.

    When I wanted to add a few additional packages, I found the GUI RPM tool actually worked pretty well. Again, I was favorably impressed.

    I think that the article has its points, but I would disagree with the conclusion that improvements in usability will not happen or can not happen is off base. I've seen things come a long way since I first started using Linux back in 1993. Don't get me wrong, things aren't perfect yet, but the gap for point-and-click users is narrowing a lot more quickly than what the article would lead you to believe.

  • What you seem to be discribing is "fast" and "powerful", which is all well and good, but it is different from "intuitive". vi is not "intuitive" (yes, I'm a vi junkie). It's extremely fast, but I really don't think you can call an editor "intuitive" when you open it and cannot immediately edit the file by simply typing. Having to type :a to start editing a file is just plain unintuitive.

    Not to belabor the point, but here's what Joe newbie should be able to do when using an intuitive editor for the first time:
    #vi foo.txt
    type some text to edit the document


    What really happens:
    user: vi foo.txt[enter]
    vi: ~
    user: type
    vi: .(beep)(beep)clipboard is empty(beep)
    user: ?
    vi: ?
    user: [enter]
    vi: error
    user: q
    vi: (beep)
    user: x
    vi: (beep)
    user: [escape]
    vi: (beep)
    user: dsaf (hitting keys at random)
    vi: f
    user: fghsdf
    vi: fghsdf

    You get the point.



    --GnrcMan--
  • The problem is actually quite simple to describe. Designing good user interfaces takes as much time and dedication as it does to design good plumbing (eg. the kernel, OS, shell).

    It's also difficult for someone who is working in one discipline (ie. the kernel) to understand/accept the rigors of working in another discipline (ie. UI design)

    A good UI takes years of research and design. It's not a matter of making the windows look pretty. It's making them work pretty.

  • by Bert Peers (120166) on Friday January 28, 2000 @08:54AM (#1327983) Homepage
    I'm glad to see someone picks this up.. I was recently ranting about this on the linux gamedev list but couldn't find much response for this. Imho this goes pretty deep; yes, we have Gtk and Qt to get away from the 30 year old "command prompt is just fine, thanks" attitude, but we still have a long way to go. Let's not turn this into yet another GUI-vs-console debate : I guess what works best depends on if you're the geek type, or just the end user "where do I click to launch Office" type. To break through, Linux should support both. But here's indeed our Achilles'heel : the development of these apps with smooth, welltested GUIs. Say what you want about MSVC++, but once you've used their built-in editors to model your GUI and attach code to it (a la Visual Basic), you really don't want to go back to native Win32 programming. Since hand-connected signals and slots under Gtk or Qt are the Linux equivalent of such hand-tuning of Win32 code, you also don't want to go program GUI's under Linux anymore without the Linux equivalent of MSVC. This is really important because without such ultra-user friendly, dumb-monkey-could-use-it interfaces the tools to build content, and hence the apps which need such content (like games), will not arrive under Linux. I know, I know, this may be ranting.. but I'm just happy to see this topic getting picked up under developers after months of crying in the void :) As long as the "cutting edge" IDEs of Linux or lagging years behind MSVC, decent GUIs simply wont become common because it takes too much effort to build them... I mean, it's coming (check out the FLTK project).. but the general attitude still seems to be "we don't need GUIs.. so why build them, or build the tools to build them". Maybe KDE and Gnome's IDEs will change this ?...
  • A good part of the credit for the lack of a friendly interface has to go to the folks who keep saying "If they can't figure it out, that just proves they're not worthy to use it." This response seems to occur regularly on Slashdot whenever a criticism is levelled at Linux useability and installability.

    And besides, who'd want a Nova, when you can get a perfectly good Dart Swinger for the same price...?

  • by nevets (39138) on Friday January 28, 2000 @10:02AM (#1327993) Homepage Journal
    You hit the nail squarely on the head!

    A first time user doesn't understand most of this. Think of yourself as going to dance lessons. You start off feeling funny and don't understand all the terms. You feel stupid by asking and looked down on by others that have been doing this for a while.

    If you want OSS to succeed, you need to make it easy. If we can think of a standard interface utility that performs "Control Panel" operations, then this could help not only the users, but the gurus themselves.

    If we can come up with a standard configuration tool that takes an ASCII config file as input, and produces simple user interface, then this would accomplish the task. Something that would be a standard, much like rpms are today. Say we have a Linuxconf interface that would get its commands from a file.

    Example:

    # hostname command
    start command;
    label: hostname
    entry: text
    run: hostname text
    end command;

    Where this would be read buy some utility and show a label stating hostname: [ ] and then when the user enters in the hostname the command
    "hostname entered hostname" is executed.

    This way all new utilities can conform to this format and append to the config file, or just have a single config directory (like /etc/config.d) that gets read by the tool, and have a "make xconfig" menu or linuxconf user interface. This would also solve the problem that some of us (me included) don't like about linuxconf, that we don't know what it is doing. But with this, all we need to do is look in the config.d directory and see for ourselves. This would make end-users happy (simple interface) and gurus happy (can see WTF is going on).

    Of course, this utility would need to be thought out quite a bit. Maybe have a separate organization under OSI to make the standard. My example was just to make a point and not actually a real example.

    Steven Rostedt
  • its light-years behind such advanced OS like Win2000 Pro and MacOSX as far as useability

    You are entitled to your opinion., but I would disagree with that. I can't say much about MacOSX, but in the case of Windows 2000, unless it is really a giant step beyond NT 4, I can't say that I am all that impressed. It is flashier, and perhaps slightly more consistant than Red Hat, but I find NT frustrating. I don't necessarily equate fancy with advanced. The NT environment may be easier for people who don't like to learn anything to stumble their way through, but for people who know what they are doing, things just take too much click-click-clicking to do. There are a lot of things I'd rather do by command line or script, and those things just aren't that nice to do in the Wintel world.

  • The goal of open source, as I see it, is not to make software designed for the least common denominator. That's what Microsoft and AOL are for.

    We are not failing if our software seems to complicated to a computer-illiterate newbie -- that's not who we designed the software for.

    The goal of open source is to make software that doesn't suck. As long as we continue with this, we're doing fine.

    Open source software is usually designed to be very powerful and flexible. With flexibility and power comes complexity. Do we sacrifice writing powerful software with writing "easy to use" software? It cannot always be both.

  • I can get newbies to run vi. Here's how:
    I tell them that the standard UNIX text editor is ed. I get them to fire it up. I try to hide my laughter. Sometimes, I have a hidden camera. Nothing beats videotaping a newbie's first session with ed! Then I say, "A lot of people prefer vi to ed." Hey, it's true! They always say, "What's vi?" "I say, it's name comes from 'visual editor.'" As soon as the word "visual" escapes my lips, I can see their eyes light up. They fire it up. I say, "press i." And they're in heaven!

    If I'm feeling really nice, I tell them about Emacs.
  • by jht (5006)
    For most people, there shouldn't be a requirement to learn much. For you, I, and most of the readers here, computers are a tool we can shape as we need to, to perform whatever tasks we can conceive. For us, a computer should be a flexible and powerful as possible, so we can mold it to each task we want to perform.

    But most people don't need or want that kind of power - they want an appliance. Something they can turn on, perform predetermined tasks with, and turn off. They want it to be inexpensive, reliable, and simple. Customization isn't important - simplicity is. We can't provide that with OSS at this point in time.

    As far as "winning" goes though, Linux is useful today. Therefore we've won in a big sense. But the commercial development of Linux and the market acceptance of OSS have come in large part because the promise is there to build something suitable for Everyuser. Red Hat is worth billions in market cap, and can afford to pay lots of people to sit around and write Linux code that gets GPL'ed. That's not because geeks are a huge market - it's because of the potential to grow beyond the geek community. But without that potential, the explosive growth we've seen will go away, the funding will dry up, and Linux will go back to being an excellent OS that people hack on because they want to. But the increased pace of development and market acceptance we're seeing should say something. It tells me "I don't want to go back".

    I'll share a dirty little secret with you: I use Linux on a desktop and a server at home, and a couple of servers at work. Users at my company use Windows NT, because it's "good enough" for their use (easy to use, and much more restrictive security than Win95). And when I go home, and want to just turn on the computer, check my email, read Usenet, write checks, and work on my book...

    I use an iBook.

    - -Josh Turiel
  • Open source is forware written by geeks, for geeks. The GNU community is self-serving, fulfilling it's own needs. That's the whole point of open source. You get the code, and you get the means of tweaking it until it fills your own needs.

    Nobody is out to replace Windows or MacOS here. Total World Domination is a sarcastic battle-cry, one that's intended to promote the "Do It Yourself" ideology. We're not competing for Linux on every desktop here...

    What the author suggests, at least implicitly, is that we need focus groups and marketting research user-proxy specifications to tell open source developers what sort of GUI the anonymous masses want to see. Sorry, I don't buy it.

    A certain level of technical know-how has always been the price of admission into Unixland. If you don't like it, then you'll like what you're given.

    The MS-Windows interface is confusing to new users as much as the X Windows interface. DOS commands, the concept of directory trees and shutting down before shutting off are all foreign concepts to new users - until they learn.

    This is the true Achilles' Heel of open source/GNU/Linux. The steep learning curve. We don't need no stinkin' GUIs! What we need is a consistent means for newbies to become knowledgable users. We need to make self-education easier. We should not come up with a conceptual kludge GUI that shows soft links as fuzzy icons and hard links as fuzzy icons with a sharp outline, or any some such bull.

    We need usable user documentation, online help that's not written in C or PERL, but rather in English (well, it's a start). man pages suck! We need a central repository for this knowledge, and we need it to be new user-friendly. HOWTO's are great once you know what you're doing and just need a heads-up on a specific item. They are after all, slightly polished notes on the process someone went through. They EXPLAIN LITTLE, they're recipes. We need readable docs, a Q&A bank, an online reference, and a human hand for new users to hold on to for the first few weeks.

    Once they are off the ground, they'll run circles around MS-GUI users, in X, in ksh and in the {G}UI of their choice. That's the point. Empowerment. Choice. Can't do it without education.

    As was stated in another of today's articles, (to paraphrase Marx)
    ..theory has removed the flowers from the chain, not so that man shall wear the unadorned chain, but so that he may recognise the chain for what it is, and throw off his shackles so that he may pick the flowers as they are..

    A pretty face that abstracts the workings (and knowledge thereof) of a system is just sticking more flowers in the chain, so the user feels grateful for being led around by a sweet smelling garland. It's not right.

    Sometimes, a non-intuitive (to an ignorant user - no offense intended) interface is the best way to represent the underlying concept beneath it. People who understand the inner workings of the system see it a certain way - true to the core functionality. Misrepresenting the system beneath the interface does the user harm in the long term. It keeps new users from becoming knowledgable about HOW the system works.

    Let's not try to save ignorant users from their own ignorance by giving them an indiot-proof interface. Istead, let's teach them to fish.
  • by spectecjr (31235) on Friday January 28, 2000 @11:17AM (#1328024) Homepage
    Here's mine

    (installed by three computer engineers; one a Linux user since before it was a buzzword (Patch Level 0.98 if you must know; that was July 1993 or so); one an applications developer with 18 years development experience on a whole slew of OSes, and lots of UI design and development experience; and a computer engineer with 10 years experience, plus a degree is psychology + a minor in ergonomics/human user interaction).

    I'm the one with the 18 years experience by the way :)

    A friend of mine has installed Corel Linux
    1.0 (he downloaded the standard downloadable distro), and I played around with it today. He did the "Doofus" install - that is, he just stuck the CD in, and said "Uh-huh" to all the questions it asked. It was installed on a Dell Optiplex GXM 5133 machine... and it sucks. Or maybe it's just KDE that sucks.

    Within 5 minutes of playing with it, I managed to get the whole OS (seemingly) hung with a complete lockup except for the mouse. Now sure, I could probably have telnetted into it and unlocked it, but I'm afraid that I couldn't get the network working over DHCP (see later). What was I running to do this? Well, we had been running notepad, but I had one "KDE Explorer" (nee Windows Explorer) window open. I can't remember if I'd tried to open the floppy drive, or the CD-ROM drive, but that shouldn't kill everything. Even the keyboard LEDs wouldn't toggle. And of course, CTRL+ALT+DEL doesn't do ANYTHING. Couldn't reset it. Couldn't get a console window. ARGHGHHGHGHGHGHHGHHHHH!!!!!!!!!!!!!!!!!!!

    Maybe this should be expected (after all, it's a Corel product), but personally I find that kind of worrying. I do have to wonder how much of this was KDE and how much of it was Corel's fault.

    Speaking of KDE - lots and lots of performance issues were there - it kept being REALLLLLLY slow the first time it'd show a dialog - it would visibly rearrange them on the screen. I'm guessing that it was written in something like TCL/TK, and that's why dialog resizing was so slow. Windows - on the same machine - had a perf approximately 5 times faster, if not more so, for its windowing/resizing.

    Speaking of which, on moving the "Taskbar" to the top of the screen, and opening Netscape, Netscape opened up UNDERNEATH THE TASKBAR. If I put the taskbar at the bottom of the screen, Netscape would resize out of the way. But at the top of the screen? It was screwed - opening a window shouldn't do that. I had to move the taskbar to fix it.

    Speaking of which, a couple of UI issues:
    Telling it to "Refresh Desktop" (to move the icons out from UNDERNEATH THE TASKBAR AFTER I'D MOVED IT...) did so quite happily - the full-screen flashed, but it did it.

    Telling it to, however, "Arrange Icons" (surely the same thing?) instead caused it to throw up a big nasty DESTRUCTIVE OPERATION WARNING Dialog Box asking me "Am I sure that I want to rearrange the Icons?" Yes/No?

    What the HELL is that about? And why not the same thing for Refresh Desktop, which appears to do the SAME THING? Huh?

    Speaking of UI inconsistencies.... yes, why I hit "APPLY" in a dialog box, I want it to apply NOW. I do NOT want it to ask me "Do you want to apply changes Now?" - because I just told it to. At least you can turn this off for Deleting files in Windows.

    Context menus are missing on edit boxes - but for some reason, they work happily on the desktop. WHY ONE BUT NOT THE OTHER? THIS IS INSANE. IT'S TOTALLY INCONSISTENT.

    Speaking of which, Right-Mousing on the desktop left the focus on the desktop - with the control panel I had open still left looking active (including the selected text in the box, and a flashing caret)... sorry, if the window's not active, I want to KNOW about it.

    Also, selecting text in a box and typing does NOT delete the extant text in the box - which is also totally counter intuitive - pasting removes what was there if anything's selected, so should typing. That's how it works on EVERYTHING else.

    In the control panel, when trying to set up networking, I hit Apply. It asked me Y/N. I said Yes. I said "Close". It closed the *panel* I was working in. I ended up hitting CLOSE 4 TIMES before I could get it to work. And then I had to CLOSE THE APP. If Apply does exactly the SAME THING as the OK/CLOSE button, but the difference is that it asks you if you want to do it or not before it commits changes, WHY THE HELL IS IT THERE? THERE'S NO BENEFIT TO IT BEING THERE WHATSOEVER.

    Also, shouldn't DHCP/BOOTP find a DNS server for you? In which case, shouldn't the "ADD DNS" dialog box be DISABLED when you're in DHCP mode? And also, why are the DNS settings boxes (IP, Default Gateway, etc) ALWAYS DISABLED WHATEVER YOU DO? Are they just there for show?
    This is S*(&!@(*#& INSANE! THERE ARE CONTROLS ON THE DIALOGS WHICH DON'T DO ANYTHING!!!

    So in conclusion, Corel Linux/KDE (after a 5 minute look at it) is pretty impressive. It brings Linux kicking and screaming into the GUI world - and it shows. Now don't get me wrong; I'm not coming at this from the point of view of someone who won't take the time to learn the system, but for all of Microsoft's faults, Windows is
    pretty damn good. In comparison:

    Microsoft Windows has some pretty annoying flaws. It causes a lot of people to get angry because of these. Corel Linux, because it's running on Linux/KDE, makes people twice as angry, with twice the hassles!

    Seriously - Corel Linux is pretty good. However, it still sucks. The KDE/Corel guys should get some people who understand user interface design, and create a CONSISTENT UI. Because at the moment, it doesn't cut it.

    Never mind the fact that by the time we left for coffee, we still hadn't worked out how to get the network to work over DHCP.

    ---

    Addendum:

    My girlfriend (who has been using Linux since 1993 (pl98))has just tried to install Corel Linux on her machine.

    We put the boot floppy in. We put the CD in. We restarted the machine. It came up, detected the hardware, flashed, showed the wallpaper again, open the CD-ROM tray and shut it again (almost like giving us the finger), and restarted.

    And did the WHOLE THING ALL OVER AGAIN. AND AGAIN. AND AGAIN. AND AGAIN. AND AGAIN.

    Eventually, after this many reboots (my friend Wes had only had to have one on his Dell), we tried removing the bootfloppy. The machine promptly booted into Windows 98 (which Shana uses to play Dungeon Keeper). Now, either this machine was possessed by the spirit of Bill Gates himself (and thus wouldn't let Corel Linux pry it free
    from Windows), or something's rotten in Denmark.

    The machine in question runs Mandrake Linux *fine*. But the Corel Linux install wouldn't even say what was wrong. It was just braindeadedly rebooting and rebooting and rebooting with nary an error message in sight. This is, by the way, COMPLETELY AND UTTERLY LAME!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

    Shana (pronounced Shaynna) would like to say at this point "Bring back the Linux Quarterly!!!".

    ----

    I think basically what we have here is a case of "Attack of the Cargo Cult GUI Designers" ... basically, they see what other OS's have, and implement the same. But badly. Very very badly. How would you like to be running an extremely (comparatively) unstable version of an amalgum of Windows 3.1/Windows 95 and FVWM, but one that has just enough (but not quite) implemented to make it *just* usable - that is, if you didn't use it much and in general gave up and just used the command line instead - but on the whole is horribly inconsistent?

    Simon
    (the last sentence should have been sanitized for your convenience... but I was too busy)
  • How can they say that the GUI's are hard to use? Sounds like it was written by someone who has never seen XFree86. It's almost as simple to use as Windows or MacOS.

    Actually what makes it hard is the ammount of system resources your typical program is using.
    Take an example I went from version 1.1.10 of the gimp 1.1.14 and suddently more and more memory was being sucked into the program. Wheras a perfectly good program had once run on my machine 16MB or physical ram and 20MB of virtual the machine needed even more. So now I have something like 38virtual just to make sure the memory dosn't just magically run out.

    If people would just optimeze the development the UI could be more user friendly and still be interesting.
  • A lot of linux users/advocates are making the mistake of taking broadening the user base as an unwritten ethic. I'll tell you what, I'd really like to see Linux get better hardware support, more software, blah blah blah, but if the price is dumbing it down to the level of the average user, and having the community flooded with morons, I'd prefer the status quo.

    As someone said, OSS programmers have tended to put functionality far, far ahead of making pretty and intuitive interfaces. And really, that's the way I like it. To paraphrase from Allen Holub's great book, _Enough Rope to Shoot Yourself In the Foot_, we musn't confuse ease-of-learning with ease-of-use. MS Word is relatively easy to learn: it has buttons with pictures, lots of visual metaphors, decent help, and that damned office assistant. But it's hard to USE. To anyone who learns Word's basic ins and outs, and starts to get comfortable with it, it's "user friendly" features start throwing curveballs. In short, all the fluff designed to make it easy for new users to get into it makes it difficult for advanced users to stay with it. At the opposite end of the spectrum is vi. This little piece of ware has a totally un-intuitive UI. It's so complicated, it has it's own Nutshell book. But everyone who I know who's really taken the time to learn it, swears by it. A vi user has basically taught the commands to their fingers, and doesn't have to really think about what their doing, rather like a manual transmission in capable hands. Use of vi also doesn't require constantly losing momentum by having to go for the mouse. In short, it is difficult to LEARN, but easy to USE. (Another great example is Blender, www.blender.nl, a 3D rendering and modelling tool with the least intuitive interface you've ever laid hands/eyes on, but which is a breeze to use once you get the hang of it.)

    Anyway, there's a lot of people who don't like this state of affairs. They think that we should all follow the lead of GNOME and KDE and their ilk, to copy the "successful" interfaces, in order to make Linux easier for the newbie (although I contend that those two projects have their own UI "issues" that make them bad examples). Go ahead and call me elitist, but I think the largest reason why this is a bad idea is that it will make Linux more marketable to the Best Buy/CompUSA crowd. You see, until now, the rude state of unix UI's has served to make it the domain of knowledgeable people. People who know that their computer won't work during a power outage, that their CDROM is not a cupholder, the difference between memory and disk space, that they can't order the 'net on a CD, et cetera. In short, non-morons. But people who buy commodity PC's and Macs, are, for the most part, morons, at least when it comes to applying some sense to computer use. The great majority of users are resentful that they can't just sit down and "get it", that they have to think and learn. They get angry when something doesn't work to their own unreasonable expectation, and usually take it out on whoever is trying to help them. From working in a small custom PC shop for 7 months, I encountered, studied, and catalogued quite a few morons. The only really important thing about them is this: I *don't* want them using Linux. Hell, I don't want them using a COMPUTER! These people should have those web-pad thingies.

    So to those who cry that Linux UI's are in a horrific state, I say "so &%$#@*! what?" There certainly are some UI's, and many configuration schemes, that are not only difficult for newbies but for advanced users, and those DO need work. But just because you have to sit down and -- the horror! -- read the documentation before you can successfully handle a UI doesn't make it bad. In essence, we shouldn't start a crusade to fix UI's that aren't really broken.

    MoNsTeR
  • It sounds like you're saying we need *another* window manager?

    Not so much a window manager but something more akin to X itself. Something that takes UI elements (say, via a pipe or network connection, like X) and constructs a meaningful rendering of that UI for display. It could be graphical, text, auditory, whatever. So long as we have a consistent "widget" set, applications can use those elements to build an interface that fits in consistently with the platform the user is using.

    I don't necessarily disagree about the practicality, but it seems like it'd solve a wealth of problems by removing the coder from the responsibility of creating a meaningful user interface entirely, and either leaving it up to the system, or people that know how to build style sheets to *make* a good interface.
  • by 348 (124012)
    The fact is that it's much harder to make good end-user software than it is to make good infrastructure software - and that's going to make it tough for Open Source software to break out of its server niche.

    This is so true. A common thread around here is that someone will say "But doing X on Linux is hard, it was easier on my old UI" or something like that and then the flames start. Linux is supposed to be for people who are smart enough to understand it etc. etc. I agree to a point, specifically around the infrastructure areas, but to be truly mainstream and industrial strength, Open-Souce software will have to grow up so that the average customer can use it.

    Never knock on Death's door:

  • And I'm afraid you missed the point of the article entirely. The point is that developers have to go farther and do some research via focus groups, extensive beta testing, irc/usenet/email contacts, etc. Its easy to sit back and say "what, specifically, is your problem with my program?" That isn't going to get anyone anywhere, because thats the way the open source world works now. And its broken. The problem isn't that there are specific little problems that affect Linux and all that its releated to. The problem is that the whole damn thing is the problem! The problem lies in the fact that geeks and hackers live in a very different world from the rest of society. What comes as simple and obvious as breathing to us never occurs to most people. I know, because I live on both sides of the fence. I'm a hardware geek, and am very good at working on hardware/OS issues. But when it comes to the real guts of programs and Operating Systems, and their attendant interfaces, I'm in many cases as clueless as the general public. I can explain to someone how to install a new hard drive in 15 mins, and I can see the problems that most people have with something I consider child's play. But I have a lot of trouble "using" Linux, and the reason is that you hacker types don't realize that the rest of the world might not find configuring X and KDE or some other window manager to do anything useful isn't just a walk in the park. I've read two LARGE books about Linux and still feel about as comfortable using it as I do pulling my own teeth. And I'm a relatively intelligent person as far as technology. Where does that leave the average construction worker who wants to be able to get email from his kid going to an overpriced college out of state? These people aren't going to ever be using Linux without training, unless the community does something to fix the problem. And doing something means going beyond saying "do you have problems with icons?" and "is there something wrong with the menus?" It means, quit using places like Slashdot as your "focus group" and go hire a real one. That's the only way the open source community will ever make it out of the server room in the basement.
  • Darn I could have sworn I just did that with RedHat 6.1. I popped in my cd of RPMs and the installer came up and I selected the packages I want. It works that way for CDs and other stuff also. If you have an autoplay file on the disk it can start a regular instaler also.


    If you got RedHat to install without problems on the first try, you are very lucky. Don't assume that just because RedHat installed fine on your particular system configuration, that it will install just as easily on someone else's machine.

    I've installed (or tried to install) RedHat on dozens of systems, from antique 486's on up to brand-spanking-new Athalons, with all sorts of random periperals. From my experience, RedHat has maybe a 15% - 20% (tops) chance of installing correctly on the first go on some random collection of parts. (Compared to about 75% first-time success with Win95 or NT [havn't played with 98 or 2000 yet, thank Ghod!]) Now, if I build a system from scratch using only parts that are on RedHat's level-1 supported list, I almost always get a clean install. Unfortunatly, the list of RedHat's level-1 supported hardware is still miniscule compared to that of the Beast Of Redmond and it's evil spawn.

    There's an old quote that goes: "Unix is user friendly; it's just very choosy about who it's friends are."

    I think the article itself does a very good job at pointing out the weaknesses of open-source. Don't flame me; I think open-source is a great concept. But, in order for the open-source model to displace propriatary software, the open-source community has to be able to acknowledge it's weaknesses and limitations.

    The open-source model has proven itself to be very good for developing infrastructure software like operating systems, programming tools, and servers. Linux, Apache, and gcc are examples of open-source at it's best. But remember, these are tools designed to be used by computer professionals, not end-users. The

    The vast hoardes of double-digit IQ office workers and home users want software that automagically installs itself, has lots of eye candy, and holds their hand to do even basic tasks. The main reason Windoze has auto-play CD's is because so many people are just too stupid to be able to open the CD in Explorer and double-click on SETUP.EXE. Commercial software companies spend millions of dollars on usability studies and getting user feedback. If you want to pander to the mass market, you'd better give them what they want if you want to succede.

    We geeks tend to forget that not everyone is as technology-oriented as we are. Just think for a minute about how many people can't even set the time on their VCR or program it to record a show. Look at VCR-Plus -- a whole system created to make programming a VCR idiot-proof -- and even THAT'S too complicated for a lot of people to handle!
  • Most free software projects rely on instant feedback from their users - as ESR points out, this is one of the greatest advantages we have over commercial developers. However, if developers aren't getting feedback from the target population (which, for many of the new projects out there, is J. Random User), that advantage is lost and applications which are too obtuse for them are produced. Therefore, the situation should be changed - developers must make an effort to get average users to get involved in development. This is difficult because development software is generally much more difficult to obtain and install, and, if feedback is to be useful, must be kept up-to-date on a regular (in some cases near-daily) basis.

    The key thing developers can do to make this process easier for non-programmer users is provide binary rpms or debs of recent development, complete with instructions on how to install them. You must also pay close attention to the feedback they provide, even if it is difficult to follow sometimes (and extracting the exact nature of a problem or complaint can be like pulling teeth). Mozilla, perhaps the free software project most focussed on end-user development, does both of these things.

  • by Aasmunds (114237) on Friday January 28, 2000 @08:59AM (#1328062)
    X is easy to use, if someone sets it up so that it is easy to use. Which means that there are as many different "easy-to-use" setups as there are hackers. To the experienced user, a bad thing about the Windows GUI is that you can't do very much about it. To the inexperienced user, a good thing about the Windows GUI is that it is pretty much the same no matter what box you use. Furthermore, Windows comes ready to use out of the box. X doesn't. And X is not X if you change machines. FVWM, GNOME and KDE look and feel very different, and adding new apps and changing the sysadmin's stupid default setup to one you like is not entirely painless for the inexperienced. Bottom line, X is still a hacker's GUI.
  • by Vox (32161) on Friday January 28, 2000 @11:24AM (#1328063) Homepage
    "Type: $photoshop myimage.png" Which will work IF: photoshop is in the path.
    Most programs installed with an RPM/deb go to a place that IS in the path or that gets added to the path by the after-install script (at least in those RPMs that are correcty constructed)

    myimage.png is in the current directory.
    If it isn't, you type the whole path, easy.

    both of which are very often untrue. Actually finding where the photoshop binary is located is not a newbie task.

    Mmmmm...."whereis photoshop" is usually enough, very intuitive, even.

    Neither is altering the path.
    On this one I have to agree...altering the path is something a newbiew can't usually do by himself, unless he's had some DOS experience.

    As far as that "open with" BS... You could just drag the icon for the myimage.png to the icon for the photoshop program. That's the proper way to use a gui. And probably even easier than typing your command line.

    Mmmmm....two clicks to open My Computer (same if you want to use Windows Explorer), a bunch more to find the photoshop.exe program (unless you have a shortcut to it on your desktop, which ususally means having to do it yourself...let a newbie try to do that on NT Workstation 4,,,not as easy as you make it sound)...then open another My Computer/WExplorer window, find the silly graphic, drag it to the photoshop.exe icon....yes, very easy, I can see that.

    And yes, I know what I'm talking about, I'm writing this on an NT box...and I, among other things, train people on both Windows and Linux at work.

    Windows is easy, as somebody else already said, only for those that are used to it, and as an example I'll put my mom...she started using computers about a 18months ago or so...I gave her the choice between running linux and windows ("what do you like better, what I run on my computer (Mandrake 5.x at the time, with E as my wm),or what my brother runs on his (winNT workstation)?" She chose linux :)

    After about 3 months, her computer gave up (very old box...damn HD died after only 8 years), so she started using my brother's box while I was buying parts for a new box for her...after a week, she threatened me with bodily harm if her box wasn't working in the next week, cause she couldn't get a thing done in my brother's NT box.

    Two days later her box was ready...15 months later, she still thinks all the "windows is easy" people have no clue what 'easy' means.

    And no, before you ask, she had never used a computer before I gave her that old box with linux in it...and no, she didn't set up a thing in it, I did it all...just like I did with NT for my brother, DOS for my father (he runs only one program in his computer, so...boot DOS, load program, do stuff, exit program, turn off puter)...what people still can't understand if that setting up an OS is NOT something for the average Joe...I don't care who makes the OS, my mom will NEVER be able to install it.

    And yes, she does install programs in her box sometimes (only RPMs, and if she gets a dep error, she ICQs me and tells me what are the missing things and I find teh packages for her and then she just "rpm -Uvh *" in the dir where she placed them all)myimagemyimageVox, who is REALLY sick of this "this is easier than that"

  • by vanguard (102038) on Friday January 28, 2000 @08:59AM (#1328067)
    When I was a sysadmin I installed a package with a terrible gui installation routine. The only people who would use this installation routine (the software cost around $750,000) are experianced system administrators. The next revision of the installation was not graphical but it worked. The new system was well accepted.

    What's my point? Good UI design is not important for applications that cater to IT pros.

    I wonder if he's looking at the apps that are built for IT guys?

    The X window is not tough to use. It's certainly not any tougher the MS Windows. Star Office is a breeze, so are the other apps targeted at "users" (xmms, gaim, etc.).

    I don't this it's fair to bash the UI of Apache because my Aunt can't set it up. It wasn't built for her.
  • by Hrunting (2191) on Friday January 28, 2000 @08:59AM (#1328070) Homepage
    If you look at it, the foundation for open-source software has been laid out over the years. Functionality was always second place to aesthetics and usability. Now, OSS is entering a more mature age where those other concerns begin to exert themselves. KDE isn't a unique interface, but GNOME is pretty unique. If you take the ideas of themes, then you have an open-source GUI model. Some themes are extremely excellent in terms of their usability (some are downright awful). Granted, the code underlying all of that isn't beautiful, but end-users only see what's on top anyway. Programs like wmakerconf and sawmill's control panel allow people to make these changes extremely quickly, even directly from the gzipped tar file. You can't tell me that that's not extremely easy.

    What this article says is that the OSS model has a hard time producing good GUIs, but that's not the case at all. We haven't needed good GUIs because our programs have never been for the end-user. Now that OSS is going mainstream, the end-user is being involved, and I think the OSS model is successfully tackling this challenge as well.
  • I'm afriad you misunderstood. I guess i was trying to make two seperate points, and i didn't differentiate them clearly enough.

    Point one, i am not saying that everybody has to go and learn to program, i'm just saying that those who do are the only source of growth for an open source platform.

    Point two, i am not saying that we should not have a GUI, i'm just saying that as far as i'm concerned a GUI should always be a secondary concern to functionality. Some applications however, a GUI is legitimately part of the functionality (like Paint/draw/cad/3d modeling apps) where the task at hand is graphical).
    Also, i don't have any problem with a GUI that has _NO NEGATIVE IMPACT_ on efficiency or flexibility. I refuse to sacrifice functionality so your mother (no disrespect to the lady (actually, it was my mother who taught _me_ BASIC) can use the same apps. This can be achieved in several ways, one is to make the GUI optional (like you can compile two versions of EMACS, one with X and one without, but the app is the same either way), and another way is to make apps that can be started with a command-line telling them what to do, but if you start them without any flags, they will bring up a GUI to ask the user what they want done (like Aladdin Expander for windows).

    To sum up once again, GUI's are fine so long as they suppliment rather than detract from funcitonality. The Amiga is a great example of a system where the GUI was well integrated but not necesary for users who prefered not to use it.
    I do not mean to say that everybody must learn to program, but i am saying that everybody who is inclined to should be helped along, because they are the real, original, and final target of open source software.
  • He's not talking about how cool the interface is or how you can customize your right-click window to include X and Y programs. He's talking about how you help users do things. It doesn't matter how simple it is to bring up a popup window if it takes 5 minutes worth of clicking to get something done. What needs to be done is to watch users using your product and see how they do things. The main point is that to you and me editing a conf file is a perfectly good way of doing things and bringup up printtool is just as easy as clicking on the Printer Setup button but for most people that just isn't the case. We need to look at how people use our stuff and how the things users need can be done more easily.

  • DLL? do you mean shared object. This isn't a Windows machine.

    Syntax is irrelevant. Hacker/Cracker, DLL/.so, they're all just names :P But yes, of course, I mean .so. I typed the comment at work. I'm a VB programmer during the day, and yes, I hate every minute of it.

    Personally, I'd much prefer an ".so". That way one can make their own application. Applications can have preference boxes based on the linked object. Everything would be standard.

    There's no way, imho, that a "universal" control panel would ever work. Apple originally had that pre-System 7. Sort of. And it sucked, lemme tell you. Linuxconf, e-conf, gnome-conf (or whatever that's called) all have similar problems. How do you deal with different sized windows, etc?

    So yeah. Hope this helps explains that :)

    Jezzball
    ls: .sig: File not found.
  • by waldeaux (109942) <donahue@@@skepsis...com> on Friday January 28, 2000 @09:00AM (#1328096)
    OK I may be a radical, but although I hear over and over again that the "failing" of Open Source (which for the purpose of this response I will equate with UNIX) is that the user-interface is SO HARD compared to

    I have spent almost no time using Windows since I first ran into it in 1983 or so. I have avoided Win3.1, Win95, Win98, WinNT, and I will probably try to avoid Win00 (as in "Win zero zero") when it plops onto the universe. That doesn't mean I haven't USED it at all, but I haven't attempted to master it.

    So, now it looks like I'll be started a new job soon which uses WinTel all over the place. I'm not worried about that (aside from all the obvious places I should be worried: security, scalability, reliablility, etc. :-), but when I see other people using WinTel OS's it seems that the UI is nothing CLOSE to "immediately obvious". It's levels upon levels of options and configuration which isn't intuitive most of the time.

    OK - so let's compare that to X11, Gnome, CDE, and even to older things like OpenWin. Are these UI's THAT far afield from Win9X or NT that they're actually MORE difficult to master? I think not. Sure the key mappings might be different and for most users, there's some fraction of expected interaction with a command line,but even for Win9X people, there is still a LOT of "delving into DOS" that takes place, even though there is a percentage of users who only interact with the GUI.

    So what about this new generation of UNIX users (defined for convenience as the post Ultrix/SunOS/ SCO people --- basically the "Linux era", although that also includes non-Linux UNIX, e.g., Solaris)? While it's not common to have users who never ever deal with the command line, I think we've reached the threshhold that it could be done. The available client software that I find under RedHat and Gnome are very quickly eating away any need (other than convenience that my fingers are hardwired to vi sequences and sentences like "ls -lt | head -5" :-) for the shell. The file managers are no worse than what comes with Win9X, there's a Gnome "finder" that works as well as the one in MacOS (does anyone know why "find . -type d -exec chmod g+s {}\;" doesn;t work under Linux?), and so forth.

    At this point I think arguments along the lines of "well, Linux/Open Source loses because they have really geeky UI's" is more FUD than accurate. It will become even less accurate over a somewhat short time scale! One metric to testing this assertion it to see how many "normal" admin UNIX tasks (sysadmin or user adminstrative tasks) are being pushed over to programs with UI's than are done on the shell. Programs like Gftp, xchat, etc. are definitely taking the place of all the command-line programs in my life, mostly because the UI is straightforward and gets me to complicated uses faster and easier than before. At that point, it's no different than searching for some obscure panel item in Win9X...

    YMMV, of course.

  • by banky (9941)
    One of the most common anti-Linux things I hear is that "while you're typing away, I'm getting work done", implying that point-and-click GUI applications are the only way to do useful work.

    Once again, I think its about mindshare, not technology per se. People equate typing to bearskins and stone axes. People also have developed a large amount of "muscle memory" when it comes to using a UI. I can't live without alt-tab, I have yet to retrain my fingers for any of the different "superior" keybindings, for instance. And may people now refuse to take their hand off the mouse, even if it provides an "easier" way of doing things.

    Themes are nice, but usability is more than themable checkboxes and xmms skins: its a consistent metaphor across the entire UI, which imo is against what X stands for: why force anything? But until a certain level of rigidity is enforced, it won't ever be set for Aunt Millie.
  • If you've ever seen a button on your computer marked only with the cryptic symbol

    ( | ) or ( ' )

    you've seen the Worst Interface In The History Of The World. This is some geek's idea of what the interface for a Power button should look like. You might have also seen it's precursor, the power switch marked with 1 for on and 0 for off (which is binary for those of you who don't know). The ( | ) is meant to be a 1 and a 0 combined. This is the perfect example of why geeks cannot be trusted with interface design. (Ask yourself if any manager or marketroid would come up with using binary on the front of a home device, I think not) While you and I might recognize that in binary 1 is on and 0 is off, who the hell else would know that? Why did someone think that any user would know what that meant? All we can hope for is that they eventually figure out that the little ( | ) turns the computer on and off. If all we're shooting for is that the user eventually figure out the meaning of the button exclusive of the symbol, why not just make all buttons random sized white squares, eventually they'll figure it out. This is my specific example of why programmers/geeks should not be allowed to design interfaces, because we come up with ideas like the ( | ) button.

    This is a small (and some have argued dumb) example but in my opinion, if we can't even come up with a good interface for something as fundemental as the power button, how are normal users supposed to figure out what we're doing with our other interfaces?
  • ...an article about the flaws of Open Source software that doesn't hint (or outright declare) that the solution to these flaws is to abandon the Open Source model.

    Until the user's perspective is an integral part of the Open Source development process, those Open Source products that rely on end-user interfaces (beyond the command line, that is) will continue to offer substandard interfaces on top of excellent engine code.

    This problem can be fixed by merely paying attention to what ordinary users want and/or need.

    Of course one person's flaw is another person's feature, but that's okay too. There will continue to be command line interfaces for those of us who want them, but an easy to use "training wheels" open source operating system with lots of GUI bells and whistles would certainly help to spread the gospel to those whose life doesn't revolve around computers, but who still use them from time to time.
  • In order to compete on the desktop - which seems to be very important to the Linux community - there has to be a completely new focus on useability and UI. That's the point of the article.

    Hold on here. Developers are people too. They have computers at home too. They sometimes even have machines that they will refer to as 'desktops'. Many of these very developers need the kind of tools they design (with poor idiot compliancy -er, user friendliness) because they operate better that way. For some, that's why they started uing Linux. I'm one of them.

    I will agree that most people are stupid when it comes to interfaces, and therefore selling them a CLI based program just won't work. But I think that might just be a good thing, a very good thing. I don't know, and this is entirely idle speculation, but, it might be the glue of opensource. Think about it, if you write code, and all of the users of said code are competant, then there's a greater chance that they will contribute to your project than if (say) 5% of them were competant.

    I know for a fact that many opensource projects behave this way, take Cistron Radius, when someone posts to the mailing list something they should know or have found out in due course, Alan Dekok is the first to not answer thier question, but tell them where they should have already checked. In many cases it appears that it would be more efficient to simply answer the question instead, but it seems he's trying to enforce competance, sometimes I'm so impressed that it brings a tear to my eye.

    It's the same for bug reports, every time someone gives too little information, the developers complain profusely. In an idiot-compliant scheme, you can't expect that complaining to anything other than futile. But again, I've seen it work. This is because most people involved in opensource projects are either competant or willing to become so. Even the 'end-users'.

    So much for by-hackers-for-hackers.
    ---
    It's not smut it's data
  • by Industrial Disease (16177) on Friday January 28, 2000 @09:02AM (#1328122) Homepage
    Almost as simple to use as Windows? Yeah. That's the problem. The Windows GUI isn't that great, and hasn't seen any real improvement in usability (as opposed to cosmetic changes) for years. Looks like the new MacOS might have some significant improvements in usability under the eye candy. A lot of people have learned to use the Windows and Mac GUI's; people assume that means they're easy, and that they're the best possible interfaces. I don't buy it. I feel like there's got to be a better way; unfortunately, I don't know enough about UI design to know what that better way could be.
  • I think he definitely has a point. I think that most average users would never think to find a programmer on the project, and say what's on their minds, because they are used to years of large companies who let all suggestions sit in a box somewhere and never act on them. I also think that it may be hard because some programmers have very little tolerance for end users, while some are very open to input.
    One thing that made me bristle while reading this was the idea that a graphical user interface should be part of the program. I love all my command line linux tools, because they are small, powerful, and configurable. I can put everything i need to rescue a system on one floppy. I can script stuff. The main thing that makes Linux worth it for me is the tools, and the fact that the GUI is _ENTIRELY_ optional. (this is starting to change... Ever tried installing a distro from CD _without_ the X libraries? &ltDOH&gt)
    I do think that providing support for desktop users who don't want to know what's under the hood may be a good idea in terms of a quick way to increase the user-base, but i grew up when everybody had to be at least comfortable with a command line (my first comp. was an apple II clone (Franklin Ace 1000)), and most were programmer-users. I think that one thing that is missing is an intermediate step for new users to head towards programmer-users without having to be dropped right into a confuding environment of uncommented C code. I think that it might be more useful to make a nice integrated BASIC (&ltshudder&gt) interpreter that is ultra-user friendly to get the new users that have the drive to become programmer-users, but need some sort of a stepping-stone to become comfortable with the system. That's what got me (and a whole generation) of new computer users into the whole thing. Having a starting place that is easily self taught, soon you'll want to do more, and then you'll look for a more powerful language, find C, and if people did a little more commenting, there would be plenty of example code for new programmers to learn from.
    To sum up, i think that for short term concerns, it may make sense to lure in desktop users by pampering them, but it would be nice not to damage any of the flexibility in the process. However, i think that for long term growth, what we need to do is create a less intimidating environment for more programmer-users to learn and be nurtured in, because they will ultimately be the main source of growth, reguardless of corporate support, etc...
  • IMHO Whats needed is to get some real expertise in man-machine interfaces involved - I am sure there are a great number in the academic community ( psychology / human perception / cybernetics graduates and lecturers ) who I believe would be more than happy to give their input on taking the GUI in a whole new direction, and try and get away from the Desktop interface model entirely. The model in itself is/was good - but is limited when the information being used is no longer local or centralised, but distributed. An example of one of my favourite non - 2D / Desktop/Folder interfaces is the PLUMBDESIGN THESAURUS [plumbdesign.com]. It would be nice to see something more intuitive at a basic level than the desktop. Klik
  • I disagree with the author. A really well designed gui would be wonderful, but who would use it?
    All of the people who really know computers extremely well, like many of the readers of slashdot probably would, but the readers of slashdot are but a minority in the group of all computer users.
    More important than quality is consistency. My father, a man who has had a home computer since 1987, hates the way each time he buys a new computer, he has to learn a new system, first DOS, then Win3.1, and now Win98. And he uses the computer more than the "average" user. What he, and I think most people want is a system that is consistent. Sure, upgrade the system, make it more capable, but keep the user interface consistent with something people know, so that they can focus on actually creating a product with the computer, rather than learning how to use it.
  • The article is all well and good, but it ignores a prime example of a perfect UI designed by hackers, for hackers. Ed.

    What's that? You've never heard of it? Don't have access to a Unix box you say?

    Fear not! Just compile this source code and you too can experience the joys of ed:
    /* ed.c - the editor with the best UI ever! */
    #include <stdio.h>

    void main()
    {
    char devnull[80];
    while (1)
    {
    gets(devnull);
    printf("?\n");
    }
    }

    --GnrcMan--
  • I have yet to see cut/copy/paste shortcuts implemented consistently among apps and desktops in X. The KDE apps usually use Ctrl-X/Ctrl-C/Ctrl-V, but Netscape uses Alt-C/Alt-V/Alt-P. Other programs use other things, if they support it at all.

    GTK+ apps also tend to use Ctrl-{X,C,V}, bless their soul (GTK+ itself uses them in its widgets).

    The rationale for Netscape's choice may have been some noise about supporting Emacs keybindings, but it drives me nuts; I'll have to see if I can bludgeon it into going with ^X/^C/^V by tweaking my .Xdefaults file.

    Then again, it also irritates me that Quicken 2000 appears not to use ^X/^C/^V either - and that's not an X app, it's a Windows app. At least the other Windows apps that I've used are better behaved than that.

    At the same time, it makes me nuts when I highlight something, want to paste it into something else, and have to spend time figuring out how to do it.

    ...which isn't helped by Qt's apparent insistence on using the X primary selection, rather than the X clipboard selection, as its clipboard.

    At least middle-mouse-button paste-current-selection tends to work most places, at least if you aren't trying to replace a selected chunk of text with another chunk of text (as doing the latter means you have to select something other than that which you're trying to copy...).

  • by cpeterso (19082) on Friday January 28, 2000 @09:08AM (#1328161) Homepage
    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)? The answer is relatively simple: The Open Source movement has no feedback loop to end-users, and no imperative to create one.

    I think this is the author's fundamental mistake. The developers of successful Open Source projects are its users. The user has a software itch that must be scratched. No one else is going to do it. Most Open Source developers don't get paid to write their software. They code for personal enjoyment. Can someone think of an example Open Source project where the developers are not users?

  • Bah! Apple's interfaces aren't flawless, not even close.

    Let's take their most visible product, the imac. Now I haven't actually used an imac for an extended time so feel free to laugh off my criticisms.

    HOWEVER, there are several ui issues that seem obvious without even turning on the machine.

    A round, one button hockey puck. Come on! People have five fingers, at least use two or three of them. Also, Apple seems to have forgotten Fitt's Law. As in, "does the mouse fitt in my hand?"

    A small screen. It looks like 15 inches. Isn't the norm 17 inches lately? I guess I can forgive them, they were trying to make the imac cheap.

    A small cramped keyboard. 'Course windows machines seem to come with these too. Personally, I can't stand standard layout keyboards. The best keyboard I've ever used is the original microsoft natural; the one with the inverse T arrow pad. The current version sucks. Leave it to MS to upgrade the only product that was perfect at version 1.0

    No expandability. Not a ui issue (or is it?) but it still pisses me off.

    No floppy. C'mon, guys, cheap removable storage is useful! And don't tell me that the built in ethernet makes up for it. You can chain together as many imacs as you want and you still can't take your documents to work with you.

    I guess those are the biggies that are very noticable WITHOUT TURNING IT ON.

    I know you can buy external usb mice, keyboards, floppies, zips, etc. But do you think this strategy improves the user experience?

    Seriously, if I wanted a small screen, cramped keyboard, hostile pointing device, and no expandability I'd buy a laptop. And even that comes with a floppy drive.

    Ryan Salsbury -- Apple sucks just as hard as MS.
  • by Little Brother (122447) <kg4wwn@qsl.net> on Friday January 28, 2000 @09:08AM (#1328168) Journal
    What is easy for you and me, even if you're not a programmer. Is probably VERY different from what is easy for the old lady down the street. While I was in high school I earned spending money as independent tech-support, advising and systems repairs for the town in which I live. I learned quickly that there are things that we take completly for granted that many people have a difficulty learning. The people I worked with were primarly college graduates and none were paticularly dense, nevertheless here are some of the problems I came accross:

    Someone didn't know what double-click meant, thought it meant clicking with BOTH mouse buttons. (Makes as much or more sense than clicking with one button twice.)

    Someone didn't know that Windows 95 wouldn't run very well on his 386DX system. (how should he know?)

    Someone didn't know that return and enter mean the same thing.

    Someone didn't know what I meant when I said "monitor."

    Someone didn't know what I meant by "Icon"

    Someone didn't know how to access the file menu.

    Someone didn't know that he had to turn on his external modem seperatly from his computer system.

    Someone didn't know what a link was

    Someone didn't know how to turn on his monitor. (I had a bit of trouble finding the hidden switch.)

    Someone didn't know the difference between memory and disk space (many don't actualy)

    These are but a few examples of things that are EXTREMLY basic to us. However few of them are intuitive in actuality. Most "geeks" I've talked to don't understand the mindset of the non-computer literate user. They could write a user-friendly program, if only they knew what the user might need.

    Oh and by the way, most extremly new users I worked with prefered keystrokes to mouse strokes, so why do all the manufactuarers rush to put GUI's on all desktops? A simple arrow key oriented shell (in the msdos shell sense of the word) would be better for many of them and applications with a printed list of ctrl commands may well be more usefull than one with confusing pictures.

  • Wrong, Wrong Wrong

    There seems to be this perception among people here that good UI design is about just adding more eye candy. The Gnome developer who suggested that he could easily add transparency to menus completely missed the point.

    First of all, I'm not going to pretend I know a lot about UI design, but it's a field that interests me and I read about it on mailing lists and the like.

    In theory, UI design is about making things simple, logical and asthetically pleasing. The reality is that since most people are used to Windows now, a good UI today will find a way to balance good design decisions with the way that Microsoft does everything.

    Let's start with an experiment. Bring your mouse pointer into the center of your screen. Now, move the pointer into one corner of the screen. Notice how awkward the movement in your wrist is. Move the mouse back into the center and move it to another corner. Notice how awkward the movement is. Reapeat for the other two corners. Now list the corners from least awkward to most awkward. If you're right handed, your list should look mostly like this:

    Bottom Right
    Top Left
    Top Right
    Bottom Left

    Now, where is the start button located?

    Acording to Tog, (yes, I'm a mac head, but I like all OSes) Default buttons in dialog boxes should be on the right side of the box. Where does windows put the default button? You guessed it, on the left. I think the reason the right is the correct side (for a righty anyway) is that the eye tends to focus on the right side of the screen. This is also probably the reason that the default positions for mac icons are on the right.

    As for eye candy, it actually does improve the user experience. Think about it this way, who would you rather see naked, Natalie Portman (if she was 18) or Rosanne Barr? I rest my case. This is also the reason that wallpaper and custom mouse pointers and the like are so popular.

    Another misconception here about UI design is that a savings of a 1/2 second is insignificant. Believe it or not, a 1/2 second is actually very significant savings and they do add up. I'm not going to take a side on the one vs. two button mouse (I happen to like a multibutton mouse myself, but advocate a one button mouse for newbies) but until users have enough experience with it, there is a measuarable delay as they try to click the right button. For popup windows, I prefer the timed mechanism that netscape on the mac uses.

    As another example, consider the mac menu bar. It has its disadvantages, but for Fitts' Law compliance, it can't be beat. Pop quiz: name the 5 easiest pixels on the screen to hit with the mouse. Anyway, the mac menu bar is infinately high making it a very easy target to hit. Windows (and everthing else) has a menu bar that's a fixed height and width. When I move my mouse to the menu bar, I can over-shoot it as much as I want, and still be right on top of it. Contrast this with the other way where you have to be aware of your acceleration. The downside of the mac menu bar is that new users sometimes think that they're in a different program than the one they're actuall in. They also don't realize that there's a difference between closing all the windows and closing the application. This is the reason that mac os 8.x and up, can display the application name next to the icon in the menu bar, though I'm not sure it helped much.

    It's important to keep in mind that there's no perfect interface for all users. I've taught a number of people to use computers and what I tell them is, I'm going to show you how I like to do things, but if you find a way that you like better, then use that instead. This could potentially be a great oppertunity for OSS on the GUI as every hacker has their own way of doing things. On the other hand, most users will just use what's given to them and make the best of it because they're too afriad to try something else because they think that they'll screw up the system or it will be too hard. You can thank Microsoft for that mentality too.

    To the developers of Gnome and KDE and all the others, I wish you well, but if you want to get Linux on the desktop, (and maybe you don't, in which case, disregard this post) then it's important to understand what makes something powerfull, consistent and easy to use. There's no reason that software has to be powerfull or easy to use. They can and should be both.
  • I think a lot of the problem is one of perception. The GUI is good idea has been around for a long time, but is difficult to substantiate. Ease of use means taking the least amount of time/effort to complete a task. The substantial up front learning to become a shellophile is paid back every day by *not* having to use a menu for every task.

    One example is simply finding the file one is looking for. Using grep, find, xargs, cut, sort and their ilk one can find any file he wants. Not so with the fancy pants 'find' utility in Visual C++. So the advantage of having the find facility a keystroke away and integrated into the IDE is quickly lost.

    Another example is Star Trek (hey Lederman made Star Trek analogies, why can't I!). They use displays as feedback mechanisms, but for interacting with the computer they talk. Why? Well two reasons, GUIs are really bad TV and also because it is much more intuitive to describe your problem in natural language and let the computer do the rest.

    So, as other posters have pointed out GUIs are gaining ground, but let's not forget the power of text to represent the world. The sooner I can talk to my computer the better!

    BTW, does anyone know a good speech to text tool that I can use from a command line? I'm using Festival to go the other direction and need something to complete the loop.
  • Except that I'm not as optimistic as he is that OSS will be able to solve this problem.

    But before I get to that, lemme try to explain why this is such a big problem, because many of y'all don't seem to get it, judging from some of the posts so far.

    But, you might say, we don't want all those Winblows lusers! We don't care how *smart* you have to be to use Linux, cause we only want us l33t genii (hey! We're even l33t l4at3n speakers!) to be able to use it! Because we all know that, once you learn how to use it (and it doesn't even take me that long, cause I'm so smart), OSS is more flexible, powerful, and faster to use than some "end-user tested" crap.

    And 10 years ago, you'd have been right. The problem here is that the above argument is no longer true, and most Linux users/coders don't even know it. Now there's no argument that OSS for Unix/Unix-alikes has had some of the best text-based UI's around. (Or, in the case of xemacs, I suppose we should say "primarily keyboard-based" rather than "text-based".) Sure, most of them are abolute hell to learn (the poster above who suggested that you could adequately teach a newbie to use vi by sitting them down in front of it and pressing 'i' notwithstanding), but, once you get used to them, you realize how incredibly intelligently they were designed. Things like vi/vim, emacs, and the various CLI shells; you'd need a dedicated teacher, a book, or a hell of a lot of patience with man pages to figure any of them out, but once you do you find that they're extraordinarily quick to use, ridiculously full featured, and amazingly robust. As my Harley Hahn Unix book says ad nauseum, "hard to learn but easy to use." And if you're any sort of geek--someone who's going to spend most of your time on a computer, such that the steep learning curve isn't too relevant--then it's not such a bad design philosophy.

    Thing is, most of us have realized that a GUI has the possibility to make anyone more productive, even Tom Christiansen's proverbial "vi wizard" [slashdot.org]. However, the people making GUI tools/wm's/environments for Linux (note: not that I'm one of them; not that I'm a good enough programmer to contribute a single line; and really truly not to take anything away from their impressive achievements) seem to have figured that we could use a dose of the old paradigms, a huge helping of superficial Windows UI plagarism, and some skinability (neato!) and have a kickass UI.

    Not even close.

    Again, Gnome and KDE are incredible achievements for what they are, and are constantly getting better. But. As they stand now, their UI is clearly substandard. KDE is like Win9x, but flakier (from a UI perspective, not a stability one, of course), with less consistent (though more extensive) preferences panels, unconsistent app UI's, much less polish, and an awful excuse for perhaps the most important functionality of a GUI--being able to seemlessly share data between different apps. Gnome has the benefit of not being such a slavish copy of Windows, but is otherwise even worse in all of the above categories.

    And what do most Linux users do about it? a) Complain about how GUI's are for wimps anyways, or b) Stick on some badass skins and note how, since E has much more functionality than any Windows wm, it is invariably a better UI.

    Meanwhile, what do MS and Apple do about it? They spend millions of dollars a year hiring UI experts and, more importantly, empirically testing thousands of potential interfaces on end-users to find which are better.

    Notice I didn't say "easier to learn". I said "better". As has been noted elsewhere in this thread, the Windows UI paradigm isn't any more intuitive from first principles than the KDE paradigm (duh; they're nearly identical). But that's not the point. What good UI testing is all about isn't how easy it is for someone who's never seen a computer before to use, but rather, assuming the user already has adequate familiarity with the paradigm, a) how flexible, robust, and powerful is it; b) how intuitive is it to do an action which is part of the paradigm but which the user has never actually done before; and c) how fast, easy, and nonobtrusive is it to do the sorts of tasks that the user does again and again.

    By all these criteria, something like the Unix CLI passes with flying colors. And, by all these criteria, Gnome and KDE, and the programs that run on them, in their current states are quite a bit behind Windows, which in turn lags behind MacOS. (Note: I've never been a Mac user, and have always generally disliked them for several reasons: bad under-the-hood technology, horrible overpricing, lack of good, fast software, one damn button, deceitful marketing. However, I'm just beginning to come around to how well designed their UI is (compared to the alternatives), and damn if OS X doesn't look incredible. But I digress.)

    But, you all say, that's what's so great about Open Source! If there's anything wrong with Open Source Software, then someone will fix it! The problem is, very few people notice that anything's wrong. That is, you don't notice how unproductive the way you're doing things is until you see a better implementation. And even then you probably won't notice--it might take someone with a stopwatch showing you how much faster you work the new way than the old way. A quick story to perhaps illustrate what I mean: couple days ago I was procrastinating writing a huge (and overdue) paper, by reading that analysis of Aqua [asktog.com] by Tog, the guy who essentially led the Mac UI development. And, since I was trying awful hard to procrastinate (and because once you start reading him, Tog's pretty interesting), I decided to click the link to this article on Fitts' Law [quailwood.com], where I read Tog's advice to Word for Windows users: switch to full screen mode to get the Fitt's Law advantages of infinite depth behind your menus, and switch to large icons to speed up finding the right one.

    Well, never one to miss a chance to not write my paper, I did some informal tests. And, even though the ideas had never occurred to me (not because I didn't know full screen mode and large icons existed, but just because since it *looks* so much more professional in maximized window mode with by big toolbars full of small icons (which, as I run 1280x1074, really are small), it had to be more productive that way), I realized pretty quickly that they actually improved my productivity. Or, would have, except that in full screen mode the menus, while at the top of the screen and thus with infinite depth, don't show up until you mouse over them (Tog doesn't seem to mind this sort of thing; I find it annoying as hell. But in any case, it's worth pointing out that this is proof Tog isn't designing for ignorant first-time users--because you certainly can't expect any first-time users to know about items which are hidden until you mouse over them--but rather for ease of use for people who know what they're doing); and since MS decided *not* to include higher res bitmaps for all the icons in large icon mode, they looked too damn ugly for me to keep them. But it is true that I could find the right one a lot quicker; and that I'd never realized how my tiny icons were slowing me down until I tested it.

    Ok, I'm hideously rambling, so lemme try to sum up. Text-based Unix interfaces were everything that today's Linux GUI's aren't: consistent, robust, quick (from a UI standpoint, not a technological one), and intuitive for those who already knew the paradigm. A simple example is pipes--a simple concept which gives the CLI its amazing power and flexibility--and their GUI analogues, object models like COM, CORBA, etc. designed to allow intuitive sharing of information between apps--which, to put it mildly, work much better on mainstream OS's than on Gnome and KDE. A more interesting problem (because we at least agree on the fact that our object models need improvement, and I have no doubt that they'll catch up pretty soon) is inconsistent and just-plain-badly-designed interfaces--a failure to take advantage of principles--like Fitts' Law--that the other guys have learned from psychological research and intensive user-testing. Perhaps the most difficult problem is the lack of consistency across apps.

    The question is, how do we fix this. In regards our lack of UI research, I have a good deal of hope. After all, Red Hat has the money to hire some serious UI people and psychologists and testers and whatnot to get Gnome on equal footing with Windows and Macs; Corel or others could do the same for KDE. Hell, they might even come up with some *new* GUI paradigms, instead of just copying the two rather flawed ones out there, often badly.

    The problem is that the strength of OSS lies not in the high-name projects which can now afford serious funding, but rather in all the little ones that provide all the little functionalities we know and love. How to get all of those projects to understand, and furthermore, abide by complex UI standards--when at the moment they can't even agree on standard menu shortcut keys--is a huge problem. Furthermore, there's the fact that a different choice of widget toolkits inevitably imposes a different UI paradigm. Finally, we have the fact that Linux geeks rightly love customizing our systems to the fullest extent; as Apple has clearly realized, with their apparent decision not to allow OS X any skins other than Aqua, customization is the enemy of consistency.

    Hopefully this absurdity of a long post has convinced y'all that these UI issues are important, because they really affect how productive any user is--but elite users *especially*. I do think that OSS can come up with a better response to the UI issue than poorly understand copies of the existing GUIs. However, I'm not sure exactly how, and our work so far in this area has not been encouraging...

  • I think that a lot of the article's comments are directed not only at the window managers, but also at the applications themselves. The window managers are improving themselves in ease of configuration and use by leaps and bounds... It's often times the interfaces for the included software that are either "less-nice" looking or more difficult to use than the Win32 counterparts.

    Even under Linux at home, I use Wine with my Forte Agent to cruise the newsgroups. The Linux application community is getting there, but still has a ways to go.
  • Interesting examples.

    But please note, I didn't say everyone has to be an expert at everything. People having an attitude of "don't want to learn" (particularly, expressed arrogantly) - or of "I don't need to know now make it all simple" are still morons, though. And actually that'd apply to the visitor to the doctor, not to the doc him/herself...
  • by jht (5006)
    Open Source has developed a plethora of worthy software - as the examples mentioned elsewhere prove so well. But user interfaces have never been an area of concern - partly because those of us who use and build the software aren't the type of people who need much in the way of a UI, partly because we're building on a system that wasn't designed with usability as a primary concern (remeber the age of Unix, folks!), and partly due to Geek Testosterone.

    Sure, the Gnomes and KDE's of the world put a prettier face on some of it, but most programs that have a thought-out UI in the Open Source world are just retreads of existing non-free programs' interfaces. So the GIMP is an example of a nice interface? It's pretty much a Photoshop clone that has some differences, but there are more similarities than not. Skins and chrome are cool, and a nice way for power users to spice up their user experience, but if we want to see World Domination anytime soon, we need to understand the needs of the ordinary user. They don't need or want a cool skin - they need a straightforward interface that works the way they need it to and that they can use out of the box.

    Saying "once they learn how to use bash properly" doesn't cut it - If an average non-power user has to get that far they'll give up. Period. They don't want to learn, nor should they have to. For Linux to succeed as a desktop OS, it needs to be possible to perform all the necessary user tasks without ever requiring a command line or editing a .conf file. That includes configuring the system and installing software. For better or worse, the marketplace has Windows and MacOS out there, and both have comparatively well thought-out, consistent user interfaces that enforce similar rules throughout all applications that run on the platform. In this case, the power and flexibility of Linux is the fatal flaw.

    - -Josh Turiel
  • who needs "innovative, flashy looks" when a nice text-prompt will work just fine?

    This is exactly the attitude that the author was pointing out as the reason why the acceptance of Open Source software on the user's desktop is still quite a ways off.

    The point is: end users want innovative, flashy looks, and Good Design(tm). They freeze up like a deer in the headlights when they see a $ or a #. Geeks are happy with command prompts and tend to assume everyone else is to, or they assume implementing skins will solve everyone's problem. Skins are no substitute for good UI design. Thanks for illustrating the author's point.
  • I'm not a user-type, and even I have eschewed free software with ugly UI's for better commercial version. Here's a brief list:

    1. Text Editing
    This is obviously a touchy issue for many. For me, they need a good GUI. On Linux, I use gEdit, which is buggy and feature-poor, but OK. When I want to get real work done, though, I use OpenStep's Edit.app. And yes, I know how to use vi, emacs, joe, and even ed when I must.

    2. CD Burning
    To burn an audio CD on my Linux system, I spent 2 hours(!) reading manuals -- for xcdroast, cdrdao, etc. Then I went to burn, and still screwed it up. I rebooted in Windows, used the free utility that came with my CD-RW, and was ready to burn in 5 minutes. Success.

    3. Copying and Pasting
    Anytime I will have to do a lot of copying and pasting between apps, I switch to an OS where the keys for doing so are always the same. And where there's a real clipboard.

    4. Matlab
    Octave successfully duplicates the command line interface, but (surprise!) has nothing like a more convenient notebook interface.

    5. Paint programs
    Sure, the GIMP is all right. But (unless I'm missing some motherlode of plugins) it is feature-poor, and the interface for some tools in nonstandard.


    Is there ANY free software that makes you want to switch to it, just for the UI?

    - Brian

  • by lbergstr (55751) on Friday January 28, 2000 @09:22AM (#1328211) Homepage
    Programmers are _not_ typical end-users. They are way, way more savvy. On top of that, they're intimately familiar with their own work, so idioms that may be completely mystifying to typical users become second nature to them. The key to useful usability testing is seeing how much a typical, slightly computer-phobic user can get done in the first half hour of use. IMHO, often, a programmer's evaluation of the usability of his or her own work has little connection to reality. UI design should be trusted to UI professionals, subjected to as much testing as possible, and then translated into code.
  • Hear hear. Up the geeks! :)

    "Easy to use" is not the same as "good". It certainly does *not* follow that one implies the other for all cases. After all, if I went for the easy option all the time, I'd be running MacOS X or '95 on a notebook in BED.

    Approach it wondering what it is; if you don't like it, so be it. Don't approach it with an agenda that "it's not easy, I don't understand therefore it's ITS fault not mine". This kind of thing gets right up my snout.

    I knew there was a reason I persist in using Debian - I can cope with the breaks of living at the cutting edge of 'unstable' all the time, for the benefits I get. "If you don't get the benefits, or you don't want to put in the effort, go away and don't moan."
  • by gomi (57888)
    MISplice is right -- while KDE et al. may be nice WMs, getting them up can be a huge pain in the ass, as I've discovered to my chagrin this past weekend, when I installed FreeBSD. XF86 has a known bug with ATI Rage graphics cards, such as is present on-board on my current mobo. My hsync is completely out of whack, and I can't even start X with something vanilla like SVGA or even VGA16 servers (640x480: mode not defined. no valid modes found. exiting.) Now, the webpage for FreeBDSM [freebsd.org] says XF86 3.3.3 and up support the ATI stuff, but I'm using 3.3.5 and still no dice. I've gotten a new video card, am going to bypass the on-board video through the BIOS, and reinstall:
    FreeBSD
    The patch to let FreeBSD recognize my Ethernet card
    The patch to enable DHCP so the box can talk to my router
    And then see if I can get X up.

    This is freaking light-years beyond what my mom can do. I wouldn't do it if I didn't have a business need to have a Unix system at my house. The effort/reward ratio from the user's perspective sucks, frankly, and I think the article is spot-on, point for point. Major improvements in usability and interface need to happen before any Unix can even begin to think of breaking out of the server ghetto.

    gomi
  • 1) Most importantly, no facts, just vague generalities.

    I don't see a single tangible suggestion in this thing. What good does saying Open Source user interfaces suck, if you cannot say "Doing X in program Y is too complicated for the average user, it should be done like A and B." And don't forget to just say, "Fix it."

    2) Don't do research. Open source is for geeks, that's all you need to know. Everyone knows what a geek is, so draw upon that.

    Ignore any email addresses, news groups, mail lists, web sites, icq numbers, etc in the documentation of a program. There is no way to get in contact with the software authors, just give up right now. It is a closed society. If you are not a geek and willing to watch X-Files all night long, you will have no impact on anything. They are all sitting in their darkened basements admiring Natalie Portman while writing these programs.

    3) Honor Microsoft, they are the only ones who can do anything right.

    What do they do right? Who knows, but it is correct, and open source programs will never be able to touch them. Why don't these programmers just go to work for Microsoft? Then we'll have usable programs with every feature in the world, but actually work, philosophies be damned.

    4) Users are the be-all when it comes to designing programs.

    Any feature not included is a snub to users everywhere. After all, what other reason to users upgrade to the latest Windows/Office/etc program than the myriad of features listed on the boxes that they will never use. Eat up more and more hard drive space, but include them, all of them, and more, there isn't enough in that program. What you ask needs adding? I don't know, but add it, and don't stop there. Add something else too! Dammit I want a program that's usable, can't you get that through your head?!

    5) Why is this grass in my yard still green?

    There is no flexibility in that, and I have written paper upon paper imploring God/Mother Nature/whoever to change it. If grass is to be accepted by the vast majority of users, it must be willing to bend a little.
  • by Pike (52876)
    Command-line software all but disappeared from the Windows world because the only available command-line interface, DOS, was such a limited system that it had to be pushed out of the way in order for the platform to evolve. As a result, most people do not know how to use it anymore. They never even learned to begin with.

    It doesn't make sense to say that open source software is inherently hard to use. None of the graphical programs that came with my Mandrake 6.1 are hard to use even by Windows standards.

    Are textmode tools hard to use? Maybe if you've never used them before. They're certainly not the paragon of interface design according to Tognazzini, but for many applications they're the only thing that makes sense. It may in fact be no harder to learn than Windows if you have never used a computer before; you don't approach the system with any preconceived notions about how the interface works.

    Is vim hard to use? Maybe if you're used to Notepad or MS Word. It's all relative.

    I was a bit frustrated with Linux at first because I had been a Windows user for a long time and had not used DOS for many moons. Administering your computer can be a little tough when all you have is a prompt and you have no idea where Linux puts everything. After you readjust, it all makes sense.

    In fact, the only major real hurdle with open source software is having to compile it. Much software is available only in source format. I have had any number of compiles fail on me, and it's too much to ask of a typical user to have him poke around in the code or go out and grab some missing dependencies, even though I personally am capable of trying to fix the problem.

    There should some sort of automated package tool that provides the both the performance benefits of compiling with the automation of a binary install. Rather than distributing a binary package, distribute a package containing a source tree and instructions for the package tool that allow it to automatically compile and install the program, without having a bunch of extra source files laying around if you don't want them.

    JD
  • The point of suggesting stylesheets is to allow one program to be used in several operating environments. MacOS provides a fundamentally different mechanism for setting up things like menus, and has its own conventions as far as button placement, window placement, etc. Most X window managers have a concept of a "dock" where you can run tiny programs. Today you have to write programs specific for each thing. If, instead, you abstract the interface entirely, you can use a form of style sheet (something more akin to XSLT than CSS, though I suspect it might call for something much different) to render widgets, controls and control groups in a manner consistent with the system you're using.

    For example, you could run programs like this using a strictly audio setup, or fold application menus into a dynamic system menu scheme (useful for cell phones, for example).

    The point is you take the construction of the UI layout out of the hands of the developer and put them into the hands of a) the system and/or b) true UI designers.

    I think we're aiming for the same thing, but I think that your idea of a "cross-platform UI" is one that looks exactly the same on every platform (something like Java). My idea of a cross-platform UI is one that's abstracted a lot further and can be rendered in a fashion that suits the goals of the operating environment.


  • What you're failing to take into account here is that many geeks know nothing about user interfaces and that possibly UI/GUI work should be collaborated on by professionals who do it for a living. Yes, you can talk all you want on how that could be open source too, but that's an area where we would be better off buying commercial packages in the near future. Open Source can't be applied to everything... I think that the fields of user interfaces and graphic design are well established OUTSIDE the realm of computers, and that for us to ask that our Open Source model all of a sudden be applied to something that it doesn't make sense with (how can you open source an image? Other than not copyright it at all) is ludicrous.

    I think Open Source does a fine job with straight programming without elaborate user interfaces. For it to enter the popular realm, it needs to have user interface work done WITH it, not IN it. I think Microsoft realizes this and spends a lot of time with the user interface as a priority because they know it's important... and we get pissed at them just because the programming is crappy at times. (Part of the problem with bloatware is that fewer bugs cause more damage, so we see a bluescreen when Paintbrush has some awkward error... but we see the error, not every little step along the way that MS did perfect). I think MS has the right approach in terms of UI/GUI, and maybe a lesser quality but acceptable approach to the programming, and if you want to beat MS, then you can't take the right programming approach and the crummy UI approach (treat it as programming, not separate interface design). Do you think that the same guy who wrote the programming for an ATM machine was the same guy who put it together by hand? No. If that was the case, ATMs would suck.
  • "open source" and "ui" have nothing to do with one another. Open source is winning the OS world because
    • source code is the programmers UI
    • programmers prefer open source
    • programmers control OSes
    • OSes are at the root of the tree and have the greatest commonality, i.e. it's the shared-est part of the software world and the beneficial econmics of sharing source showed up there first.

    There's nothing about the vaunted Windows or the Mac end-user UIs that can't run on Unix and those UIs will show up there eventually when the open unixes complete their takeover of programmer mindshare. They're not there yet because

    • OSes don't have UIs, they have APIs so we don't get one for free and
    • existing end user UIs are OS dependent so they haven't been ported yet. Takes time.

    Whether they will show up in an open sourced form or not depends on the economics of those markets, whether they

    • "need" to be proprietary to make them worthwhile for someone to develop for (think of verticals like airline reservations) or
    • are broadly allowed to be proprietary with some monopolist controlling them

    I hope they are open source and I hope there's no monopoly, but open source is the "programmers UI" and GUIs are the end-user's UIs and they are on orthogonal coordinates.

    --------------

    So, all that said, as two asides:

    • there's much to the XWindows system to recommend it, and the Windows or Mac UIs on a "real" OS with the better client/server separation of XWindows will inevitably be a better Windows than Windows, and
    • can I say, sendmail.* has no business talking about UI to anybody. sendmail.cf was their UI, and as horrible as it was, the m4 stuff is in many ways worse : )
  • by Bert Peers (120166) on Friday January 28, 2000 @09:17AM (#1328237) Homepage
    No, I think he's right. We have feedback loops from end-users when those end-users are fellow geeks. In fact, we have the tightest feedback loop possible because those "end-users" are going straight to the code to fix what they don't like ! But when it comes to our whole new category of end-users, the desktop clicketee-click monkeys which we try to lurk over from their windows machine, we're stubborn as hell to accept that those guys simply need their dumb-ass buttons to click or they'll ignore Linux, period.

    Check out the truckload of arguments dumped here as to why we really don't need GUIs, and then go ask that dumb secretary sitting next to you at the office what she'd think about a PC that gives here "# >" when booted. Yeah, maybe Gnome and KDE is listening to what their users' complaints are.. but the majority of the geeks definitely isn't. I think that's what he was saying.

  • I would say that the OSS community have only failed partly on UIs: GUIs. Compare bash and COMMAND.COM, or GNU long options vs. UNIX options (for command line programs). The textbased GNU tools are _very_ user friendly and powerfull. I once had to rename a large bounch of files, to names made up by parts of their old names, and some new (common to all files) text. Fourtunately, I hade Cygwin installed on the machine, and just did a one-line shell command that used sed to replace the names. The windows user whom I helped was _very_ impressed by how easy it was done.
    But still, the OSS community have failed when it comes to GUIs. Because there is not single rule of thumb how to use X programs, except copy/paste (Which works fairly well for text, but while it is possible to, no one has implemented it for pictures and other data). It is totally impossible to use X without a mouse - there is no way, that works in all programs, to switch focus from one button to another, or press a button, with the keyboard, like it is in Windows. But GTK and QT is on their way, they only have to team up together to form a uniform user environment build up by heterogeneous programming tools.

    --The knowledge that you are an idiot, is what distinguishes you from one.
  • Thanks, you just illustrated the point.

    I believe it's exactly the sarcasm about users that the author was trying to illustrate. The traditional view of developers is that users suck, and rightly so. Users should simply get it, or they're too stupid to use the program anyway.
    Now I think that's a pretty healthy attitude for developers to have, which is why there should also be specialized UI/useability analysts/designers involved whenever you create a system or a tool for a widely distributed (skill, experience) user-base, rather than depending on the developers creating the underlying functionality.

    In order to compete on the desktop - which seems to be very important to the Linux community - there has to be a completely new focus on useability and UI. That's the point of the article.


  • by dammitjim (10999) on Friday January 28, 2000 @09:27AM (#1328244) Homepage
    Part of the disconnect in this discussion is that we're each operating with our own definition of a "good" user interface.

    Yes, efficiency in a UI is good. Flexibility, consistency, clarity and information density are also good. There are lots of qualities that make a particular UI implementation useful. The trick is to include as many of those as possible into the product.

    The interface for Cisco routers, as anyone who's ever seen it can tell you, is quite simple. Efficient. Able to be used via a low-bandwidth text interface, which is perfect. But is it easy to use? Not for most people. Microsoft Bob, at the other end of the spectrum, was incredibly inefficient, but useable by most people above age 5.

    I think the main point is not whether XF86 or a particular WM has a good interface, since those programs are mainly MAKING the interface for the rest of the system. Does Sendmail have a good interface? Does vi? Only when considered seperately and by somebody who is very familiar with them.

    For the VAST majority of OSS projects there are no common use models. That makes learning the software more difficult. On the MacOS, most software conforms to several systemwide standards. CMD-Q is quit, CMD-O is open, etc. Windows is almost as good. These types of things make a system AS A WHOLE easier to use. That is the challenge for OSS project leaders - find a way to make their learning curve work for them.
  • >Saying "once they learn how to use bash properly" doesn't cut it - If an average non-power user has to get that far they'll give up. Period. They don't want to learn,

    This much is true, and not a problem. Just don't expect those of us who know our shells from our eggwhisks to pander to the sheer pathetic attitude of "don't want to learn".

    > nor should they have to. For Linux to succeed as a desktop OS,

    Disagree from here on, though. People *should* both have to, and want to, learn how to use something for what it's worth in the first place, otherwise get lost by all means. Open-Source hasn't got where it is today by getting a committee-load of morons together saying "we can't help, won't help, make it pretty pictures for us".

    I suggest you also have a strange idea of linux either "succeeding" or (in general) "winning". It doesn't win by having more (l)users; it wins by being *better* than the alternatives (not "the competition"), and having a user-base giving out a *quality* signal, not a quantity one.

    How can "power and flexibility of linux be the fatal flaw"? They're right up amongst its major strengths, apart from stability and all that.
  • One of Mike's key theories seems to be that there is no sense of feedback between the end-user and the coder in Open Source development. I would refute this fairly strongly - often the people I know using Open Source tools have fairly widespread experience of other User Interfaces, ranging often both across multiple platforms and going way, way back to before the days when the Graphical User Interface first raised it's head above the primordial digital soup. Now this experience does not make any of these people a UI expert, nor does it necessarily mean that the programs they write have well designed User Interfaces. It does however give us the possibility of recognising good UI design when we get to experience it, and also the possibility of influencing the design of the User Interface in later releases.

    In these days of expanding user-base for Linux, and the push to provide a more newbie-friendly environment to work in (which, by the way, I totally support), good User Interface design is getting to be much more important. There are various resources appearing, from the Gnome UI Improvement project [gnome.org] and its mailing list, along with the work that the KDE people are putting together with KDE 2.0, which are testament to the need to try and learn from the many graphical interfaces out there and to innovate as well. Having a well designed UI need not reduce the speed at which the experienced user uses their machine, while allowing the novice some hope of making progress.

    Innovation is often overlooked in designing a new UI. As soon as you stray from, say, the way MS Windows does something, people jump up and down worrying that new users will be confused by a different method. I'd disagree - just because it has been done that way before is not, in itself, reason to continue doing it. A good UI *must* be intuitive and logical at some level - simply copying the existing behaviour of other window managers will not end up with a coherent project. At the moment, the graphical user interface is a mess of conflicting ideologies. We all have experienced the frustration of 'Drag-and-drop' when it isn't a universal quality - for example in Windows, you can (sometimes...!) drag a file into a program to load it, but you can't drag that file out to save it or pass it to another application to work on it in a different way. And I don't mean using the clip board either, although that may be the route that would be used to effect such a transfer, it shouldn't be obvious to the user that that is how it happened.

    Taking the best paradigms for working with a graphical user interface and making it all stick together in a cohesive fashion is a task of iteration, experience and reiteration between the end-user and the coder. Since in the Open Source world the user may also wear the coders hat, this should be the ideal environment in which to create and refine the most useable graphical interface on any platform, as long as we keep our sights on some central game plan of Useability and not merely on creating a feature-rich tick list of things our programs can do.

    Cheers,

    Toby Haynes

  • Most of our interfaces *do* suck to some degree, let's not deny that. To deny it would mean denying the need to keep making them better. The fact that our interfaces tend to suck much less than a lot of the competition, well, hehe, that's no reason at all to get complacent.

    He's bang on the money about the user feedback loop - it's crucially important. But he's wrong to say The Open Source movement has no feedback loop to end-users. What's this [uibk.ac.at]? We need more stuff like this, better stuff like this. The only thing is, I'm not sure the devlopers in question are using this excellent facility to the extent it should be - there are many out-of-date user comments on there, mainly because the wanted features have already been added. In time, if the list isn't kept current users will stop posting to it, in the mistaken belief that it isn't doing any good. But that's just another glitch to work out.

    The thing is, making good interfaces is just another interesting problem for geeks to solve. Define the problem, and we'll solve it. First we'll start with poor solutions, then we'll keep making improving them until they're good solutions, then make them better and better until... well, it never stops. Need to talk to users? Ok, sure, voice chat is kinda fun sometimes, anyway. Need to try it this way instead of that bad old way? Ok, that makes sense. Need to read a about it? Just give me the URL!. Need to give prizes for the best user interface designs? Come on, somebody with more money than geekness please step forward to sponsor the contest. The only hard part of this is recognizing the need. Achille's heel? Far from it, it's just another hill to climb.

    The fact is that it's much harder to make good end-user software than it is to make good infrastructure software

    No, that's just wrong. Speaking as someone who does both, has been doing both for 25 years, and doing it well IMNSHO, I can say with considerable confidence that creating good infrastructure is much harder than creating good user interfaces, and the stakes are much higher. Without good infrastructure you get a monstrosity like Windows (pick your flavor) or Dos - something pathetically non-functional. Glitzy user interfaces are the hare, and good infrastructure is the tortoise - it takes a lot longer to do the job if you build sturdy infrastructure first, but you can then build your stucture much higher without having it collapse (apologies for the mixed metaphor). In the end, the tortoise wins. Is winning.
  • what would be _really_ cool is if you gave window edges infinite depth. Think about it: if an individual window could lock the mouse inside it, the menubar issue goes away, along with some other problems. There would have to be a way to get _out_ of a window (hold down middle button to get out?), but this would solve many Fitts's Law problems with minimal rewriting.
  • I really don't think that's an option. Linux, and to a lesser extent FreeBSD and openBSD, is picked up by corporations. They don't care for the product (at least, most of them don't). They just see it as a tool to make money.

    What will happen is that these so called geeks will (have to) find another outlet for their programming creativity. The geeks and protestors of today will be the establishment of tomorrow. That's how it's always been, and that's how it always will be.


    ----------------------------------------------
  • by jilles (20976) on Friday January 28, 2000 @10:08AM (#1328276) Homepage
    Funny:

    "It's faster for me"

    Haha, you confirm the article in every respect. You rant a bit about speed and efficiency and you completely ignore usability.

    Of course it is faster if you know what to type and you happen to be able to type fast. I saw my grandfather use a PC a few weeks back and I assure you, this wouldn't be as fast for him as it is for you.

    The article's point was that OSS developers are brilliant programmers but are also completely clueless about providing a usable GUI.

    Look at linux. It took until the late nineties before people were starting to realize that the traditional userinterface (X + really crappy windowmanager) sucked for somebody unwilling to deal with a commandline. What did they do? After years of complaining about MS windows and it's user interface the best they can do is cloning it. We have to wait for Steve Jobs to see some actual innovation (about which a certain GNOME hacker manages to say that he can do the same since he can do transparency).

    Interesting sidenote: this also applies to mozilla. If you read the newsgroups people are complaining about the user interface. A common reply to these complaints (you guessed it!): write a skin for it. Mozilla is brilliant except for it's userinterface. Little thought has been put in it so far. At best it is netscape 4 with skins + some features of internet explorer. Where's the innovation?
  • Can someone think of an example Open Source project where the developers are not users?

    But that's the wrong question, isn't it? The important question (for this discussion) is how many users aren't the developers of the software?

    OF COURSE the developers should be users of their software! That's obvious. But I keep reading comments from people who seem to think that only developers have a right to suggest features.

    This is incredibly short-sighted if Open Source/Free Software is be the dominant product. For years I've been hearing people say that they just want their computer to "get out of their way" so they can do their job. Now it seems many people here want these people to become programmers instead.

    Of course, programming is a wonderful and usefull thing to learn, but not everybody wants to do that. Should Open Source/Free Software be limited to just geeks? I didn't think so.

  • by Wellspring (111524) on Friday January 28, 2000 @10:09AM (#1328280)

    I think this was the best point the author made. For an experienced administrator, typing in a quick and dirty text command is the quickest way to do things. For someone who is keeping her life as non-computer oriented as possible, though, text interfaces, key combinations, and scripts/rc files are all hopelessly arcane and arbitrary.

    That's why windowing metaphors are so powerful-- you are hijacking training that people already have in the Real World and using it to ease the adjustment. That's why complex procedures are laid out in wizards: to guide people through it without having to remember an algorithm.

    If you are trying to let someone do something complex, you want to make them learn as little as possible in order to do it. That doesn't mean they are ignorant, it means that we are imposing on them to spare as little brainspace as possible. A doctor doesn't make us learn medicine-- we shouldn't force him to learn software engineering.

    This is all pretty obvious, IMO. But it is easy to forget. As coders, we know way more than the average person about computers. We don't need metaphors-- we can handle the raw abstractions. So in the name of flexibility and consistency, we get straight into what often amounts to minor coding in its own right.

    This is compounded by feature creep. People are paying for features they won't use on their Office apps, and then wonder why their desktop is so crowded, and why everything has to be filed away in menus.

    Finally, since abstraction is our living, we are using it too much where we shouldn't-- the user's experience. Making something universal, making it systematic, often good things. But sometimes you have to hide the underlying elegance in favor of being usable by people who don't know code.

    emacs is not what we want. Enlightenment isn't, either, though it is ridiculously great. Nor is Word, really. MS's interface advantage isn't that they're particularly good, they are just what people are used to now. What we have to start thinking about is what is making Linux suddenly so popular to the Rest of the World: What do users want? Linux addresses security, stability, standardization and upgrade issues that the business world probably assumed were inevitable.

    What we have to do is what PARC did years ago. Say "What are these computers for?" "What can they let people do which they couldn't do before?" and "How can computers help people do what they're doing now more efficiently?".

    Answer those-- and don't think that companies like Apple aren't asking those questions every day-- and people will wonder why MS and others can't make an operating system which doesn't need to be unravelled by a PhD in CS. Rather than saying that about us, which is what they're doing. In almost every other area, Open Source has proved to be better. I think that, if people really start focusing on it, we can take the lead on it.

"Well hello there Charlie Brown, you blockhead." -- Lucy Van Pelt

Working...