So…what tester are you? …The Chuck Norris?

 

The Chuck Norris
Observed Behaviour : Desk smacking, shouting, swearing, punching, ranting, stomping, kicking and general aggression
Favourite Phrase : I’m gonna put my fist through it
Nemesis : Anyone with a weak constitution

The Chuck Norris has a bad attitude. The Chuck Norris gets annoyed when they find a bug, even more annoyed when they have to raise it in the defect tracking system and almost apocalyptic if the fix fails. The Chuck Norris can’t do any operation on the computer without it getting on their ‘goat’. The Chuck Norris hates programmers, detests project managers and positively despises the end user.

The Chuck Norris is known to slam their fist on the desk because the tab order is out, punch programmers because they uttered the words ‘Is it really an issue?’ and roundhouse their monitor because the help text was spelt wrong. The Chuck Norris is an animal.

 

(Note to the real Chuck Norris. Please don’t hurt me. http://www.chucknorrisfacts.com/)

So…what tester are you? …The Drama Queen?

I’ve been inspired by a post on the software testing club to put together a list of what types of tester I’ve worked with or noticed in the testing community. The post on STC was about how/when someone becomes an expert at testing. It was a good topic with some thought provoking responses.

 

Over the next few posts I’ll aim to cover all of the testing types I’ve noticed on my travels. Let me know what you think in the comments. Maybe even let me know which one(s) you are. Overall though, don’t be too offended by the collection. Just adding a little bit of much needed fun in to our often too serious testing community…

The Drama Queen

Observed Behaviour : Mass panic when a defect is found
Favourite Phrase : Look, Look, it’s broken
Nemesis Team Member : Programmer

 

The Drama Queen over-reacts with each bug found. Whether it is a spelling mistake or a catastrophic failure The Drama Queen always reacts the same. The Drama Queen can be seen hurtling towards the programming team, returning with at least 5 of them whilst wildly pointing at the screen and shouting ‘Look, Look, it’s broken’. In reality it’s often ‘just a bug’ that is fixed immediately with little or no fuss.

 

The Drama Queen really gets programmers backs up as they are never sure whether their code is really that bad or whether they’ve just overlooked something. Cry Wolf?

Easy Tiger – Don’t dismiss record and playback just yet

Again this week I’ve been reading blogs, forums and tweets from people dismissing record and playback as a viable automation option. Which is fine, providing reasons and justifications can be cited for not using it. But empty statements and re-iterations of other peoples reasons don’t wash too well, especially in the complicated world of testing where context appears to be king.

Sure, it should probably never be used as a long term automation strategy, but I’ve done a couple of projects recently where simple, low tech, “dirty” record and playback has been the perfect choice. And here’s why:

  • The project had incredibly tight timescales
  • The project, in the same guise, was unlikely to be re-run in the same way meaning a full considered automation strategy could have been a waste of money
  • The testers didn’t have time to plan, build and utilise a full automation strategy
  • The appropriate skills weren’t available
  • Quick feedback and regression was needed

Given that time was of the essense I needed a quick and dirty way of smoke testing the UI and using automation to load data. I didn’t need long term, dynamic, flexible and wide covering automation otherwise I would have adopted a different strategy.

I needed a simple and quick smoke test that hit some key acceptance criteria, gave me confidence core functionality was still working and loaded some data at the same time.

It was right for me. It gave me confidence. It showed up basic functionality that was no longer working. It wasn’t time consuming or difficult to maintain. It took only 5 minutes to run. It did the job.

Think of record and playback as a tool the manual tester can use to help them achieve their testing goal. In essense, it was a project that had no automation with a manual tester who used record and playback to lower the regression burden and load states. Does that make it sound more viable and appealing? The tester was using it lower burden and make their testing efficient, not as an automation strategy or plan. Far more appealing now.

So when someone says that record and playback is wrong, costly and pointless ask them to qualify why that’s so and under what circumstances. It’s always best to have a balanced view of these things. There’s a time and a place for all types of automation. And if that person has never used it, never worked under the conditions it can be suitable for or simply prefers to spend time manually checking basic tests that a computer could be doing – then maybe their point of view should be taken with a pinch of salt. My guess is, that point of view may also contain the words ‘best’ and ‘practice’.

Long term automation with a framework and key skillset is the way forward for most projects. However record and playback still has its place, so don’t dismiss it just yet.

Acceptance Criteria : it’s a good friend

With some careful planning, a good use of time and access to your customer (or customers proxy) you can craft and distill stories that will make your job as a tester all the more effective.

On an agile project test involvement early in the planning and story writing can add an extra dynamic. Testers often have very critical minds and often ask questions other team members don't. And it's this questioning and thinking that is so powerful and effective when writing stories.

It's not just that the customer understands the stories more and thinks more critically about them but that the programmers also have more information up front and the designers and any other team member can see clearly what criteria that story will be judged against. Testers often posses the skills needed to bridge the gap between the customer and the tech teams too. They also tend to put themselves in the shoes of the user, consider usability and accessibility and are often the ones who raise pertinent questions about non-functional behaviors.

Leaving the tester out of the story writing sessions means that when the story moves over to test for testing the testers will often generate a lot of defects, some of them often quite simple. Defects that could (and should) have been found before any code was written.

And if the tester is being involved to their full capacity they too will find that the story in essence becomes a very effective test case. A case that both manual and automated testers can work from. There is no reason why a story can't contain a long list of acceptance criteria. In fact, the more the merrier in my eyes, it only helps to make estimation and verification easier. There's no reason why the acceptance criteria can't reference or jump out to flow diagrams, state transitions and any other supporting documentation. And all of this become far more possible when you include a critical thinker in story writing sessions.

I've been through many sprints that, at first, weren't successful but we soon started getting key team members involved at each story writing session and we soon started dropping code that had fewer defects. With fewer defects velocity tends to go up, moral remains high and more time is freed up for exploratory testing.

So don't be shy. If you are not actively being invited to story writing sessions, then invite yourself and add your critical thinking early.

It’s not a blame culture but it’s definately their fault

One of the main things I really like about agile is the fact that the whole team are creating and working towards shippable software at the end of each sprint. Well, that's the theory anyway.

And a positive side effect of this is that you lose the 'over the wall' mentality. In a true agile environment there is no 'them' and 'us'. It's no longer a blame culture. Everyone is responsible for quality. Everyone is responsible for getting the software working. The software is not thrown over the wall to test and then thrown back over for bug fixing.

So it becomes a team activity in the truest sense. We are all working towards a common goal. No one person is responsible for quality – we all are. Sure, there are still individual mistakes but the team rally together to solve these.

And it is great. There's no bad mouthing, sniping or hushed conversations – well fewer anyway 🙂 It's all about the product. It's all about the team. And that, in my eyes, is a really positive thing.

It’s all about the people

As many may have guessed or deducted from my posts I'm all about the people. I strongly believe that people and their skills, outlook and mind set are what make or break a team. A good team can achieve great things. A bad team will rarely achieve anything above average.

But a good team isn't just about getting a group of genius' or 5 star employees together. It's about diversity and creativity. And this is exactly why great development teams can churn out huge amounts of software of exceptional quality. It's why some open source projects are so successful and social media collaborative projects are so exciting, interesting and productive.

It's because of people. It's because the people in the team are usually self governing, highly motivated, creative and directing their own work in line with the whole team approach. It's partly because these teams are made up of cross disciplines whose outlooks on life, work and play can be so very different.

As a manager or team builder don't be too hasty to build a team of just one discipline, gender or personality. Instead, search out the creative, individual, accommodating, communicative and motivated individuals and bring these people together irrelevant of experience. (Note: Obviously some teams require certain unique skills sets which cannot be ignored)

The interconnection of ideas, thoughts and opinions is where real learning and development takes place. It's where great ideas are born and plans are made.

Sir Ken Robinson said that "creativity is the interaction of disciplinary ways of seeing things."

Whenever I build a team I look at the team as a whole, not as individual members. I don't dictate ideas down to the team. I get them all in a room (of all levels) and we brainstorm and generate ideas together, as a unit.

It's this team work that generates ideas, plans, actions and a team unification that is so often missing from many test teams. If you can include programmers as well, then you are on to a winner.

Creativity is a core fundamental in software testing. How can I find more bugs? What questions can I ask the software? How can I report my findings in a way my audience will interpret them as I want them to? How can I make myself more efficient? How can I leverage Bob's skills even though he is not on my team?

So a good team is not only about the people (their skills or experience) but the teams outlook on life as well (attitude, understanding, communication skills etc). And don't become complacent, it's often the juniors who have the freshest and most interesting take on testing too………..

Agile: It will make your face melt and your mind burst

For me one of the most difficult challenges I have faced as a tester is the
move from a traditional project methodology to an agile one.

The process of adopting agile for a manual tester is tricky. It's
incredibly difficult and often it is the testers who offers the most resistance
when teams make the move. Stories about testers being negative, throwing their
toys out of the pram and generally being a bad egg are common.

And I completely understand why.

When I made the transition from traditional to agile it felt like my face was
melting and my mind was bursting.

It was the toughest challenge of my career. I
hated those first few weeks and wondered whether I had a role in the team or
not. I was contemplating a change of career and feeling completely and utterly
under valued. I hated it. I was terrified that this was the future of software testing and I didn't get on with it.

For a tester, it's not just about doing the same work in a different order or
with tighter time constraints, it's about changing your outlook on testing
and how you fit in to the team. It's about redefining your role (and your skills) and evolving to
stay relevant. You need to do a mind shift that at first seems completely alien.
A mind shift that seems so very wrong.

In the end I just let go, took the rough with the smooth and worked at seeing what all the fuss was about. And here's what I found out.

The focus of the whole team
shifts to quality

  • You will become the quality expert. You will no longer be the person who
    tests just at the end
  • You may need to devise tests with little to no formal documentation…fast
  • You will need to feedback your test results rapidly
  • You will need to be confident, vocal, capable, responsive and communicative,
    often taking charge and leading on quality
  • The rest of the development team will come to you for feedback to their
    tests and code early

You will bridge the gap
between the business and the techies

  • Your role should now mean you liase closely with the customer. You will need to
    adopt a customer satisfaction role
  • You will help to define the stories and acceptance critiria – these will become your tests and guidance so your input is essential
  • You will have to report finding about quality to the customer and
    stakeholders….fast, timely, accurately and with diplomacy

You will need to put your
trust in the Product Backlog

  • Traditional projects with 100 requirements often end up delivering a large
    percentage of that 100 but with poor quality, misunderstanding and often incomplete
  • Agile projects with 100 requirements at the start *may* end up delivering only 60. But these will be complete, exactly what the customer wanted and of course, be superb quality.
  • This original number of 100 may grow and shrink with changing markets and business decisions. Trust the backlog.
  • The customer will define and decide the next sprint of work for your team.
    • You will simply advise, manage expectations and communicate
    • This is a tough one – letting the customer decide what to do next….
  • You will need to consider the longer term and bigger picture, but your main focus
    is the sprint in hand

You will need to increase
your exploration and automation

  • You will need to replace the tedious, checklist type manual tests with automation if possible.
    • Your regression suite will get too large unless you make the most of
      automation and get the basics covered.
    • The only other option is to hire a load
      of undervalued and demotivated testers to simply 'checklist' basic
      functionality.
  • Your automation should be integrated with the continous integration and
    automated build deployments.
  • Elisabeth Hendrickson summed up agile testing very nicely indeed (taken from
    her ruminations blog – http://testobsessed.com/):
    • Checking and Exploring yield different kinds of information.
    • Checking tells
      us how well an implementation meets explicit expectations.
    • Exploring reveals the
      unintended consequences of meeting the explicitly defined expectations and gives
      us a way to uncovers implicit expectations. (Systems can work exactly as
      specified and still represent a catastrophic failure, or PR nightmare._
    • "Checking: verifying explicit, concrete expectations"
    • "Exploring: discovering the capabilities, limitations, and risks in the
      emerging system"
  • A negative side effect of increased exploration is how you go about managing
    the test information.

You will need to drop the
concept of test case preparation and spec analysis

  • It's unlikely you will get a detailed spec.
  • The acceptance criteria become your test cases and design.
  • The software becomes the UI design.
  • If you must write a test plan, plan for the sprint only.
    • Don't assume you
      know how or what you will be testing in three sprints time.
  • Prepare to be dynamic in your tool selection, approach and thinking to testing. You may need to
    change your tools to cater for new information.
    • Don't be too prescriptive.
    • Add a
      quality toolsmith to your team. They will save you a fortune in the long run.
    • Invest time in researching free, open source or cheap tools.
    • The more tools you know of, the more likely you will be able to respond to changes.
  • Don't even consider what are supposedly Best Practices.
    • Do what is right for your team, on that
      project and at that moment in time.
  • Trust me, letting the stories and software guide the UI and design is a
    revelation. It's just tricky changing your mindset to accept this.

You will need to get over
the defect stats and metrics complexion

  • Working software is fundamental. It's what the end goal is.
    • Each sprint you aim to deliver releasable standard software that meets the
      acceptance criteria.
    • So along the way there is less emphasis on raising and
      recording every single defect in a tracking system.
    • It's more about shouting
      over to the programmer and getting it sorted between you.
    • Look at low tech dashboards as a way of reporting metrics
  • Defects that relate to the acceptance criteria and story under test mean the
    story is not done (even if it has been coded and the programmer has moved to a new
    story).
  • Defects are no longer used to cover our backsides or blame other people.
  • Defects that aren't related to the story should be on the backlog, where the
    customer can prioritise.
    • After all a defect is a piece of functionality that
      either exists and shouldn't or doesn't exist and should.
    • Let the customer decide
      what to do with them.
    • They may be less/more important to the customer than you think.
  • If you truly must report then this needs to be done in the lightest way
    possible. And my guess is, that if you really are having to report each and
    every defect encountered along with test case metrics and stats in a formal way then someone in the
    process/system has not truly bought in to agile.
  • Note: I'm not saying be slack with defect tracking and reporting.
    • Far from it, if you need to put a defect on the backlog for the customer then you need to consider how you will describe this successfully for that audience.
    • When shouting to the programmer it's often easier as you can show them the defect in action. 
    • The people you report to, the information you report and the way you report it changes.

After getting my head around these differences and new concepts I noticed a few unexpected side effects;

  • I was re-ignited with my passion for software testing
  • I was being consulted far more on quality issues meaning I spent less time complaining and raising obvious bugs after the software was dropped
  • I started to use my creativity and critical thinking in a rapid and responsive way, rather than testing a spec and thinking of a few edge cases up front.
    • I was being engaged and used for my creativity, skill and critical thinking
  • I started to work in teams where the whole team valued quality rather than an 'over the wall' mentality.
  • I noticed that the customers were far happier with the process. They were getting to control the focus of the work and ending up with software that meets their needs at that moment in time, not the software they thought they wanted 6 months ago
  • I lost a huge amount of negativity and became more positive, motivated and accomodating.
  • I spent far less time sitting around after raising a barrel load of defects.
    • I no longer waited for the triage, fix, build inclusion, release, retest, close.
    • I got them fixed asap, released asap and retested asap.
  • My job didn't feel futile. I felt I was adding value.

Now I know there are people with frustrations with agile and there will be teething
problems and issues for all new teams. And agile really may not be suitable for all types of work, but there are certainly some awesome principles and techniques we can all learn from agile.

If you have any agile testing stories to share then please let me know
in the comments.