Mark Shuttleworth: Less is more. But still less.

Anyway, i dream of a day i dont have to google a workaround for something that does not work as is supposed to...

Those Ubuntu papercuts are important for the user experience... and 100 are not enough. We already have enough new features, what about fixing what is not working properly instead of reinventing the wheel?

I disagree strongly. Just because the current default is crappily organized, doesn't mean we should just *throw everything out*, especially things that are ASSUMED to be there by applications (and users!) like the system tray and task area. A frequent mistake is assuming *personal preference* is a good universal default (or worse, only useful feature set), especially by highly technical users (since they're the ones that can easily adjust the defaults).

>I think looking how the best smartphone OS:es does it is
>the way forward. Be inspired by for example, N900, iPhone
>and Android. A few consistent status icons and so on.

>We need to drop the Windows 95 mindset about UI:s on desktops.

Interestingly enough, I find that the current smart phone OSes look a LOT like Windows 95. You have the 'taskbar' (displaying time, and the 'system tray', maybe more depending on the OS), except it's at the top instead of the bottom of the screen (in the style of Windows CE) which is always visible (except in a few full screen apps). Then you have the 'desktop' with the icons (i.e. springboard and other equivalent), which is always covered by your windows... which are always maximized.

If anything, smartphones are a RETURN to Windows 95 (previous generations were a return to Windows For Workgroups... should be getting Windows 98 before too long... hopefully the pattern won't hold enough to get Windows ME!). IMO, smartphones are as true as you can get to the current desktop metaphors but with the current technological constraints of the platform, and by NO MEANS innovative or a new mindset (w.r.t. UI metaphors, at least).

---

One thing, though, that I think smartphones have been much better about than desktops is in effectively using transitions and animations. Simple, fast transitions (with '250 ms' being borderline, and probably 50ms being the fast you can get with actually having it perceptible... 100ms probably being a good midpoint).

Transitions/animations are something that I think follows the 'less is more' (or 'less is better') mantra, unlike UI layout. People tend to make the mistake of a little animation being good, so having MASSIVE HUGE ANIMATIONS is awesome... and that results in power point presentations where the letters fly from all over the screen on every single slide (a nice rule to follow: if a member of the audience can walk up to you and punch you in the face during your transition, then you deserve to be punched in the face).
Staying with the powerpoint analogy, having *no* transition effect at all can be fairly jarring (even if we just accept it- because computers aren't natural!), and would often be easier to miss. On the other hand, having a very fast and non-flashy transition (I'm personally fond of the direct fade) can make it feel far more natural while not wasting the audience's time.

As you said, an application's developer by their very nature is going to do a horrible job
evaluating the UI, since they've spent too much time staring at the internals, as well as every
iteration of the UI, and generally having a drastically different mindset than most of their
potential user base (except for aaplications meant for just other devs).

This is the reason why it's good to segregate the internals and the UI. Something like Qt's
QUICK (declarative UI, state machine frame work, a markup language, and a grapical editor
for all of those that's far more capable than QtDesigner & Glade) should make it easier for
'UI people' to modify the interface, and even do usability studies with seveal different layouts
without being too dependant on the coders.

To spot a bad programmer is simple. Tell him "I've been very productive today, I deleted 2000 lines of code" and looks if that makes him smile.

UI design is hard (just as many things are hard— kernel design, glibc internals, etc).

Most of those things, however, are fairly opaque to outsiders. Random fools don't think they can handle them— they haven't a clue even where to begin.

With UI design, however, lots of people think they understand it and the people most willing to push their expertise onto everyone are the ones that really are the least qualified. (The qualified people realize that its _hard_ and that there are no singular black and white one size fits all solutions).

Worse, not are we surrounded by all these self-appointed experts eager to push their bastardized vision of the one-true-way on everyone, we simply have no idea how to tell good UI design people from bad ones and because there is no one solution (see above) any change you make will cause lots of screaming, so we can't tell that our UI designers are bad by the screaming.

It's a mess. In the absence of a real ability to find UI specialists who are objectively better than something else I'd rather just leave UI design to the developers. If they get it _too_ wrong users will yell until its fixed, and at least we know that someone who uses the package is happy with the UI.

Uh, here in Portland Oregon where I live, "the average kernel hacker" who thought they could manage such a circuit would probably do about as good a job as "the average electronics engineer". I can think of four local kernel hackers off the top of my head who could design the circuit in question without too much difficulty.

"You would not want the guy that lays out the traces for your motherboard to be hacking on glibc."

Huh? How do you know? One of the cool things about open source is that folks contribute mostly according to their abilities rather than their credentials, and their work is judged mostly on its technical merits rather than its pedigree. If my circuit-layout engineer contributed to glibc, I would be cool with it if it looked like good and useful code.

The real problem with programmers or anybody else as "UI designers" is that IMHO *nobody* "knows how to do it". The only objective criteria I am aware of are properly run user studies, and I don't believe that we have enough data from them to design a UI that we can be confident will work well overall before we test it. Over 30 years in this business, I've learned not to trust anybody's pronouncements about a UI design unless I see the post-design testing that justifies it.

Apple is still the king of UI design, not because their UI designers are that much smarter (they've made some IMHO hideous decisions over the years and right into the present), but because they do more and better testing of their designs than anyone else I'm aware of.