Some of what you find out about agile methods may sound familiar. In fact, many development projects have adopted solutions that some agile methods employ. You may have already adjusted to some agile practices as a conventional tester without realizing it. For example, before the term “agile” was formally adopted, I was on more traditional projects that had some “agile” elements:
- when I started as a tester, I spent a lot of my first year pair testing with developers
- during the dot com bubble, we adopted an iterative life cycle with rapid releases at least every two weeks
- one project required quick builds, so the team developed something very similar to a continuous integration build system with heavy test automation
- developers I worked with had been doing refactoring since the early ’80s. they didn’t call it by that name, and used checkpoints in their code instead of xUnit tests that would be used now
- in a formal waterfall project, we had a customer representative on the team, and did quick iterations in between the formal signoffs from phase to phase
- one project adapted Open Source-inspired practices and rapid prototyping
These actions were done by pragmatic, product-focused companies who needed to get something done to please the customer. Many of these projects would not consider themselves to be “agile” – they were just getting the job done. The difference between them and an agile development team is that the agile methods are a complete methodology driven towards a certain goal rather than a team who has adjusted some practices to improve what they are doing.
Other conventional testers tell me about projects they were on that were not agile, but did agile-like things. This shouldn’t be surprising. The iterative lifecycle has been around for many years (at least back to the 1940s). There are a lot of methodologies that people have used, but not necessarily codified into a formal method within the iterative lifecycle as some agile champions have. A lot of what agile methods talk about isn’t new. Jerry Weinberg has said that methods employed on the Mercury project team he was on in the early ’60s looks to be indistinguishable from what is now known as Extreme Programming.1
Another familiar aspect of agile methods is the way projects are managed. Much of the agile management theory draws very heavily from the quality movement, lean manufacturing, and what some might call Theory Y management. Like the quality pundits of past, many agile management writers are once again educating workers about the problems of Taylorism or Theory X management.
What is new with agile methods, are comprehensive methodology descriptions that are driven from experience. From these practices, discplined design and development methodologies have improved rapidly, such as Test-Driven Development. Most importantly, a shared language has emerged for practices like “unit testing”, “refactoring”, “continuous integration” and others – many of which might have been widely practiced but called different things. This shared language helps a community of practice share and improve ideas much more efficiently. Common goals are much more easily identified when everyone involved is using the same terminology. As a result, the needs of the community have been quickly addressed by tool makers, authors, consultants and practitioners.
This has several implications for conventional testers that require some adjustments:
- a new vocabulary of practices, rituals, tools and roles
- getting involved in testing from day one
- testing in iterations which are often 2-4 weeks long
- an absence of detailed, formalized requirements documents developed up front
- requirements done by iteration in backlogs or on 3×5 story cards
- often, a lack of a formal bug-tracking system
- working knowledge of tools such as refactoring and TDD-based IDEs, xUnit automation and continuous integration build tools
- a team focus over individual performance
- developers who are obsessed with testing
- working closely with the entire team in the same work area
- not focusing on individual bug counts or lines of code
- less emphasis on detailed test plans and scripted test cases
- heavy emphasis on test automation using Open Source tools
Some of these changes sound shocking to a conventional tester. Without a detailed requirements document, how can we test? Why would a team not have a bug tracking database? What about my comprehensive test plans and detailed manual regression test suites? Where are the expensive capture/replay GUI automation tools? How can we keep up with testing when the project is moving so quickly?
A good place to address some of these questions is: Lessons Learned in Software Testing: A Context-Driven Approach by Cem Kaner, James Bach and Bret Pettichord.
We’ll address some of these challenges in this series, as well as examples of testing activities that conventional testers can engage in on agile projects.