I paired with Dawn Code. We decided to focus on the proofreading feature in Wikisource. We created a mind map to help us think what to test and record our results. Here it is.

Mind map for exploring the proofread function

There is so much goodness to report from last week’s Belgium Testing Days! I’ll be writing all that up, but I wanted to start with the great ideas that came out of my session on “Speaking their language: What testers can learn to work more effectively with programmers”. My slide deck will give you a bit of a feel for the talk, but as I’m going with simpler slides these days, you had to be there to know what I said. However, much more interesting are the ideas generated by the participants, who divided into small groups and made lists of what testers should learn to help them communicate and collaborate better with programmers. I asked them to go beyond the ideas I described in my talk. Each group gave their top choices, and I wrote them on a flip chart.

The last group to go had the one we all agreed was most important – have fun!

Naturally, I replied with a typically long-winded answer. She must have liked it though, because she suggested I cut and paste my reply into a blog post. Here it is!

The key thing with a newbie agile team is to not say “move testers on all teams into automated testing” but “help all teams learn to take whole-team responsibility for quality and testing, and learn how programmers and testers collaborate to automate tests at all levels”. Automated test code is code, and generally, it’s much quicker and better in the long run for programmers to code the automation fixtures. Testers know what to test, and when programmers do the coding, testers have lots of time to help customers come up with examples of desired behavior to turn into tests. Then they can pair with the programmers to automate regression testing and any other types of tests (performance, load etc). Then they will still have time to do the all-important manual exploratory testing.

If they read our book Agile Testing, they will learn that they have to be patient and invest a lot of time in learning and experimenting with different test frameworks. And they should use Mike Cohn’s test automation pyramid concept to see where they’ll get the best ROI in automation. Generally, they should always start by learning how to do TDD and get traction on unit level tests. Then they can move on to API or service level tests, then GUI. But that’s not a rule, each team has to figure out what’s best for them.

I highly recommend Gojko Adzic’s Specification by Example book, and also his blog, gojko.net. Markus Gaertner has a great ATDD book coming out but it’s not published yet.

There are SO many test frameworks, drivers, tools, it’s overwhelming. Recently we had to find a way to automate GUI regression tests for our new code that uses Dojo. Our existing GUI tools aren’t able to interpret the Dojo JS properly. It was truly a team effort, though not a smooth one. Our sys admin had earlier played around with Selenium, and we thought Webdriver might work. The sys admin did a spike and proved it did work, then he and our senior architect spiked a couple of different frameworks – one homegrown, one using Geb. They demo’ed it and got everyone’s opinions. For now we are going with the Geb framework, but down the road we might decide it’s not quite right and try something else.

Anyway, that’s a long-winded answer. One good place to start getting an idea about functional test tools is the Agile Alliance Functional Test Tools group’s spreadsheet comparing various tools, at http://bit.ly/AgileTestTools. When the teams are ready to think about functional testing, they might take a look and get an idea of all the choices. It’s a good idea to stop and plan a test automation strategy.

It is really, really hard to get started with test automation. There’s a period where it’s just extra work and no reward. But eventually they’ll cross over that Hump of Pain and start reaping the benefits, eating away at their technical debt!

An Agile Approach

Gil works with a team of three developers, who also provide technical support to customers. They practice agile development, working in small increments and short iterations, releasing new versions of their products a few times per year. They use agile practices such as pair programming and continuous integration.

Gil’s team doesn’t have any testers, but they clearly do plenty of testing, both unit and integration testing . Gil explained to me that his team practices “dog fooding”: they use their own product to help with their own unit testing.  They have thousands of unit tests running in their continuous integration, providing quick feedback after every check-in. I thought it was interesting that, although their team is co-located, they use an online board product, Trello. Gil said the sticky notes kept falling down.

Developing What Customers Want

I asked Gil how his team comes up with requirements for things such as user interfaces and APIs. He said that rather than compose formal user stories, they “throw ideas in the air”, sketch out what they want on whiteboards, break features down and code them. They don’t make changes to requirements during the iteration, but they can continue to tweak the features in subsequent iterations. They try to innovate and come up with new features that can help both advanced and new users. Once they release a new feature, they use feedback from customers to enhance it. They listen to requests and fix problems quickly.

Using their own product allows the developers to evaluate the user experience and performance aspects, rather than doing formal usability or performance testing. Since the developers rotate the technical support duties, they each get time working directly with end users who are having issues with the software. This sounds to me like a great way to get a feel for quality from the customers’ perspective. I wish my own team had this kind of direct contact with users.

Value to Customers

Gil noted that when Typemock’s products were new, the early adopters were more flexible – not everything had to be perfect. Now, they’re producing enterprise software, the customers have changed. Developers with different experience levels have different needs. Inexperienced programmers may value an easy learning curve  over sophisticated features. Even though they use their own product, Gil’s team doesn’t always know what the customers will like. They use beta testing as needed, choosing the types of customers that can provide the most useful feedback.

Gil told me a great story about his previous experience working for a company that produced large medical devices. His team didn’t have direct contact with customers. His first visit to a real customer was eye-opening. The customer had many large devices, and very little room. Gil could see that requirements he had thought weren’t very important were actually critical because of the space limitations. For example, computers needed to be inside the machine, with touch screens, to save space. This is a good lesson in why we need to understand value from the customer’s perspective.

Continually Improving

Since Gil’s team doesn’t have testers and does their own testing, I asked what their main pain points were with respect to testing and quality. He said they want to make some improvements to their continuous integration process, and reduce some technical debt they have incurred there. Next, they would like to address velocity issues. They work at a good velocity, but management always wants more output. Gil said this is a question of matching expectations. They have to balance developing new features with meeting support standards and fixing bugs.

Since I work on a small team that works on a now-mature product, I was interested to hear about experiences of a similar team. Though they’re in a different domain, it sounds to me like they have a similar commitment to delivering the best possible quality software product that they can. My experience is that there are more and more teams like Gil’s that think about many different aspects of quality. They go beyond functional testing to think about different quality aspects the customers value, and try innovative approaches to delivering those.

Group working on experiments to build trust

On December 13, SQuAD (Software Quality Association of Denver) members got together for a workshop to generate ideas that might help distributed teams succeed with agile and testing. We started by identifying some areas that pose particular challenges with distributed teams, such as coordinating, visualizing, learning, and building trust. Then, each table group chose an area of challenge, and brainstormed experiments to help overcome those challenges. We finished up by having each group share their top experiment with all the participants. Some of the results were quite imaginative, and we all got some good ideas to try.

One group tackled what they termed “The 24-Hour Question”. When you have a team whose time zones are half a day apart, when one location has a question for the other, they often have to wait a day for the answer. They suggested aligning philosophies, coming to agreement on testing practices, coding standards and the like, along with finding better ways to communicate.

The 24-Hour Question

Another group’s experiment to improve communication proposed guided, controlled feedback. Establish a baseline, identify primary points of contact, and eliminate unnecessary parties. Then engage, manage expectations, and get feedback. Try new ways of communicating, and try to measure results and use the feedback to see if the experiment helped. Since I couldn’t take notes, I’m afraid I’ve forgotten the details, but the gist is to actually try to measure results of your experiments.

Some experiments included getting everyone on a team together for project kickoff, or getting at least some members from all locations together once a quarter. One participant has been doing this with his own team, and management had found the investment in travel cost worthwhile. Many experiments involved making use of technology, including video conferencing, instant messaging including IRC style tools such as Campfire, desktop sharing, projecting blogs and other online resources, and even virtual planning rooms. Some ideas were simple: share photos among remote locations, and email or IM jokes to each other.

A group discussing experiments to build trust proposed a kickoff meeting, remote pairing, management buy-in, a survey, and team-building activities. One of their experiments was to have everyone on the team work remotely.  Another was to have the remote team lead the meetings. Retrospectives were also recommended, and I think that’s one of the best ways to evaluate how well an experiment worked and think of new ones to try.

A Festive Experiment

My own take-home aha was the idea that we need to first set a baseline – how is our distributed team working now? This might involve surveying all team members to see what works or doesn’t work for them. Then try one small experiment for one iteration, and use the retrospective to talk about whether it helped with a particular issue. Keep finding ways to measure progress. As with any problems faced by agile teams, we can’t fix everything at once. Take baby steps, but get feedback all along the way.

Please see more photos of our fun workshop.

Agile Testing Quadrants

You might want to start with Brian Marick‘s original posts on his agile testing matrix, which we called the Quadrants and (with his permission) made the heart of our Agile Testing book.

The quadrant numbering system does NOT imply any order. You don’t work through the quadrants from 1 to 4, in a waterfall style. It’s just an arbitrary numbering so that, in our book and when we are talking about the quadrants, we can say “Q1″ instead of “technology-facing tests that support the team”. 

Most projects would start with Q2 tests, because those are where you get the examples that turn into specifications and tests that drive coding, along with prototypes and the like. However, I have worked on projects where we started out with performance testing (which is in Q4) on a spike of the architecture, because that was the most important criterion for the feature. If your customers are uncertain about their requirements, you might even do a spike and start with exploratory testing (Q3).

Q3 and Q4 testing pretty much require that some code be written and deployable, but most teams iterate through the quadrants rapidly, working in small increments. Write a test for some small chunk of a feature, write the code, once the test is passing, perhaps automate more tests for it, do exploratory testing on it, do security or load testing on it, whatever, then add the next small chunk and go through the whole process again.

The quadrants are merely a taxonomy to help teams plan their testing and make sure they have all the resources they need to accomplish it. There are no hard and fast rules about what goes in what quadrant. Think through them as you do your release, theme, and iteration planning, so your whole team starts out by thinking about testing first.

Michael Huetterman adds “Outside-in, barrier-free, collaborative” to the middle of the quadrants, see his Agile Record article or his excellent book Agile ALM

Visit my Presentations page for some slide decks that contain more information on the quadrants, or check out our book. I’m always happy to talk about the quadrants, just send me an email!