Archive for the ‘user experience’ Tag

The Last Refuge of the Unimaginative Mind?

I am a creature of habit.  I like this because it keeps me efficient, which keeps me happy, which keeps my coworkers alive.

This is another situation in which I work the way I naturally live.

Consistency in Experience

When you use an app or a site, it usually only takes a few seconds or so to really get the hang of how to navigate and operate things.  If all of the navigation is on the side and suddenly a navigational element is along the bottom, doesn’t your brain kind of badgerget tangled for a minute?  Personally, it makes my face scrunch up like a little badger. 

Keeping navigational elements consistent is a real key in usability; your users will get used to how to work something fairly quickly if it’s designed well.  If you have even small inconsistencies that confuse them, they will remember that they had trouble with the product and you will get negative press and unhappy customers. 

Another key example of an easy way to be consistent in design/experience is to keep your Yes/No, OK/Cancel buttons in the same place.  Doing some acceptance testing the other day, we noticed that the Cancel button was on the right and the Accept button was on the left in one area of the app.  Everywhere else it was reversed.  This was caught pretty quickly because we kept hitting Cancel when we meant to hit Accept.  Your users will do this too; your app is so usable that they just fly through everything without paying too much attention and then….they hit a snag. 

And then they make that badger face. 

And so on and so forth. 

Keeping the minute details of your designs consistent will keep your users moving quickly through your product and minimize the amount of thought they put into their use of it, which equates to great design.

Consistency in Development

On our team, we have some things that are just standard.  Things like all grids should sort, all active checkboxes should be checked by default if a user is Adding New, case searches should be wildcarded, etc.  These are items that we already know to do, and therefore we don’t have to add a lot of noise to acceptance criteria with these little things.  Muddying up the spec will make other items of actual importance get missed, noise reduces signal, yadda yadda yadda.  These are items that we have just determined will be standard, and as we get new additions to the team we make sure that they get informed of them (even if it means forgetting and kicking a story back and then telling them).  As these conventions build up over time, we ensure that our stories always represent the essence of a feature and don’t have to waste energy or space on the scaffolding around them.

Consistency in Documentation

Just like with the Consistency in Experience section, users will get the hang of reading a manual/help file/on-screen info prompt/tooltip/etc.  I know that sounds kind of silly, but little things can really make a big difference in user experience.  If you go into extreme detail about editing a user account in one section of a manual and then only make a blurb about editing a user location in a later section, it might make a difference.  People’s eyes will search for what they want to find, and if they are used to looking for headers like How to Edit a User Account and your location editing “section” doesn’t have that? badger face like whoa.

Now for the real meat of this portion of our show: consistency in stories and tests.  Tests should be consistent in naming and consistent in organization.  People should be able to easily read through the muck to get the information they need.  Back in the day?  I could never have read tests.  Now that we’ve cleaned things up a bit I have some idea of what is going on and how things work/are organized.  I can tell what stuff is because of the items surrounding it, or by the way it is named.  It makes it much easier and faster for people to read if you are consistent in the way you structure your tests.

When I write stories, I like to lay them all out the same way.  The same things get bulleted, the bottom of the story says “Mockup attached” if that applies, things get formatted similarly.  For example, when something needs to be restricted, the first thing in the backlog item is some bolded text, before the story, that says Permissions: [Whateverthepermissionsare].  This is great because:

a) Developers will see that right away and know to build it in

b) It doesn’t muddy up the acceptance criteria and cause something else to potentially be missed

c) with this convention, if there is no explicit permission statement there, developers don’t have to guess if it needs it or not

(note: these things go for the “Mockup attached” thing too…they won’t look for an attachment if that’s not at the bottom of the story, etc)

Using ubiquitous language is extremely useful as well.  We had a doozy of a time on our most recent project trying to figure out how to separate lab accounts and client accounts in stories…eventually we came up with those terms (and a bah-zillion others), and now our developers never have to ask me what the hell I’m talking about.

Oh, and, of course, as a developer I want my stories to be consistent so that I can easily identify each element of them.  Heh.

Consistency in Code (written by Scott C. Reynolds because I don’t know enough about code but I do know that this section is important to this post)

Teams usually come up with conventions in coding, or coding standards, that define how the team will do things like organize code, name variables, and things like that. This is helpful in communicating intent and reaching collective code ownership. For instance, the team standard may be "all private members are named with a leading underscore". Then anyone in the team reading code that comes across a variable named _someVariable will know that it is a private instance member and not a local variable, and will know to be concerned with things like mutability. This cuts both ways, in that the benefit gained from following the convention is about equal to the damage caused when someone doesn’t follow the convention.

Some frameworks, such as Rails, are built on the principle of "convention over configuration". In trade for following certain conventions, you get increased productivity by leveraging things the framework can do for you automatically.

Conventions become a sort of "meta layer" of communication on a team when people are doing things the same way; whether it’s naming variables, sorting classes into certain folder structures, calling things the same thing (ubiquitous language is a convention, and bears mention somewhere I think), then it removes guesswork from the equation and focuses communication on problem solving rather than mechanical details.Some frameworks, such as Rails, are built on the principle of "convention over configuration". In trade for following certain conventions, you get increased productivity by leveraging things the framework can do for you automatically.Conventions become a sort of "meta layer" of communication on a team when people are doing things the same way; whether it’s naming variables, sorting classes into certain folder structures, calling things the same thing, then it removes guesswork from the equation and focuses communication on problem solving rather than mechanical details.

Consistency in…General

Oscar Wilde once said “Consistency is the last refuge of the unimaginative mind.”  I would partially disagree with this statement.  By being consistent with the overall structure and feel of things, you can exert your mental energy into things that really matter, rather than minutiae.  Consistency in these small things means you don’t have to think about them; they exist as quality without any extra effort and greatly enhance the usability of a product, the understandability of a story, the ease of modifying tests.

…but maybe he wasn’t talking about software, hmm?