tina_t

Sunday, June 12, 2005

Personas, Part 2

In my last entry, I wrote that personas are substitute, "fake" users and that they can be useful in focusing development on real users. Now it's time to find out how to write your own personas.

Research

Before writing a persona, you should do some research on who your users are.

Here's what you will want to know about your users:
* work experience (in the task domain of your app)
* education
* age
* gender
* computer literacy
* frequency of use of the app (or how often they do the task the app is for)

Another thing you should look at are the tasks that people will use your app for to find out what their goals in using it are.

But how can an open source developer find out something like this?

In a large company, which has enough time and money for this kind of stuff, you would be able to talk to the target users in person and watch them do actual work. This is probably not very doable for you -- but if you can somehow manage it, by all means do it, because it is really the best way to find out about your users.
So if you know people who have use for the app you are developing, grab them and ask them some questions. (But don't think you can just ask yourself because you need the program yourself, too. This will not work -- you are not your user and are too much encumbered by technical considerations to be able to think like a normal user in this case.) Also watch them work, either with a previous version of your app or a competing app. If neither exists, watch them do the task without the help of the computer.
The point of this is to make a list of things that people want to achieve by using your app - these will be their goals. You can find goals most easily by looking out for logical connections between actions that users make and thinking about what the goal of the combined actions might have been (you can also ask them, of course).

Another slightly more doable possibility is asking people your questions in a short web or email survey. But again, it's hard to find these people in the first place.

By now, you prabably have noticed that these usual steps that companies may take to research their target users are not really of much use to a regular independent open source developer without help -- so how can you cheaply and as quickly as possible get some information about your users?

I've thought a long time about this. What we did in the end for our project was look around the web to find competing apps and scoured their web forums and any other sources we could lay our hands on (newsgroups, for example) for anything the users were saying about themselves and how they use the app -- examples are stuff like "I'm a design student and I mainly use ... to ..." which yields info about age range (student, so probably in their twenties), (future) profession (designer) and what the app is used for (and also possibly gender, if the person has added it to his forum profile). Another example is "I'm just a hobby designer trying to make my own website".
Another good source are blogs. Look for the names of competing apps and see if you find people who write about them in their blogs -- what they like or dislike about them, for example. Blogs often also have personal info like job, age and location of the blogging person, which is very useful. If you've already released older versions of your app, you can of course search for references to your own app, as well.
Note that you will probably find only users that are web and technology savvy enough to actually have blogs or post to web forums, so depending on your app, they may not represent all possible users -- of course, if you are writing a blogging app, then that's perfectly fine ;). Another thing to remember is that if you want to ask people in the irc-channel of your app, you will probably only find very tech savvy ones (how many "normal" users know irc?) who should definitely not be considered as covering your whole user base.

The reasearch part is all for today, wait for more info on writing the actual personas in a few days if you're interested.

Wednesday, June 08, 2005

Personas, Part 1

Holehan and I have been working on our own small QT/KDE app on and off for a while now. In the course of our (not terribly far advanced) progress we've found the so called "persona" technique very helpful to focus our design efforts on the target user audience. And since I've written an article about the very same technique for our previously mentioned usability course (which, sadly, was not meant to be), I decided to translate my article to english and adapt it a bit so it shouldn't go to waste. It's quite a bit longer than your usual blog entry, but I think it's well worth it, because it contains a lot of knowledge I've collected from all over the place and I've not yet found someone who put all this together and fleshed out all parts of the process and not just some of them. I decided to divide the article into several parts so there's not too much text to read at once and also so I won't have to finish the whole article tonight ;). Today I will say a bit about what personas are and why they are useful. If you like this introduction, read how to make and use them in a few days :).

What are personas?

The concept of personas was first widely popularized by Alan Cooper in his book "The inmates are running the asylum" in 1998.
Personas are ficticious users that represent the needs of a larger group of users regarding the goals and personal characteristics they have. They are used as a substitute for real users, helping to make decisions about the design of an application. Personas help you to keep the focus on real users and their goals instead of thinking only in terms of the fuzzy ghost of the "average user" (who doesn't really exist.
To make personas really come alive, they are given plenty of bibliographical information, including a name, age, gender and also, very importantly, a picture.
Personas may not be real people, but they are based on knowledge about them - usually you do a bit of research about the target audience for your app before making the personas. That also means personas can't be reused for another project - they are tailored to the application they are written for and most probably won't fit for another one.

So what's the deal, why are personas so great?

1) They put you into your users' shoes and and help you focus on their goals:

As a developer, you often have a great idea for a feature for your app, but then find out later that your users only see the new functionality as additional distraction and clutter because they don't need it. Personas help you to put yourself into the position of your users and recognize what their goals really are, instead of keeping you guessing and adding random features they'll propably never see or use. Which in turn makes your interfaces less complicated and saves you the time you would have spent implementing a mostly unused feature.

2) They can resolve disagreements among the team:

Often there are disagreements in the development team about which feature is needed and which is not. These can often easily be resolved by refering to your personas - for example when someone in the team says: "What if somebody wants to print this out?" you can argue with "Peter is not interested in printing anything." (It is very important not to say "our persona" in sentences like this, but to at all times use the persona's name, otherwise you will never take it seriously enough. Always talk about "Peter" and resist the urge to generalize him.)

Read on in a few days to find out how to use personas yourself - and don't forget to visit the OpenUsability booth at LinuxTag - read Ellen's blog entry to find out more!