Jeff On Games

So this post has nothing to do with games, and more to do with just real world usability of applications. It's a rant I've been talking to people about for a while, but I decided to get it up on my blog for people to discuss in the greater cloud of the web. Generally, the post is about the battle between Microsoft, Apple, Google and Open Source. Not from a doctrine perspective, but entirely from a usability perspective.

The Apple Approach

So, without a doubt, Apple has some of the best usability in the market. There are lots of reasons for this, but the one I want to focus on is their tight application integration. Apple products understand other apple products really well. Syncing an iPod or an iPhone through iTunes is ridiculously easy, because it's designed to be easy for 90% of the customer base. That's why people use it. And no other company can control the hardware and the software the way Apple can.

Then there's the other 10% of the customer base. People like me that would rather use other applications to sync their music collections to their iPod or iPhone. This is where Apple fails. In an attempt to make sure that you always use their software with their hardware, they've unnecessarily (and sometimes very purposefully) obfuscated the way an iPod sync works. Certainly, certain products can do it, but from my understanding these products have reverse engineered the iPod database, and this reverse engineering frequently breaks when Apple releases new versions of their firmware.

Now, Apple has a good reason for this. They want things to be as simple as possible for the 90% of people that own or want an iPod. But what they don't do is make it easy for the other 10% that want an iPod, but have use cases outside of the bounds of what they offer.

The iPod / iTunes integration is just one example, but Apple does this all the time. Very rarely does Apple offer a product that communicates in a standard way unless that standard is so ubiquitous that they have no other choice. So Apple is tightly integrated, with no loose coupling.

The Open Source Approach

Open Source has the opposite approach. Loosely couple everything and have the programmers sort it out. This means, a lot of the time, that the average user is completely screwed. Figuring out how to get two systems to talk to each other in the Open Source world generally requires some wicked voodoo magic. Everything understands everything else, but only if you're really careful and tell them where and how to contact each other.

Now, this is a blanket statement, and I know many applications have improved in the Open Source world concerning this, but the problem is that when you allow everything to communicate freely, you lose any possibility of creating a reasonable user interface that would have come about through two products having tight integration. It's great that every open source calendar product understands iCal, but if you can't get them to communicate easily, what's the point?

The Microsoft Approach

Now, Microsoft is interesting because it's schizophrenic when it comes to integration. Individual Microsoft products are tightly integrated with a strange variety of loose coupling (or at least have been in the past). Applications like Office, Windows Media Player, Visual Studio, and others, are very tightly integrated with themselves, and they offer the options for extension and integration with other applications, so long as you're working within a very tightly confined area that Microsoft has defined.

This is basically Microsoft's history: offer a lot of developer support and allow extensions for almost everything you do, but only so long as they're developing for your platform. Only in recent years has Microsoft opened their data exchange systems so that applications outside of the controlled Microsoft environment can potentially understand what's going on.

The problem is that outside of a single application, Microsoft doesn't integrate with itself at all, and depends on third parties to offer features that are prominently displayed in Apple software. Is this bad? Well, for the average user… absolutely. Say, for example, that I want to order a set a pictures from an album I've made in my favorite piece of photo software, or let's say I want to publish them online. This can easily be accomplished from both Microsoft's offering and Apple's offering. The problem is that Apple has an offering that it owns and prominently displays as an option. Microsoft, on the other hand, would allow you to sync to any number of picture website systems, but you'd have to do some searching. The average user can't be bothered with that, and even if they could, the number of options is way too overwhelming. The average user is more likely to get confused than actually published their pictures online.

In my opinion Microsoft's approach to letting 3^rd parties integrate into (almost) any piece of software they make is the "better" option, as it encourages independent development. The problem is that it only really helps power users, and hurts their general interface design. So, with Microsoft, you don't get the benefits of either the tight integration or the loose coupling.

The Google Approach

Just when you though Microsoft was schizophrenic, along comes Google. Google boasts over 13 products that integrate with your Google account, and they… well sort of, kind of, not really integrate together. Mail allows me to look at my documents and calendar (through a Labs extension), as well as allows me to add information to my calendar by detecting information in emails. But the whole system feels very disjointed. More importantly, the communication protocol between the applications is proprietary and hidden (so far as I know).

Things become more interesting when you talk about the new G1. Here's a phone that's based on an open standard for communication between applications and wants them to behave like they're tightly integrated without using tight integration. But apparently the first thing the G1 does is force you to sign in with a Google account, something you can't change. What if I want that phone, but not a Google account? Really, what was the point there?

The problem with Google is that it offers a lot to users in weird chunks. There's no unifying vision like there is with Apple, and its developer support (at least for its applications) is spotty. So you don't get external extensions and you don't get tight integration. It's the interface of any given application that draws you in, but is anyone really happy with how it works beyond that?

The End All Problem

This all comes to a head in one way: the management of your multiple personalities. My name is Jeff, and I have 3 identities on the internet: Jeff as employee and co-founder of Orbus Gameworks, Jeff as an IGDA volunteer, Jeff as just me. In some places, I want to have access to all of these personalities at once (say on my phone). In some cases, I want to share just select information with other people. I want to share my business calendar with my business associates, for example, and I want to share my personal calendar with my friends. I want my phone to have access to all my business contacts and personal contacts, and sync them to the proper places, and I want my music to stream be able to sync to my home computer and maybe my work computer without issue.

The problem with tightly integrated software is that it either can't or doesn't understand this concept. You are you regardless of what you say. The problem with loosely integrated software is that you don't get the usability of power of integration. You have to play the game tight and loose. Tightly integrate across platforms and across communication lines while communicating via loose protocols that anyone can understand.

Will this ever happen? Who knows. The problem is that each company has to fight significant hurdles to make a tightly integrated, loosely communicative application suite. Apple has to open up communications and fight against their urge to make integrated suites. Microsoft has to integrate more, communicate more loosely, and become less schizophrenic when it comes to application design. Google has to decide what they're doing, and Open Source has to get some user interface designers (seriously guys, you're killing me). It's an uphill battle for everyone.