My friend and excellent agile coach Michele Sliger, co-author of The Software Project Manager’s Bridge to Agility ,  recently emailed me this question that she hears a lot: “Where should I start looking to learn more about test automation and tooling?”

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!

I had the opportunity to talk with Gil Zilberfeld, product owner with Typemock, a software company whose products are designed to help developers with their unit testing. I don’t often get to talk to product owners, and I was interested in his views on testing and quality. (Disclaimer: I have no experience with using Typemock’s products, and this is not a commentary on those products!)

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.

My new article “Story Mapping the Wrong Way”, a tale of how I messed up our team’s first attempt at story mapping but we learned stuff anyway, is on Techwell and Stickyminds. How fascinating! :->

Gojko Adzic was voted “Most Influential Agile Testing Professional Person” by his peers, in an award program sponsored by the Agile Testing Days conference. I was asked to give the honorific speech before the actual award ceremony. This is no doubt the highlight of my professional career – I got to give a speech to the conference participants ON A HORSE WEARING A COSTUME. It just won’t get any better than this! Here is the video – warning, it is long, I don’t have time to edit it. If it’s possible to fast forward to the end, do so and watch Gojko getting knighted by the Lord Mayor of Potsdam!

Someone on the agile-testing Yahoogroup mailing list posted a link to a blog post in which he proceeded to misuse, maul and maim the Agile Testing Quadrants. There is no way to put comments on that blog post to try to refute his claim that the quadrants are somehow a waterfall process. Since other people might misunderstand the purpose of the quadrants, I’d like to put a quick explanation here.

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!

In my latest Techwell blog post, I tell the tale of our most recent estimating meeting, where the product owner brought us a user story that was written as a technical implementation. We had to get him to back up and tell us the purpose of the story, so that we could determine the appropriate technical implementation.

I learned about Adam Weisbart’s retrospective fortune cookies via Twitter. He kindly sent me a box of them for our team to try.

Vince and Lisa choose their cookies

We’ve been doing sprint retrospectives every two weeks for eight years, so it’s always good to get out of our rut and try something new! We each chose a cookie, and took turns reading the “fortune” inside, which was a thought-provoking question. The first question was “What could the ScrumMaster do to be more effective?” This discussion led to an idea for a new Big Visible Chart – a wall on which the SM would show the stories she and the Product Owner are preparing for upcoming sprints. We also decided to try going over requirements for each user story with not only the product owner, but the primary stakeholder for each story, which the SM will ident

Lori looks excited about her fortune

ify.

All of the “fortune” questions provoked good discussions, and ones we wouldn’t have had otherwise (we had already done our standard retrospective before digging into the fortune cookies.) For example, “How would you improve our sprint review?” Ours could certainly use improvement, but we never talk about it. I think our next sprint review will be better!

One of the questions puzzled us, “Were our Artifacts helpful for this sprint? Could we improve them? How?” We weren’t sure what “Artifacts” referred to. But the question led us into thinking of a better way to note requirements changed after coding begins, and ensure the developers are informed of all changes.

A cookie for our remote team member

The fortune cookie concept posed a challenge for Nanda, our teammate in India. We had to open his cookie and read it for him. While we were fighting over who should get to eat his cookie, the cookie got dropped and shattered on the carpet. Having fun as well as thinking of experiments to improve made the retrospective fortune cookies a big success!

Whoops!

(Thanks to my teammate Mike Thomas for taking some of these action photos with our team camera).