Full experience

One of the things I wanted to talk about more was what I think does matter about the desktop, which is the total experience and how it relates to branding. People with extensive computer experience have a significantly better understanding of the individual components in a system (though they can and often are wrong of course about details), but the problem is that this leads to a different experience than someone without that understanding.

A specific example I’m thinking of here is the Java updater on Windows. I overheard one Java developer expressing surprise that someone they knew without much computer experience thought Java was a pop up. Now you may laugh, but really, they’re not wrong. The pop up is their total experience. People with the computer knowledge know they need it to play some online game, or they don’t. They know it’s from a different company, and added on by the hardware vendor, or that the pop up is a tiny piece of a much larger system. It ends up being a very different brand.

Speaking of hardware vendors and brands, this brings me to Windows itself. I’ve kept around a Windows install on my PC for various reasons, among them that I like to keep up to date on what’s happening in Windows land and be able to carry on an intelligent discussion about operating systems in general (not that you can tell from some coffee-fueled rambling blog posts), and also because I’ll probably have to work on porting GObject Introspection to Windows (pure pain) at some point. So here’s the problem with the Windows brand, and I think Microsoft is catching on to this – you’re carpet bombed with it in your interaction with the system, and it’s associated with very good things, very bad things, and everything between. Some things that are Microsoft’s fault, and some things that aren’t.

I was browsing the menu one day and came upon a Windows Dancer menu item. Microsoft made this, associated it with the Windows brand, and shipped it. It boggles my mind. Did you know that 29% of Windows kernel crashes are caused by NVidia? Except here’s the problem – it just says “Windows crashed”. So the user is going to associate that crash with the Windows brand, even though it it’s really not Microsoft’s fault. By far my favorite though is the Dell Dock. Definitely a lesson there in letting hardware vendors do arbitrary things to one’s OS.

The point here is that the design and experience of Microsoft’s core system (or any operating system) in a vacuum are far less relevant than the total experience of someone who just gets a computer. And this I think is actually a strength of the free software operating system, for a few reasons. Following the “rough consensus and working code” approach inherently avoids the worst things. If someone proposed a Message from your mouse vendor pop up in GNOME, we’d just laugh. Second, because we’re fundamentally cooperative, there’s less tension about replacing higher level things that people try to add on top. If memory serves correctly, for years Windows didn’t ship with an unzip utility in the core OS, presumably because of concerns about undercutting Winzip. We’ll never have that problem.

A bit more on this later, and how it relates to a feature I’d like to work on for the shell.

Uncanny valley? I don’t think so.

So Henri Bergius discussed John Gruber‘s claim that the free desktops are in an uncanny valley. Let’s leave aside the obvious bits that 1) desktops are absolutely nothing like robots trying to be people, and 2) clearly the fundamental basis of the uncanny valley is the “Pathogen avoidance/mate selection”, since in the tenth of a second it takes for your reaction to form, you obviously don’t have any time to ponder “Western constructions of human identity”. Given that people don’t get pathogens from their computer (unless you’re using a public internet terminal) nor attempt to mate with them (no comment), the uncanny valley isn’t very useful as an analogy.

That said, it’s amazing to me that John managed to go on for so long about operating systems in general (not just desktops) without mentioning the most important point about them. Actually, really the point, which dwarfs all others. That is:

To run the applications you want

Now, don’t get me wrong. There’s a lot of details about desktop operating systems that are important; more on this in a minute. Obviously, a web browser is essential, but that’s a commodity. Now, I don’t want to get into a debate about exactly what percentage of people can be fully served by solely a web browser, but let me just note that for a lot of people, especially ones with overseas families, Skype is still a killer app. And you can’t write Skype in the default web security model (which is the relevant bit here, not a missing-the-point debate about AJAX versus platform widgets).

Continuing on the subject of the uncanny valley, clarkbw told me a while ago there’s been HCI research to the effect that people are not generally too troubled by visual differences. Consider for example the evolution of the Start menu; it looks really different between each of Windows 2000, XP, and Vista, but generally people don’t have a problem with that. However what they do have trouble with is something that looks similar, but does something completely different. A good example here is how in the default GNOME panel configuration, we ship the “make all your windows go away” button in the bottom left. Kind of a bad idea, one that will go away with the shell design.

But in general, I don’t think the problem has anything to do with an “uncanny valley”. If we’re talking about the consumer space, basically people just use the operating system that came with their computer, until it’s time to replace the computer. Overcoming this is I think largely a business problem, not a desktop interface problem.

So on the subject of looking like Windows in the context of GNOME, my take is that it is important to look good and be functional, and having a distinct visual identity is important – but – keep in mind:

Given that data, considering that our target market is, like Windows, general purpose computing, it makes a significant amount of sense to consider issues that occur during transition and what the expected target audience needs.

What did I mean by “general purpose computing”? Well, it’s a big world. Think of scientists and engineers using Scilab, or all of those fixed-function registers that currently run Windows. OLPC-type projects. Content creators who need to edit video. System administrators and developers (count me as a skeptic of editor as a service).

What about targeted “netbook” operating systems? There is definitely a large number of people who only need a lightweight computer. I think the core desktop should adapt automatically to those kinds of conditions; for example, you should be able to drop bits of GNOME you’re not using (say Evolution), and the panel should adjust Ubuntu Netbook Remix style. There’s definitely a place for Moblin type specialized interfaces, and as long as they’re generally compatible with the general purpose OS. Concretely, if say Skype has to rewrite or do significant work to adapt their app, there’s a problem. But regardless, if Moblin achieves its goal of being shipped by hardware vendors on netbook hardware regardless, it’ll be a huge step forward.

Now, different people have different visions of where the GNOME Shell should go, and that’s healthy and fine. To an extent these different visions can be accomodated by different means. Ideally of course, we fix the problem in the default design. But failing that, it might work as a Firefox-style extension mechanism that we want to add, a separate project that builds upon shared infrastructure, or automatic interface adjustments like the netbook screen size one I mentioned above.

But you can count me as believing that it makes sense to be sure that the apps you use today continue to work, while achieving the goals of making GNOME look nicer and more interactive than two grey bars, and fixing the obvious problems like poor access to your recent files, no application search, etc. Some of this we’ve done already, but there’s a lot more to do. If you’re interested and able, it’s pretty easy to dive in to the project!

Further awesome

So earlier I raved about how Firebug is made of awesome. One of those Free Software projects that just saves you massive amounts of time as a developer, and really raises the quality bar you expect from tools.

There’s one other project I should have mentioned earlier in this category, which is Valgrind. I’m sure nearly all Planet Fedora/GNOME developer readers know if it (though I was surprised there were still people not using Firebug), but Valgrind almost makes you feel like if it was a bit smarter it could write the code itself, and you could kick back on the beach and watch it.

But besides praising Firebug and Valgrind, I wanted to link to ANTLR as also raising the Free Software quality bar. Now, probably a lot fewer programmers have the need for a parser generator than need to debug HTML/JS or C, but I have to say – if you need a parser, ANTLR is also made of awesome. It’s not just that the parser generator is powerful, documented etc. What definitely takes ANTLR a notch up is that it actually comes with a custom IDE for writing and interactively debugging your grammar. All Free Software, and pretty sexy too (Though sadly the screenshots are on a Mac). I also started using another nice Terrence library, StringTemplate in a project recently, which is what motivated this blog post.

Are there any indispensible tools or libraries that have really impressed you lately?

Not in DOS anymore

I have to say, this app makes quite a jump from their old DOS-based UI. I would have no idea how to use it, but I’m sure it makes sense after you get training. Good to know one fewer company’s custom app is not tied to MSDN and Windows anymore, moving on to Free Software. I wish I could make applications look at that good.

And life gets a little better

You know the feeling. You’re happily sitting there, coding away at some graphics or other code in C+GObject, and then comes the point where you need to add a signal to your object. But your object doesn’t have any signals yet, so you have to go find and copy the boilerplate. Ok, not a big deal, you say to yourself, it only takes a minute or two. Then you notice your signal takes multiple parameters, and thus you need to generate a marshaler.

At that point you go to add one to your foo-marshal.list file, only to realize you don’t have one yet! Now you need to copy a chunk Automake boilerplate, and apparently if you want to do it really correctly it involves three times as much boilerplate involving stamp files and other monsters.

It’s around this point you’re probably thinking that finding medieval torture devices and using them on yourself on live television would be a less painful remunerative occupation than programming. But there is hope – the awesome jdahlin wrote a patch. The problem – it’s not in GLib yet, and it’s unclear when it will be.

So maybe you don’t buy into the the pitch about polyglot applications yet, but the new GObject Introspection release, because it already depends on libffi, contains a slightly tweaked version of jdahlin’s patch, known as gi_cclosure_marshal_generic. Depend on introspection, and never deal with marshalers and other torture devices again!

From Here To There

From Here To There is a quick introductory tutorial for people interested in building multi-level applications using the GObject stack, and having your own application be split between C and your choice of runtime. This tutorial uses Clutter and JavaScript, as we’re using for gnome-shell.

I’ve been working for a while now on two applications using the system (gnome-shell, and a personal project not yet ready for announcement), and while there is still a fair bit more introspection system work to do, so far I’m pretty happy with how it’s worked out for both projects. My personal project is actually a mashup of C for some graphics and system stuff, Java (JGIR) for the core application logic, and Groovy for some scripting and extensions. It’s quite polyglot; I’m practicing what I preach.