The Open Source Design Conundrum

Matt Asay writes "Walk the halls of any open-source conference and you'll see a large percentage of attendees with ironically non-open-source Apple laptops and iPhones. One reason for this seeming contradiction can be found in reading Matthew Thomas' classic 'Why free software usability tends to suck.' Open-source advocates like good design as much as anyone, but the open-source development process is often not the best way to achieve it. Open-source projects have tended to be great commoditizers, but not necessarily the best innovators. Hence, Red Hat CEO Jim Whitehurst recently stated that Red Hat is "focused on commoditizing important layers in the stack." This is fine, but for those that want open source to push the envelope on innovation, it may be unavoidable to introduce a bit more cathedral into the bazaar. Without an IBM, Red Hat, or Mozilla bringing cash and discipline to an open-source project, including paying people to do the 'dirt work' that no one would otherwise do, can open source hope to thrive?"

Comments

Apple makes good hardware

[walshy007]

Thing is apple laptops are usually pretty good in design, so even OSS people will buy one and then put distro of choice on it, problem? not really. Good hardware is good hardware.

Re:Apple makes good hardware

[tixxit]

Yep. I think some people just need to realize that there are lots of people that use OSS simply because it is good software and not because we are zealots that hate Microsoft or Apple or whatever.

Re:Apple makes good hardware

[segedunum]

This is basically just a gigantic band aid, and is unlikely to be successful. Most of what needs doing is to fill in glaring gaps of functionality in software that is now ten years old or more. Much of what people will put in there will already have bugs in an upstream Bugzilla somewhere - years old with no resolution other than WONTFIX. I fail to see how that will change.

I really hate that term 'usability' that a lot of people never define and expect to be the answer to their troubles. It gets thrown around by many in the open source desktop world mainly as a response to mask the internal troubles in the software that they're using and if someone starts talking about 'usability' and 'Mac OS' as benchmarks then maybe people will think 'Hey, they're going to be as cool as Macs!' and that they're doing something about the issues and it will all go away. Usability is about far more than making some sad Mac clone. It's about developers, developers, developers, developers - creating the useful applications and functionality that people want, making it easy for developers to create it and getting that functionality to users. Windows has that. Mac OS has that (albeit with a few speed bumps), and can run the open source software most open source developers use, so it's what you're going to see most of them use.

The Linux desktop is not the answer. It doesn't have to be that way but it's going to take a distributor to really grab hold of the situation, make sensible software choices on behalf of developers and users and identify just what system it is they're putting together. Given that we have desktops in the open source world that have limited functionality in the name of 'simplicity' (read JoelSpolsky on 80/20 method of software development - http://www.joelonsoftware.com/articles/fog0000000020.html) and we have brain damage such as PulseAudio that distributors readily lap up without any thought then I really cannot see who's going to do it. 'Just Works' is so far away it's just stopped being funny.

Re:Apple makes good hardware

[node 3]

Usability is about far more than making some sad Mac clone. It's about developers, developers, developers, developers - creating the useful applications and functionality that people want

No, usability is not about functionality, it's about how that functionality works. Specifically, it's when the functions are designed to work in a way that better matches the way humans function. Open Source tends to focus more on how the computer functions as a computer and not enough on how it functions as something for people to use.

This focus on human-computer interaction is something the Mac excels at. People don't point to it as inspiration because it's pretty. They point to it because it's more usable. Its prettiness is just one aspect of its usability.

To be clear, functionality is important, but it's not the same as usability. To be usable, a system needs functions, but merely having the functions doesn't make a system terribly usable.

Re:Apple makes good hardware

[woodlander]

Actually, just over half of the nipples are found on men. Check yourself.

Re:Apple makes good hardware

[SanityInAnarchy]

First of all, developers are far from the only Firefox users, even on a Mac. People like their addons.

Second, Firefox was an example -- it's trivial to find inconsistency even in Apple's own software, before you get to third-party stuff. And Windows is even worse. The fact that people can paint "inconsistency" as a major weakness on Linux just strikes me as absurd -- the differences between Qt and GTK apps are nothing compared to the differences between various Windows apps I've seen.

All that said, Firefox tends to be a fairly decent UI, no matter what platform it's on, so I think that disproves the "open source can't design" theory.

Already handled

[clang_jangle]

This is already being done. Many of the most successful FOSS projects have corporate contributors, so this "design conundrum" doesn't really exist. As for the popularity of Apple devices among FOSS developers, well, a lot of Apple software is based upon FOSS. In fact Apple, like it or not, is a pretty good example of how to monetize FOSS. Can't say I'm thrilled with the methods they employ to achieve that, but it's still a fact that they do achieve it.

Re:Already handled

[Old97]

The best things about OS X and the iPhone were published in academic journals years ago; some as much as two decades ago.

Your statement is generally true for all software. Just about every important thing we do in software was thought of by 1980. There have been refinements, polish and some interesting synergies gained by combining things - innovations, but few if any important inventions. It's just a lot of these ideas were not economically viable to implement until hardware improvements, materials and costs made them so.

You should also credit Apple for excellent execution - since Jobs returned at least - in a number of key areas which left them well-positioned to implement the good ideas once they identified them. One thing neither FOSS or Microsoft can fix is difficulty in aligning hardware and software designs when both are moving targets and only one is in your control.

Re:Already handled

[Geoffrey.landis]

Apple, also, don't innovate much....

You say that almost as if you think it's a criticism.

There's nothing more annoying than innovation that's implemented solely for the sake of innovation. There are places where you might enjoy that, sure, but for a machine that you use every day to get work done, you only want innovation that makes your work easier.

...while Apple is much better at finding good ideas to copy.

A desirable trait.

UI Design and custonmer support are the dirt work

[Anonymous Coward]

That many developers feel it is beneath them and gets in the way of them developing. In the commercial space, developers rarely interact with customers in a support role or in UI design. Many would quit before performing this role, but developers in some cases are the only ones who can properly address this.

In one company I worked for, developers had to eat their own shit in that they were forced into part-time customer support of their code. When your interaction with code begins and ends with the source code control system, you have one view. When you actually are forced to see where the rubber meets the road in your customer, you think much more about the interfaces, the update processes, and the support code and scripts that get working code into working systems.

In the commercial space much effort and resources is applied in these critically important areas. With the journeyman programmers, this rarely if ever happens.

Most of the Apple distribution is Free

[flyingfsck]

It is only a small part of the Apple Mac software that is non-Free and you could even run Darwin which is Free. The bulk of the software on any Apple Mac is GPL.

Window managers

[buchner.johannes]

While this might be true for apps -- they change too much to settle on a thought-through UI concept, and new ones are constantly created for the same task by not so experienced UI designers -- I'd like to add that IMHO Linux has the best window managers out there. That is one of the reasons I don't use Windows and would put a Linux distribution on a Mac. Because I need to move and resize windows without finding the borders (e.g. Alt-click or Alt-doubleclick and drag). And I need sane virtual desktops for more screen space and for grouping my windows.
These are UI features lacking in non-open-source. Granted, it is not something the novice user will miss.

Re:Window managers

[Seth Kriticos]

Fully agree, and add to it:

And there is much more, like the middle button select pasting (you laugh once you realise how ineffective copy/pase is).

I also love the (non default) functions of compiz, like workspace and window overview zoom and application switcher (basically Alt-Tab) mapped to a click on one of the corners of the screen.

Workplace switcher mapped to a click on the edges of the screen.

And so on. Seriously, every time I have to sit in front of a Windows machine, my basic productivity drops 95% as everything is so cumbersome, slow and ineffective. Not to mention that it lacks a basic tool-set.

KDE is very usable

[Anonymous Coward]

I disagree with the premise that FOSS usability is always bad. I'm not a developer, I can't write code, but I use *nix exclusively for my home computers, running KDE. And they are WAY more usable than my windows computers at work. Small things make such a huge difference--with windows, when you move the mouse wheel, the active window scrolls, even if you have 2 open side by side. You have to click on the one you want to scroll. With KDE, the window that your mouse cursor is hovering over scrolls. This is so intuitive it took me a month or so to even notice. I've found all kinds of other small usability tweaks.

My KDE desktop at home is so much more usable and intuitive than my windows xp box at work that I often work at home just for the pleasure of using KDE.

Application specific expertise

[mevets]

Commercial applications have long separated the appearance and behavior of the application from the implementation for good reason. The obligatory strained car analogy, I like cars that are quick and responsive, but I don't want one made by an engine designer. No matter how talented the engine designer is, s/he will most likely make a car suitable for engine designers.

Balancing the viewpoints of "real world users", experts, and various designers is required to do it properly. Are all these sets well represented in the FOSS contributors?

Some good points in there

[mjeffers]

First corollary: Every contributor to the project tries to take part in the interface design, regardless of how little they know about the subject. And once you have more than one designer, you get inconsistency, both in vision and in detail. The quality of an interface design is inversely proportional to the number of designers.

This isn't necessarily true. It's true that great design is typically the result of a unified vision but design focused companies solve this problem by having a lead designer establish guidelines and standards that are then used by the team to create all the bits and pieces. You don't need one person, but you need one person in charge. For an Ubuntu, RedHat or OpenOffice where you have a corporate structure behind you, this level of design quality is achievable and I think they have it now. For a project of volunteers or a team that's widely distributed this has to be much more difficult.

Second corollary: Even when dedicated interface designers are present, they are not heeded as much as they would be in professional projects, precisely because they're dedicated designers and don't have patches to implement their suggestions.

Without the ability to write code, designers depend on an organizational structure that recognizes and values good design and will work to make sure that the end result meets the design goals you initially set out. This can fail in a non-OSS project and could succeed in an OSS project but a hobbyist project will probably never have a structure that allows a designer to do great work.

Another issue that I think isn't addressed here is that OSS projects are typically (necessarily?) started by people who can code. Once you have something running it takes a huge amount of effort to redesign away some of those early design decisions. You'll also forever be in a mindset that views design as window-dressing that gets applied to APIs. I'm not familiar enough with the history of OSS projects but are there examples of projects that started with a design process?

Re:Some good points in there

[Blakey Rat]

There's a little more to it than that.

It's not just that the projects are started and nursed along by people who can code, but they're started and nursed along by people who can code and also:
1) Don't know the purpose of a GUI
2) Don't understand the value of a GUI

There are tons of techniques that can be used, even by a programmer, to ensure that their program is more usable than the competition.

At the most basic level, they can follow all the UI standards of the OS/DE in which they're planning to run-- that one's simple, but it's completely missed by a lot of projects. If your program is running in Windows, and your font isn't rendered with ClearType-- it's a usability bug! Fix it! If you're running in OS X and pressing the down arrow on the bottommost line of text results in a beep instead of moving the insertion point to the end of the line-- it's a usability bug! Fix it! (And a very frequent one, since a lot of OS X programmers come from the Windows world now.) If you're not following all the standards of the OS you're running in, there's your starting point.

Secondly, every time you code something with a GUI, do a hallway usability test. This consists of grabbing someone walking by in the hall, and asking them to perform whatever task your application is designed to do using the new GUI you just wrote. The less that person knows about programming, the better-- you want normal users, not power users. The point isn't to assign a simple "pass/fail" to the UI, but to get their comments and feedback. Do one of those a day, and you'll hammer out 80% of the usability flaws before the product is even released. (Of course, this involves talking to other human beings, sometimes even *gasp* girls!, so I guess that's why it doesn't get done.)

Thirdly, understand the GUI. Discoverability, most importantly. Emphasizing the use of spatial memory, which the vast majority of non-geeks are better at than rote memorization. Understand how the basic widgets work, and why they work that way. (When you understand why widgets work the way they do, you'll hopefully have talked yourself out of "just write your own!" Writing a menu or listbox is *hard*. Writing an open dialog is *incredibly hard*.) Be able to answer the counter-intuitive question: "what five places on the screen can the user put the cursor on the quickest?" and learn why Macintosh menus are stuck to the top of the screen. Understand Mac Classic, which got closer than any other GUI to perfection. (IMO, of course. ;)

There's no reason any programmer can't do these things. They just don't want to. That's a whole different article, though, going way back to the woefully-obsolete "high priesthood of technology" attitude.

Random examples:

Just recently Slashdot covered a new open source FPS game. It's main window looks like this: http://schend.net/images/screenshots/alien_arena.png I can't even enumerate the hundreds of things wrong with just that one window. That the developers thought that UI was "good enough" to craft a *release* around... I don't even know how to reply to that.

Awhile back, I filed a bug against Notepad++ (a highly recommended-to-me text editor for Windows) because their menus didn't work. Their DROP DOWN MENUS. The ones attached to the top of the window. One of the most basic elements of a GUI, one that's been perfected for 20 years, and they don't work!! Again, I have absolutely no words for that.

At least use the updated version of MPT's article

[YokoZar]

Why link to the outdated version of Mathew Paul Thomas' article when he wrote a much newer one here: http://mpt.net.nz/archive/2008/08/01/free-software-usability Appropriately, it's titled: Why Free Software has poor usability, and how to improve it

Comment removed

[account_deleted]

Comment removed based on user account deletion

It isn't dirt work, it is conflicting work

[coryking]

UI design isn't dirt work; it is actually very fun and rewarding. The thing is it is hard to wear both a "UI Design Hat" and a developer hat at the same time. Why? The UI guy in you wants a usable UI and the programmer wants a usable codebase--those two goals are often highly conflicting. Good UI design often requires code that often needs to deal with crazy edge cases, or code that has to turn fuzzy human illogic into clean, elegant programming. If you try to wear both hats, the developer in you will fight the UI guy in you because the UI guy wants you to create a feature that the programmer in you knows will be a messy pain in the ass.

Once an organization gets large enough, you can have different people wearing the hats. This works great in an environment where there is a communication process for the two to talk to eachother. In the open source world, such communication channels typically donâ(TM)t exist--there is no process that has really been established. You might get UI guys dropping golden nuggets on the project mailing list from time to time, but you donâ(TM)t have the UI guy meeting up with the developers on a daily basis.

If you want the UI guys to be in on the party, the culture of open source development will have to shift to make use UI guys are not only included in the entire development cycle, but more important--they are seen as equals in the process. If the UI guys says "this design sucks", the developers don't implement it. I dunno if that is part of the culture nor am I sure how or if such a thing could ever be pulled off. UI guys get the props they deserve in paid jobs simply because there is a financial incentive to listen to them. Without that financial incentive, the only incentive to spend your time working on open source is the joy of programming. When you are doing programming for the joy of it, you donâ(TM)t want some UI guy (even if it you) raining on your pretty looking, well designed code :-)

Re:It isn't dirt work, it is conflicting work

[shutdown -p now]

The UI guy in you wants a usable UI and the programmer wants a usable codebase--those two goals are often highly conflicting. Good UI design often requires code that often needs to deal with crazy edge cases, or code that has to turn fuzzy human illogic into clean, elegant programming. If you try to wear both hats, the developer in you will fight the UI guy in you because the UI guy wants you to create a feature that the programmer in you knows will be a messy pain in the ass.

This is very true, and here's a very simple yet pervasive example of this.

If you want an UI that feels responsive, it should never, ever hang on any operation. Which means that all operations have to be pushed onto background thread/process, with all the synchronization complexity that it entails, and all the safeguards that you have to do to make sure that two conflicting actions aren't being pushed to background and executed at the same time. As an UI designer, you understand that, while the effect may be small and hardly noticeable, it does take away the nagging feeling of annoyance that inevitably comes up when working with blocking UI. But as a developer, you understand that code complexity will increase manyfold.

I thought so, too...

[SanityInAnarchy]

I bought a Powerbook, for that reason. I figured, I'd never run Windows on it, so may as well put Linux on the best laptop ever, right?

Didn't work too well. I never quite got it working, and just ended up using OS X.

In fact, from personal experience, the reason people choose Macs seems to have less to do with the overall UI, and more to do with specific things Just Working that Just Don't on Linux. Example: Maybe it's gotten better, and there's a nice GUI for this somewhere, but when I plug in a second monitor to my laptop, I restart my X server -- I could never quite get Xinerama or the nvidia stuff to cooperate without a restart.

Contrast this to a Macbook -- just plug it in, and it works. Open System Settings if you want it to behave other than as a clone.

So, I still use Linux, and I really don't get the people who would be into open source and use an iPhone, but I can certainly see why people would choose a Mac. Everything just works, just about all the commercial software you want, and a decent (not great, but decent) Unix under the hood for development.