I’m writing this entry some 30,000 feet above sea level, having just crossed the border
. In a little while (well, somewhere around an hour and a half) we’ll descend into
area, where the pilot tells me I can expect 90 degree weather.
If my battery holds out, I can write a proper entry that may be of further interest
to you folks. I mentioned a while back a post about video gaming and UX, and I think
it’s appropriate to dig into here now. The following is a bit of a rambling set of
thoughts, but it should provide an interesting discussion nonetheless. There’s a lot
more to say, but this will help get the ball rolling.
At the most basic level, videogames are like any other piece of software. They construct
a specific experience for users, have a set of goals and needs, and are built up by
bits of code that have things like semi-colons, parentheses and the odd dollar sign.
They also share a large heritage with the world of Entertainment – movies, books,
and the like. In straddling between the two, videogames give us a great opportunity
to recognize that in fact, what makes them entertaining is part of what makes software
usable and even enjoyable. That’s right: your software experience shares a bunch of
things in common with the latest rap album, art-house flick, or novel.
Now, clearly, that’s not a generality I am going to apply to the networking stack
in Longhorn – but it is something that applies to all my experiences, including the
ones networking exposes. That’s a bit abstract, let’s get to some examples.
I’ve been recently playing my way through the game Splinter
Cell again. One of the things I noticed as I took on the role of Sam Fischer,
super-spy extraordinaire, was how I became physically affected
by my experience. My hands got a little sweaty and my attention was completely on
the game (I missed my wife calling my name!). This is just a bit of software, running
on a bit of hardware, and yet I’m actually having these subconscious reactions to
it. That’s a pretty neat trick.
This isn’t any different than the moment you hold your breath in the big action flick
(“oh my gosh is he going to make it!”) or bust out into tears (“But he loves her!”).
In those cases, it’s all visual and aural (let’s leave the context of theatre out
of the discussion for now, but it matters as well), and in the videogame case we added
in a controller which adds another tactile level of immersion (and in my lucky case,
with force feedback).
The take away is: it’s possible to engage people on an emotional level without having
to actually put them into situations or have it be “real.” I am not actually a super-spy
(as far as you know), yet when I pick up the controller, I am literally playing in
Sam’s world. With software in general, we have this ability. In fact, we already do
affect people in emotional way today.
A simple example should suffice to explain. Ever tried to find some function or feature
in a piece of software you use? You know it’s
there, but you just can’t seem to find it. Maybe they named it something else? Maybe
there’s some system to it you haven’t figured out (“What if I hold down the Control
key?”). It’s frustrating, it’s annoying, and it produces cases of “computer rage.”
People scream at their computer, they make not-so-friendly gestures at it, and generally
unleash their emotions on it (or worse, on someone else – we’re human after all).
That’s software producing an emotional response. It’s not a good response
of course, but it is one, and powerful at that. This alone points out just how much
we can have an affect on users. The challenge is to make that an intentionally produced
reaction (much like reducing an audience to peals of laughter with well-timed comedy)
and a positive one at that.
Ok, so how do videogames fit into this? Videogames help bridge a lot of our understanding
between the world of Entertainment and what we do in software. Let’s take the Splinter
Cell example again. Clearly, as made-up entertainment, it puts you in highly unlikely
and highly unreal situations. At the same time, it creates an atmosphere of tension,
making every move seem meaningful, of drawing the user in and really making them react
to the situation, rather than sit back and think about it critically as some bits
running. (Users typically don’t do this, even when they are working on something and
thinking critically about it).
I believe a big part of this comes from the sandbox model of game play used successfully
in many games – think Splinter Cell and Knights of the
recently, or Mario64 and its predecessors (even Doom). At a basic level, the model
here is: create an environment for the user where the rules are easy to grasp, failure
is a learning experience and not a dead end, and the environment provides enough interesting
challenges to captivate the player. For those who’ve ever played Mario64, you can
certainly appreciate the first hour you spend jumping and running around before actually
completing any stages – it was that eye-opening and fun.
This applies to software equally. In Windows, we have an environment for users. Putting
aside how successful it is at these things, it is designed to easy to grasp, to have
failure not be an entire dead end, and to provide interesting things to do. Examples
are the task model to help users find tasks and do them (and it’s consistent across
the experience for the most part), the Recycle Bin provides one aspect of making failure
not be a dead end (deleted the file? Just get it back), and those same tasks provide
a set of interesting things to perform (same for the Start Menu).
In each of your applications, you do the same thing. Now, it is a little more complex
obviously than a game with 3 buttons. In fact, the challenge we have in modern software
on PCs is managing the 157 buttons – and balancing that with the sandbox above. But
when I’m in a given application, I have the context of the sandbox that is Windows,
as well as the context of the application itself. This can change depending on the
type of application I’m in and how effective it is. For example, in an editor app,
it tends to be sets of controls around one thing I’m working with – and I generally
expect most of those controls to work the same. When I’m in a navigation-based application,
or perhaps surfing the Web, I have a different set of expectations. The Web, in fact,
is absolutely fantastic at following these rules and applying them – and it’s one
of the reasons, I believe, for it’s continued success – easy to pick up and keep going.
Imagine if every website I went to had 100% different conventions or did not obey
the basic rules about things like links. (Just to digress a minute: this happens a
lot more than I’d like actually. Ever gone to a site then hit the back button and
it doesn’t take you back far enough and so you just reload the same page? How annoying).
So that turned into a bit more on other things we can learn from videogames, but I
want to bring it back to the emotion point. Emotion is a powerful part of who and
what we are as individuals. It’s also a lens through which all experiences we have
are filtered. For example, if you are already in a bad mood and something goes awry
on your computer, you are not going to be a happy camper. At the same time, when you succeed at
doing something on your computer (particularly if it was something you thought might
be difficult), you will be quite pleased with yourself – even proud.
This is nothing new of course. Emotional design in products is a relatively old concept
(if it’s had a few names over the years) and is well practiced by those most experienced
at supporting a particular brand. (We’ll talk another day about how emotional design
can be financially rewarding). But it’s something we generally do poorly in software
– either not recognizing it or not knowing what to do with it.
Videogames come in here. While not all videogames are useful to look at (let’s be
honest, a lot of games suck – but it has nothing to do with the genre), they do generally
show us where software has been used to tell a story (and I mean more than just text
here). This continuum, of piecing together the actions a user does in front of a computer
(or game device) is critical in the general software world as well – it’s how we maintain
and protect the experiences we want to build (and thus the emotions we want to evoke).
Plane has started to descend and they’ve asked me to put all my electronic devices
away – we’ll have to end this for now.
I’ll try and post within the next couple of days some ideas on how to make good experiences
happen, and evoke good emotions. For those at the PDC, I recommend you start by attending
’s talk, “The
New Windows “Longhorn” User Experience: Get Users to Fall in Love with Your Software”
and visiting the UX Lounge.
I’ll see you there.