…..stuck in the shadow of my mistakes.
This is a brief tale of how I learned to take a little more responsibility in my job.
As testers, I believe that we have to be advocates for quality, we cannot force it, but we can and we should be straight shooters and we should say it as we see it.
When I was new to testing, in the games industry, I didn’t really understand the role of a tester, we weren’t allowed internet access and worse than that, had next to no interaction with the development team. My friends thought they knew what I did though, a lot of misguided ideas about bean bags and such.
These days, I like to think I know what I’m doing most of the time. And now my friends have no idea what I do. Still no bean bags.
That’s not the only thing that has changed.
The test team on my first project was pretty big, around thirty testers. We were a real mixed bag, but indisputably gamer types.
There were a few in the team who took bug count to be the biggest badge of honour, seeking quantity over quality (if you can class one bug as better than others).
In lieu of this observation, in my own naivety, I decided not to partake in this competition and would intentionally ignore bugs, leaving them for the bug-hungry, as I sought meatier bugs.
Upon release, I noticed there were bugs that I had seen, bug ignored in the release version. This was before the days of day one patches and DLC, the released product was the only release.
Not my proudest achievement in life. And, I didn’t own up to it.
Coincidentally, Gerald Weinberg tweeted this Einstein quote (I Googled it to verify and Reddit confirms it – who doesn’t trust Reddit after all?), and it resonated with me.
My first tester role outside of the games industry, presented me with the opportunity to maintain a large automation suite.
A lot of this work required analysis, maintenance and updating of the various test cases that were executed on a nightly basis.
Many changes were being made to the code base and the automation was there to catch defects quickly. On occasion, there would be merges that meant a lot of tests failed.
When there are failures en masse, it is possible that other failures are masked, and this was true of this scenario. It took me three weeks to realise that a suite of failures were not down to this one problem.
This time, however, I reported the issue in TFS, raised it with the scrum master and informed the team in the stand up. When pushed for a reason that this hadn’t been reported sooner, I had to hold my hands up and admit the fault was mine.
A moment’s embarrassment was a little unpleasant, but for the sake of the quality of the end product, it was the right thing to do. And I didn’t have the guilt that comes with ignoring these issues.
We will all miss bugs, but to intentionally do so can only be detrimental to the quality of our end product. It isn’t necessarily only our call as to whether issues will be fixed or not, but we should always find the time to raise them. If anything, this can be an issue sometimes for me, in this age of distraction and managing it can be hard. But, I’m getting better at it than I used to and I’ll continue striving to improve.