Skip to main content

What I wish I knew when I started testing: Expectations vs Reality

In November 2018, I gave a talk at Belgrade Test Conference on 'What I wish I knew in my first year of testing'.

Here's the first post on the series with some key areas from that talk. (For the second part of this series: What I wish I knew when I started testing: Get involved with the testing community))

This post will focus on Expectations vs Reality (Since it was over two years ago since I gave that talk, there'll be some mismatch between my talk and this post to reflect new things I've learned etc).

These expectations reflect the expectations I had when I started my software testing career back in 2012


Expectations vs Reality

Perception of quality

My understanding of what quality was, was similar to perfection - I thought all (known) bugs had to be addressed before you went live. Bugs were something that hurt the quality of the software.
As time passed, my understanding of quality and "good enough" has changed. Now I don't only focus on bugs, but mainly on the value that can be provided to the stakeholders.


Agile

When I started my testing career at the Assurity Graduate Program, I heard some amazing things about Agile. I thought 'This sounds amazing - I'm sure I'll only end up on Agile projects' (or maybe a few non-Agile projects).

The funny thing is, I've been on a lot of 'Agile' projects. I've found that some companies believe they have Agile projects just because they are doing a daily stand-up (while there is definitely some value in running daily stand-ups to make sure that everyone is on the same page, I've found it can be hard to focus when the daily stand-up can run up to 30-45 minutes long, that in one past project it became a daily lean-on-the-wall/desk then eventually a daily  sit-down).

I can't help but think that 'Agile' is quite the buzzword to throw around to seem cool.

While I have worked on some projects that implement a lot of the fundamentals from the Agile Manifesto, they are, however, outnumbered by the projects I have worked on that only claim to be Agile.


The purpose of testing

Even something as simple as why we test software is something that I haven't always agreed on, with people I work with. It never occurred to me that my understanding of the purpose of testing would not be the same as other testers (let alone other people on a project).

To me, it was a given that we would at least have a shared understanding of what testing is supposed to achieve. 

But I was wrong.

There are multiple interpretations of the purpose of testing.

My interpretation: We test software to get a clear picture of the state of the software.  I quite like Anne-Marie Charrett's analogy where testing is the headlight and the road is the software project.

Here are a few purposes of testing I have come across, which I disagree with, along with reasons why:
  • To find all the bugs - you can't ever KNOW that you have found all the bugs as it's near impossible (if not impossible) to prove that something does not exist.
  • To ensure high quality software - testing in itself sheds light about the quality/state of the software; it tells you how things are looking, but it's up to the team to ensure high quality software
  • To improve the quality of the software - similar to the previous point; testing in itself doesn't improve the quality of the software, but if testing is done well it can give your team a good idea on what needs to be improved.  i.e. Testing --> information/input on what needs to be address --> make changes --> improved quality of the software

For the second part of this series:







Comments

Popular posts from this blog

Getting started on a testing project

I started on a new project a few weeks ago and thought it would be a good idea to share a checklist for what new testers on a project need and some good starting questions when you, as a tester, are new on a project Checklist for what new testers on a project need (Note, your project may not include all of the below) Note to check if user credentials are needed for any of the below

My Most Used Test Heuristics (with examples)

First, what is a heuristic? A heuristic is a guideline ,  it is fallible.  Therefore, it will give you a good idea of what behaviour you should see BUT it isn't definitely what should happen - it's up to you to confirm that the behaviour you are seeing is correct.  In a previous blog post I shared a step by step guide on  how to test without requirements/little requirements.    But I figured it's good to share my most used test heuristics that I use for testing without requirements. They are: Consistency with History Consistency with User Expectations Consistency within Product Let's take a look at each of them along with some examples to illustrate the concept. 1. Consistency with History  The feature's or function's current behaviour should be consistent with its past behaviour, assuming there is no good reason for it to change. This heuristic is especially useful when testing a new version of an existing program. (Source: developsense) Example: Whitcoulls, a

Bloggers Club: The Importance of Exploratory Testing

 Before we dive into the importance of Exploratory Testing, I would like to clear three things up. Firstly, I align with this definition of Exploratory Testing, by Cem Kamer, it is an approach to software testing that consists of simultaneous learning, test design and test execution. Secondly, I don't think Exploratory Testing has to be a substitute for test cases, it can complement test cases. (It's up to you, how or if you choose to combine both Exploratory Testing and Test cases when you test a feature) Lastly, exploratory testing is not adhoc testing - adhoc testing is random, unstructured testing, exploratory testing forced you to think critically about the application under test. (For more about the difference go here .) Job Interview Analogy To illustrate the importance of Exploratory Testing, I'd like to first use the analogy of a job interview. (I wrote about this in a previous blog post but will expand on this further) The Test Cases in this analogy In a job inte