The Stickering

Experience Reports, Software Testing

‘The Stickering’ is a loosely managed, session based, reporting-and-guiding tool for your (user acceptance) testing. Feel free to adapt and use this for your own projects. The explanation given here is how it was integrated for a particular context.

Context: Exactly one year ago, I and a few other consultants were hired to help transform the current process of deploying and developing directly into production and hoping nothing blows up, to a more closely managed process with more safeguards.
In addition, the complete software application now in place would be recreated to a more modern technology. This meant: new process, new technology, new infrastructure, new people, old business processes with new changes. All this, under heavy set deadlines.

Fast forward and zoom in on testing: The first release was a disaster. Testability was an afterthought, so that testing in earnest could only start when it was too late. Bugs ramped up, deadlines were reset twice and the bi-weekly fix-releases were taking up most of the test team’s time.

While we were busy fighting old battles, the team of coders was almost doubled and two new projects were started.

Today, we’re two months from the deadline, one more rigid that the last, and we can finally start testing in earnest. The functionality is huge, complex and still changing.
We do not have the necessary knowledge to do a good enough job.

Enter ‘The stickering’Wizard Mindmap

Because the functionality is so incredibly complex and important to the business, we’ve been able to get a lot of support. Many people are interested and motivated to help us find important information.
Suddenly, there’s 20 other people testing the application and without an adjusted process, we’re sure to lose track of what we’ve been doing and what is still to be done.

To manage our coverage, we created mindmaps (www.mindmup.com) . Together with the functional people and their documents, we lined out a few modules and gathered a bunch of functionalities together with interesting test ideas in various mindmaps.

We pinned them to the wall. Next, we ordered three kinds of stickers, all in a different colour. One colour for testers, one colour for business people and one colour for IT-related but closely connected to business users, such as analysts and helpdesk.

They visit us in blocks of half days. Each session, they choose a few connected nodes on the mindmaps and start exploring. We ask them to focus on their unique point of view. Helpdesk professionals know where users will have questions and where quick solutions should be implemented. Finance will have another focus.

During their sessions, they test the nodes from their point of view and note their finding in the following Test Charter . (click through for an example)

After their session, we debrief and ask them all sorts of questions. (I will elaborate on this in a later post)

The final step is adding the coloured stickers to the mindmaps once the user has the feeling she has tested the node sufficiently. This way, anyone can pass the wall and see our progress. The goal is to get all nodes stickered by each colour.

Together with our bug wall, our results and progress get very visible.

We’ve only just begun with this and I’ll be sure to report on how it worked for us in the end.

 

WP_003445

 

Katrina’s question of goodness

Software Testing

This afternoon, Katrina posed the question “What makes a good tester?” but phrased it in a clever activating way: “What makes you a great Tester?”
She had been wrestling with this particular behemoth for some days and found it time to call in the reinforcements.

This added a lot of dust and confusion into the fight, but turned out to bring some interesting threads.

Some remarks that came out of the discussion:

  1. Testing is multidisciplinary, what are the attributes that make you a good tester?;
  2. Who/what do we compare a good tester too? Non-testers? Bad testers?
  3. Core skills: “good” means finding & reporting important problems quickly and cheaply and being able to express/defend your actions.;
  4. A test that measures this. An exam? A duel to the death? A multiple choice test?
  5. How good you are is directly connected with how valuable information you supply;
  6. If you’re in high demand and teams are fighting to get you on theirs;
  7. When you are considered an expert of the product;
  8. Customer satisfaction is a parameter;
  9. Peer assessment;
  10. You could be really bad at finding bugs/important information, but inspire everyone around you to not make them in the first place or give their fullest to find them for you;
  11. Being confident in your ability may be an indication;
  12. The Relative Rule was mentioned.(http://www.developsense.com/blog/2010/09/done-the-relative-rule-and-the-unsettling-rule/)

There were other interesting remarks, but let’s keep it at this.

All of the above seem genuine criteria and yes, it is extremely relative to context. To find a general ‘rule’, however, I’d like to go deeper, broader and try to generalize. Many of the above can be countered with a “what if”. (We’re good at finding alternatives that complicate things)
Can we find common ground on what makes a good tester?

Context is important, but for this exercise we must hold every possible context into account rendering the parameter to become infinite or null. It’s virtually impossible to factor this in.

Skills are important, but as we have an infinite number of contexts, where a very large list of skills has the potential to find that out-of-the-box bug nobody without that particular skill thought about, we can’t calculate non-traditional skills as a factor.
There are a few skills that are always valuable but they are not necessarily crucial to be considered ‘good’.

Person X is a blank slate. You may customize X to your own wishes.  You must build person X to become a tester that could be an asset in any context. Use as few attributes as possible.

This is my person X:

  1. The person has a professional demeanour;
  2. The person has good written communication skills;
  3. The person is a power learner, meaning that (s)he can quickly learn new things and is interested to;
  4. The person is aware of his/her own shortcomings.
  5. With the above attributes the person will use every method, tool, colleague, hoodwink, trick, question, experiment, ploy,… in his or her power to find important information.

To me, these are the absolute attributes and skills that make a tester good. Or at least good enough to serve in as many possible context I can imagine.

How would your person X look like?

The Test-as-a-noun Alarm

Software Testing

Words are important
I often practice good and thoughtful wording. We’re in the business of gathering information and supplying it. Working in a business where most people have no deep understanding of what their colleagues do, we need to be able to clarify, even translate information in a way that our recipient can understand the message optimally.

This is no easy feat and requires much practice. That’s why I train myself in it and you should too. At some point this summer, the idea popped into my head that “Test should never be used as a noun”.

Since then I’ve had the pleasure to discuss this on Twitter and Skype with Chris(@Kinofrost, QualityExcellentness), Patrick Prill (@TestPappy), Sarah Teugels(@Sarah Teugels) and James (@rightsaidjames).

This is the conclusion I have come to. (which is not necessarily, what the others have found.)

Shaping of ‘a test’

Consider these two definitions (from Context Driven Testing – James bach)

“Testing is the process of evaluating a product by learning about it through exploration and experimentation, which includes: questioning, study, modeling, observation and inference, output checking, etc.”

“A test is an instance of testing.”

To me it felt that the second definition did not bring any value but more likely supported confusion and abuse of the term.

  • ‘A test’ is a countable noun. Which makes it dangerous for (non-)testers who like to attach meaning and value to numbers.
  • ‘A test’ is easily confused with ‘a check’. It’s much too easy to substitute the difficult to comprehend concept with a more simple one. The question: “Could this information impact value to anyone who matters?” is forgotten and replaced with “Can I push this button and is the background blue?”. ‘A test’ involves human interaction, tacit knowledge, interpreting results,…
  • Calling your activity ‘a test’ implicates that it is a thing. Things are tangible and generally mean the same thing. A dog means a dog, even though there’s a few hundred different races. You can further specify what kind of dog it is you’re talking about.
    ‘A test’ involves tacit knowledge, which can’t as easily be expressed.
    In addition, calling it a thing, gives the illusion that it can be repeated. You don’t want other people to misunderstand it that way.

I have been convinced by the aforementioned people that there are indeed cases in which ‘a test’ can be a valuable. It comes with a few caveats though.

– It’s an activity; like ‘a run’ or ‘a play’ it isn’t specific about anything, but gives notion of a certain activity.
– It’s focused on finding important information (to a person who matters).
– It’s requires human intelligence. (tacit and explicit knowledge)
– It’s boundaries are irrelevant. Where it started and where it ended are not important to the concept.

We’ve come up with the following definition, trying to stay true to the nature of Context Driven Testing:
“A test is a human-controlled activity, any activity, that is focused on discovering information that is important to a person who matters”

Which is inclusive with: “Quality is value to some person who matters.”

Conclusion

“When you use ‘test’ as a noun, find a better way to phrase it.”
and if you don’t, be mindful of what it represents.
Which has it’s exceptions of course, like every heuristic.

I’m open for further discussion, but Twitter didn’t take kind to this blog post format.

Agreeing on uncertainty

Experience Reports, Software Testing

Coverage in Scope

In a software project, you can come across quite a few kinds of coverage. There’s Line coverage, Decision coverage, Use Case coverage, Branch coverage,… It makes sense to talk in terms of percentages when addressing these.

The above examples are descriptions of exhaustive, finite lists. The lists may not be complete, but somehow, by someone, somewhere these lists are conceived and decided upon.

They will grow in time, as new information becomes apparent and new important issues are uncovered.

This is important: the changes to these lists are manageable, even if they don’t seem to be at first. You can prioritize, as some of the items are more important than others. You start from what is apparent and deal with what comes your way. Use cases are added, lines are added, decisions are clarified, branches are checked,… It’s a work in progress and eventually the project will reach a point where change isn’t relevant anymore. Coping with that constant change is being agile.

Coverage Estimation

Suppose you have 1.000.000 lines of code. There are already tool-enabled checks in place that support 90% line coverage. Could you estimate how much time it would take to reach 95% line coverage?

It’s a straightforward question but a herculean task to gather information to offer as precisely as possible an estimate. Even then the solution is ambiguous  and the result uncertain. But you can give an informed estimate, if you desire. An educated guess, calculating in some margin for error and unforeseen difficulties.

Possible parameters  for line coverage estimation:

  • # of lines
  • Complexity of lines
  • Disparity of lines

In order to agree upon an estimation, the influencing parameters must be agreed upon. To agree upon a parameter, it must be known. Estimations are more than guesses, they are an agreement between two parties. One side calculates in the time for his or her planning, the other wants to get results within the borders of the estimate.

Test Coverage

By definition, testing is infinite. You have knowledge of only so many influencing parameters and there are many more in hiding.
Test Coverage, in percentages, is an absurd concept.

Consider the following proposition:

Will you work for me? It involves pushing buttons.

I won’t tell you how long, how many times, what happens when buttons are pushed, where you’ll be doing this, in which environment or whether it involves trained wild-life.

I’m guessing you find this absurd. Estimating Test Coverage is just as preposterous as you can’t put your finger on the infinite parameters flying around.
People, by nature, are unwilling to agree to a set of uncertainties.

However, if you, or anyone on your team is still hell-bent on getting estimates for testing, there are possibilities.

  • You both could agree on a set of known parameters. Keeping in mind that new ways will open up and temper with your estimates.
  • Or both parties could outline a model of the feature and work from there.
  • You could agree on spending X time on the feature and nothing more.
  • An initial hour or two could be estimated for a first probing session on which a clearer ‘estimate’ could be given.

All of the above are severely lacking in either meaningful coverage or estimation. There are many workarounds and different possibilities, but they are usually artificial and bound to escalate.

Estimates seem harmless at first, but:
They have an impact on people’s planning, frustrating them as estimates are shattered. They can hit a dent in your credibility as a tester.
They can severely implicate your freedom as a tester.

You need to be able to push where it hurts, being told where and how long you can test restricts this.

Chesting and Tecks

Software Testing

I had an amusing experience a few weeks ago. A colleague of mine was explaining how he was automating a regression test set and how it greatly enhanced their testing experience. I believed him, because I know he’s a professional worker with good testing and automating skills.
But I wanted to tease him a bit, as I’ve learned that he sometimes mixes up terminology and definitions.

I asked him: Today, I asked for an extract of a certain table from our database. I visualized it in excel, added some formulas and conditional markup. Next, I sorted on that markup and data errors were immediatley visible.

Was that automated testing or manual testing?

To many people, it’s a confusing question. Hell, it’s even confusing for me.
A better name might be “tool-enabled-checking/testing”. But this doesn’t clarify whether my example is testing or checking.

I noticed that we, testers, see checking and testing as surrogate terminology for automation and manual. This is not completely true, it’s too easy. There’s bound to be a gray area. A twilight zone where testing overflows in checks.

One tests a theory. My theory was that the table I selected might contain errors. I devised a formula in which I could show these mistakes. This is where theoretical testing flows over into the actual checking. The moment I start working in the excel sheet I’m beginning my practical checks. But checking is still a subset of testing. Be they tool-enabled or not, checking has to be done to either, prove or falsify your theories.

There’s a funny ebb and flow kind of feeling to testing and checking as they tend to alternate. While exploring your product you come across new ideas constantly. Further exploring ideas in depth or jumping to the next idea or even exploring ideas within ideas makes the whole concept extremely fluid.

Black on white, in the given example one goes into checking as soon as you start comparing your data to it’s expected result. But while you are doing it, you’re still testing. There is much verification, validation and checking in testing, but it’s the testing itself that’s interesting and which can result in infinitely more important paths to follow.

Be wary, that the above mentioned explainability heuristic does not hold into account false positives and negatives, human epiphanies (oh! That looks weird, let’s take a closer look) and more human errors by the analyst, developer, tester or anyone else whose had a say. It serves to show that “automated” is not the same as checking. It can be used to explain that automated checks are a subset of all possible checks and that all possible checks are a subset of Testing.