I did a Force Field Analysis brainstorm session with my team. We wrote down what we like and don’t like about our jobs as testers. Then, in the “didn’t like” column, we circled the items we felt we had control over changing. Here are what my testers and I don’t like about our jobs.
Items We May Not Have Control Over:
- When asked what needs to be tested as a result of a five minute code change, programmers often say “test everything”.
- Stressful deadlines.
- Working extra hours.
- Test time is not adequately considered by Programmers/BAs when determining iteration work. Velocity does not appear to matter to team.
Items We May Have Control Over:
- Testers don’t have a way to show the team what they are working on. Our project task boards have a column/status for “Open”, “In Development”, “Developed”, and “Tested”. It’s pretty easy to look under the “In Development” column to see what programmers are working on. But after that, stuff tends to bunch up under the “Developed” column. Even though their may be 10 Features/Stories in “Developed”, the testers may only be working on two of them. A side affect is testers having to constantly answer the question “What are you working on?”...my testers hate that question.
- Testers don’t know each other’s test skills or subject matter expertise. We have some 20 project teams in my department. Most of the products interact. Some are more technical to test than others. Let’s say you’re testing ProductA and you need help understanding its interface with ProductB. Which tester is your oracle? Let’s say you are testing web services for the first time and you’re not sure how to do this. Which tester is really good at testing web services and can help you get started?
- Testers lose momentum when asked to change priorities or switch testing tasks. A programming manager once told me, “each time you interrupt a programmer it takes them 20 minutes to catch back up”. Testers experience the same interruption productivity loss, but arguably, to a larger degree. It is annoying to execute tests in half-baked environments, while following new bugs that may or may not be related, along the way.
We will have a follow-up brainstorm on ways to deal with the above. I’ll post the results.
During a Support Team/Test Team collaboration, I was coaching a technical support team member through logging a bug. I suggested my usual template.
1. Do this.
2. Do that.
Expected Results: Something happens.
Actual Results: Something does not happen.
Afterwards, I said “That’s it.” She looked over the Spartan bug report and was reluctant to let it go. she said, “It looks too bare bones.” She wondered if we should add screen captures and more commentary. IMO, when a bug has repro steps, that’s all you need. And the fewer the better! Sure, a picture is worth a thousand words. But sometimes it only takes about 14.
If you’ve ever participated in bug triage meetings, you’ll probably agree. People love to fill bug reports with non-essential comments that obscure the spirit of the bug and discourage anyone from reading it.
“After those steps I tried it again and got the same error.”
“Maybe it is failing because I am doing this instead of that.”
“I remember it used to not throw an error, but now it does.”
“We could fix it by doing this instead of that.”
It’s a bug report, stupid. Report the bug and get back to testing. Opinions and essays are for blogs.
…Praise for the simple, bare bone bugs.
Sounds too good to be true, huh?
One of my programmers is cool enough to request a code review with me when something critical is at stake. I can’t really read code and he knows it. So why does he keep suggesting we do code reviews?
He realizes said activity will force him to explain his code at a translated-to-layman-terms-level. Occasionally, I’ll ask questions; “Why do you need that statement?”, “What if the code flow takes an unexpected path?”. But often I start to daydream…not about my weekend or other non-work things but about a previous statement the programmer made. My brain gets hung up trying to grok the code. And while I’m lost in thought, the programmer keeps zooming through their code, until…
…all of a sudden, the magic happens.
The programmer says, “Hold on…I see a mistake”. It happens every time! I kid you not! A different programmer on my team found two errors while explaining his unit tests to me Monday.
Now I’m not suggesting testers should daydream their way through code reviews. And of course, a tester capable of actually reading/understanding code is more valuable here. But I am suggesting this:
If you’re a tester who feels too uncomfortable or inadequate to perform a code review with your programmers, remember, all you have to do is listen and occasionally ask dumb questions. And even if you’re bored to death looking at someone’s code, and you fall into a daydream, who knows? You may have indirectly helped your programmer save the world.