This is not my idea but since Joakim hasn’t blogged about it, I almost feel obliged to.

Some time ago Joakim, Tobias and myself where discussing and giving each other feedback on three upcoming lightning talks we wanted to present at the yearly Agile Sweden conference. Joakim had come up with a topic that had a lot to do with bugs, errors and mis-functionality that the users of a computer system has to deal with.

In his excellent talk Joakim ended up introducing a word ‘Felyta’ which roughly translates to ‘Error surface’ or ‘Error area’, The word doesn’t translate very well in my opinion but the concept is universal. I will try to explain it and then add to it.

The severity of errors

fig. 1

All old, new or changed functions that reach end users has the potential to either wreck havoc or add value and we often hope it’s the latter. If the software doesn’t act the way we want and causes us trouble we want that remedied quickly and the effects of the errors caused reverted equally fast.

Most users of software has at least one experience they remember where the software has gone crazy and caused a lot more grief and damage than the same manual process ever could have. We take working software for granted up until the point where the execution speed of software reminds us that it is really a double edged sword. The effects of error is something we want to minimize and we try very hard to reduce ‘being wrong’.


Take a look at the graph fig. 1. It represents the unwanted effect of the new release of some new sofware where an error was introduced and then remedied.

Different errors, different effects?

fig. 2

Very severe errors are usually taken care of fast because we hate being wrong and in a state of uncertainty. But what about those nagging mis-features, how are they handled? A common pattern are services releases, fixes that are lumped together in a batch fashion and delivered when they carry ‘enough value’.

The next picture, fig. 2, illustrates how a less severe but still unwanted effect adds up over time. From the illustration it is easy to see that the effect in the long run is pretty much the same as in the former case. The blue areas are roughly the same size in the two graphs and the only striking difference is in their orientation.

It’s the product that counts

fig. 3

Instead of looking at unwanted effects on one dimension — more or less severe, I suggest we start describing its effect as an area. They are a function of severity over time, not just a value. This model of how unwanted functionality effects our users and business is more powerful and closer to reality than just categorizing unwanted effects as more or less severe to have in production. It is the total area that counts, the error area or maybe we can call that product ‘Risk Area’.

If we agree that the area is more important than severity alone, we are also in a better position to generate a options that can reduce the effect of our future mistakes.

More on generating those options in the next post. ‘Patterns for reducing Risk Area’

Advertisements

About Ola Ellnestam

Agile Coach, Systems developer, Agile Practitioner and father of three.

3 responses »

  1. The concept of a severity rating is also used in regard to usability problems (a set that also bugs belongs too, of course), where we look at the frequency, impact and persistence of a problem. That sounds very similar to what you describe in this blog post. The old Jakob has written about it here: http://www.useit.com/papers/heuristic/severityrating.html

  2. […] this previous blog the concept of risk as an area was introduced. The area is the product of ‘severity of […]

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s