I hate skins and I love native GUI widgets. Microsoft and Apple had a relatively strong set of user interface controls that people are familiar with. Yet loads of developers seem keen on reinventing these devices from scatch. Media players seem to be particularly bad at this. Microsoft’s own Windows Media Player and Apple’s own QuickTime Player both seem to throw out the entire GUI toolkit and start from scratch, building totally confusing (and totally x-Treme) interfaces.
A good user interface should get out of the way. Particularly an interface for an application that delivers content (show us the content, and get out of the way). If you want totally x-treme, you don’t upgrade your media player skin – you download Limp Biskit videos.
When the Mozilla project moved to create their own cross-platform GUI toolkit, many people who were concerned with the user experience cried foul (including myself in this January 2001 rant about skins, and this August 2002 update). The idea struck me as the result of developer-centric thinking and complete disregard to the end-user. A cross-platform GUI would make things much easier for the developers, and a bit easier for the minority of users who work on multiple operating systems, but it isn’t much good for Joe-Windows-User.
Here we are, three years later, and I think they may have been onto something. First, let me be clear that you should always use the available operating system native GUI widgets when you can. Chances are the alternatives you will develop will suck.
Mitch Kapor’s Open Source Application Foundation has chose to stick with native GUIs on their Chandler application. This is a smart decision. Most skinned application suck. Trillian would be a great instant messaging program if it weren’t for the over-skinning (that said, I do use Trillian as I find it to be the best of the worst).
Put the UI in my hands
Enter XUL (pronounced “zool”). XUL is the XML User-interface Language developed by the Mozilla project. It allows developers to define the user-interface of their application using a combination of “off-the-shelf” standards (primarily CSS and JavaScript). The end result is a relatively accessible architecture for interface design.
XUL does to the user-interface what View Source did to web development. Though I have the advantage of a web-development background (familiarity with the key technologies, like CSS), I can do things to a XUL-based app that I could not do on other applications. For example, I found some of the icons on the toolbar of the Mozilla Firebird browser to be poorly designed – so I replaced them (this was as easy as saving new PNG files and dropping them into a .JAR file). The search box was too narrow – so I made it wider (this was absurdly easy).
These may seem like insignificant examples, but it opens up a level of control over the application that is not possible with other design methods.
It’s about quality and consistency
Another key development that has softened my stance of Mozilla’s break from the OS native interface is quality and consistency. Microsoft has been squandering their lead. The quality and consistency of the Windows GUI has been deteriorating rather than improving. Microsoft has also devalued their native Windows interface by allowing it’s own applications, including their media player and the massively important Office suite, to shirk the standards.
XUL, meanwhile, has gotten much better. The software is constantly improving (and incorporating native OS widgets where appropriate – which is a nice touch). Performance is no longer an issue on newer hardware. Where XUL-based apps might have taken a performance hit compared to native Windows apps, the difference is insignificant on recent hardware.
The Mozilla Firebird browser project shows that XUL can be used to develop a quality interface.
Will the operating systems rise again?
I should note that Apple’s OS X may be an anomaly in that the quality has actually been improved over previous versions of the OS. Regardless of your opinion on the style of the OS, it is clearly well rendered. Microsoft is planning on following in Apple’s footsteps by having DirectX handle the desktop GUI in the same way Apple is using OpenGL. There is a chance here that Apple and Microsoft may leap ahead of other interface systems. However, I think it’s more likely that developers of XUL will tap into these improvements than be left behind.
Platform Freedom and Platform Friction
In 1997, Netscape’s Marc Andresen claimed that:
“[b]rowsers will reduce Windows to an unimportant collection of slightly buggy device drivers”
If anything, it is XUL that has the power to do this. I originally thought that the ability to develop applications that run on multiple operating systems with relative ease wasn’t much good, since the overwhelming majority of computer users are running only Microsoft Windows. However, after my recent stint on a Mac for a week and having switched from IE to Mozilla Firebird as my primary web browser, I’m starting to see something more significant going on.
A friend of mine pointed out that for the average novice Windows user to switch to an alternative operating system, they would also be forced to deal with an entire new set of applications. However, if Mozilla Firebird becomes your primary web browser and OpenOffice.org becomes your primary office suite, the platform friction is greatly reduced, as these applications are available on other operating systems. Web-based services and applications are another layer that can work well on any OS. Once you’ve got Johnny windows user into his Hotmail account, he doesn’t care if he’s running Windows 98, OS X, KDE, or Gnome.
But I still hate skins
I do still hate skins. I dream of a simple media player that uses native GUI controls. I hate that every new version of Microsoft Office includes redesigned menus and toolbars. However, in the accessibility of XUL, I see a small example of how the wall between developers and users can be torn down.
More info on XUL:
This here, then, is the most significant aspect of Phoenix/Firebird’s ascendance, which wasn’t discussed below your recent Firebird post, Steven: Firebird proves XUL.
Firebird will be ported to all platforms. It injects itself — disguised as a browser — as a stealth development platform within systems of all types. Apps are written for it. Firebird is the local XUL interpreter, so interfaces are platform-consistent within the XUL-written design. More screen time is spent within Firebird than is spent using formerly popular tools. Folks are buying only as much PC as they need.
OSes that give Firebird more processing room are favored; bloated ones chewing cycles for their own, unknown purposes are disfavored. Today’s OSes become more like smart shells, and eventually come to think of themselves that way. Commoditization is splattered everywhere. Fourteen-year olds are writing XUL-fronted apps in pHp.
This is a flight of fancy, maybe, but it raises an important tangential question for me: What if the browser inevitably is part of the OS? What if Microsoft truly didn’t tell a lie of the mind to U.S. high courts?
LQ
ps. Steven, the benefits of openness and standardization compete within me fiercely too. I think the next generation, bottom-up, platform independent interfaces we’ll get to evaluate soon will produce better de facto standard interfaces than today’s platform-specific, top-down schemes do — whatever one’s current preferences. Standards bred of openness, freely anointed and deposed.
Seems to me that SilverOrange is already onto this.
Bam! Right on, Lou.
From web application to application web.
The next step, it seems.
I am not sure I agree with you. I rekon non-natives GUI’s will become more and more prevalent and if are done right should be intuitive. Take for example if you will the web, already its given us a plethora of GUI’s. Some of them terrible, but some of them quite easy to use, and just make up the landscape of the web.
I don’t think the web is a very good example of what you’re trying to say. The web may have a wide variety of designs, but it has a very small and simple set of GUI widgets. The fact that these same simple controls are used on all websites is a primary reason why the web has become so pervasive.
Good design is only part of what makes an interface intuitive. The other part is an understanding in the mind of the user. This part is based on past experience of the user and is out of the direct control of the interface designer. Since past experiences vary among users, what they find intuitive will vary too.
Common interface widgets eventually result in wide user experience. When this is combined with good design, interfaces can become intuitive for the widest possible cross-section of users.
“I dream of a simple media player that uses native GUI controls.”
Open Start > Run and type mplayer2. There it is.
Winamp anyone? what’s a minibrowser for (except security holes). sorry.
I hate skins + the bulk of winamp, so since xmas i have been working on a mp3 player thats uses the nullsoft in/out dlls (so sound quality is the same) but has no skins and is comprised of various interworking .exe’s. This means that when your mp3 player is sitting in the tray thats all thats sitting there – just the player – no gui – no config screens (except the ones in the damn nullsoft dll’s 🙂 ) email me if your interested in beta testing it (it’s free).
If i see enough interest i’ll set up a site @ sodnpoo.com/noamp
Lee Bowyer
noamp_dev@sodnpoo.com
“Open Start > Run and type mplayer2. There it is.”
Better still, get Media Player Classic! http://www.gabest.org/mpc.php
“I hate skins + the bulk of winamp, so since xmas i have been working on a mp3 player thats uses the nullsoft in/out dlls (so sound quality is the same) but has no skins and is comprised of various interworking .exe’s.”
Have you tried foobar2000? I love it, myself.
http://foobar2000.hydrogenaudio.org/
VLC (http://www.videolan.org/vlc/) is also a very nice, plain jane (and cross-platform!) media player.
Hi Kids,
Just thought I’d say my piece about GUI(s).
As with everything else nowadays, they get
complicateder and complicateder. Software
developers like those in other engineering
disciplines have lost sight of, and could’nt
care less about the KISS rule which states:
“Keep It Simple Stupid”
Until this rule is re-discovered, dug up and
dusted off like an old engineering tome;
software will continue to grow fatter and
fatter until not even its programmers can
wield it. They will continue to throw ever
faster hardware solutions at it in order to “fix”
what should have never seen the light of day
in the first place…
Doing GUI’s over browsers are like dancing elephants: people care less about the quality of the artistic expression than the creature dances at all.
If all you are going to do is a few images, buttons, and list boxes, I suppose XUL is the way to go. But if you are going to do some fancy real-time graphics (games come to mind — can you imagine doing a 3-D first-person shooter game over a Web browser?), the only way to go is client-side, and if your Longhorn link is any guide, the client-side is a moving target in terms of what it can do.
My interest is in the visualization of scientific data, and I would like to have some kind of platform-independent Web browser-hosted thingy, but it seems that these Web systems are a long way off.