One of the things I'm interested in right now is if, and how, people practice to develop skill in software testing; like, really, really interested. I think it is fairly common for people to follow a sort of unconscious development plan by simply going to work every day. However, there is another group of people that practice intentionally, be that in the occasional weekend testingsession, the Black Box Software Testing classes, or perhaps you do even more than that.
My Journey with Practice
Like lots of testers, I have a background in music. I grew up in a family where music was important and started playing the euphonium around ten-years old (I think). I never quite made it to a level of competence that I aspired to, even though the potential was there. The reason? I never learned how to practice in an effective way. I went to rehearsal every day and took private lessons with a fantastic teacher, but that was it. This was my big musical failing.
As an adult, I decided to commit myself to music once again. I picked up a new horn and joined the Brass Band of Nashville. This time is different, though; I've actually learned how to practice. Adult life is a little more time constrained, so learning how to make practice time meaningful (and useful) was a really important aspect of making this renewed passion work out.
How I Do It Now
When I practice music, I have a specific mission in mind for some aspect of my playing that can be improved. I definitely don't hang out for an hour or so noodling and playing the hits for fun. Usually, I'll pick something from the last rehearsal or gig that I want to improve on and then dedicate that practice session to working on that topic. Lets say, for example, that I had a problem with a key-signature change in the song “God of Our Fathers” (because I did). The next time I practice, I'm going to spend time working in that key signature, working through scales, arpeggios, short exercises, and what-not, in that key. The important thing here, though, is repetition.
My practice sessions go something like this:
Theory or idea of what I want to work on -> play the thing -> self-evaluate -> play the thing -> self-evaluate -> ...
One of my favorite books to practice from is the Arban Complete Method for Trombone and Euphonium. The first two-thirds or so of this book is dedicated to specific areas that can be practiced. There are sections for scales, intonation, slurs, intervals, and so on. Before each section, you get a bit of theory on what you are about to embark on. The author tells you what you are about to practice and things you should keep in mind while mastering these exercises. Something about this really clicks with me. As a student, you know when you are improving, because you know exactly what you are practicing. There is a very explicit nature of this type of practice that works for a lot of people.
Some Practical Testing Exercises
So let's talk testing. Let’s say you want to work on being a wizard of heuristics. That's right, you want to conjure these things out of thin air. Heuristics are methods or rules we based on our personal experience that can be used for problem solving. Most often we use these as a way to quickly come to some sort of answer or solution, but the real trick is that they do not always apply or work for a problem you are working on. Rob Sabourin, Matt Heusser, and James Bach have all written about heuristics they find useful in software testing. Reading these may help you to better understand the exercise as you are working through it.
Pick out some thing you want to practice with. I love Scrabble (or Words With Friends if you must) and think it would be a fun way to do this. Play the game a few times and actively observe the heuristics you use. Are there certain rules you use to maximize the points you get for a played word? Are there rules you use to prevent the person you are playing from getting a high-scoring word? Get familiar with these rules, familiar enough to be on a first-name basis. Now, write about this "Scrabble heuristic" that you have discovered. Ask yourself the following questions: What makes it a heuristic? When is it useful? When might it fail? Can you teach this to other people, and have them successfully apply it?
This is an exercise that you can run many times. The fact that it is a game keeps me interested and coming back for more, all the while learning a skill that hopefully will be transferable to software testing.
After working with Scrabble a little and developing your ability to observe heuristics you use during game play, take your new knowledge over to software and see if, and how that skill carries over. Find some website that you can test. Test this software while focusing on heuristics—if you can do this with a friend, that is even better. This doesn't have to go on for an extended period of time—thirty minutes or an hour is perfectly fine. When you are done compare bug reports and testing notes, and talk about the strategies you used to discover these bugs. Sharing what you learned can be a great way to learn from others and also a great way to bring to conscience the things you learned.
I encourage you to try this exercise out as an experiment—see how it works or doesn't work, helps or doesn't help, and share your results in the comments here. I really want to hear about your experiences with this exercise.
There are plenty of people out there that can't get to conferences or take classes because of rigid time requirements. I think that this mixture of theory, repetition, and self-awareness can (in some cases) suffice when that direct feedback loop of working with other people is not available. The trick here is being mentally present while doing an exercise, so that you can evaluate and change how you do the exercise the next time. Do you have any experience with this? Let me know in the comments section below.