Agile methods were developed as a response to the issues that the traditional V-Model and waterfall methodologies had with defining requirements and delivering a product that turned out to be not what the end user actually wanted and needed.

A software tester’s role in traditional software development methodology, a.k.a Waterfall & the V-model can be generally summarised as:

  • Finding defects in development products, such as requirements and design documents
  • Proving that the software meets these requirements
  • Finding where the software under test breaks (whether that is through verification of requirements or validation that it is fit for purpose)

So, what are we really talking about when we use the term “agile” and what are the implications for a software tester?

A tester’s life in a V-Model or waterfall based software project world is, for most traditionally trained testers, the basic process they steps they perform are similar to the following:

  • You receive a requirements document which you proceed to review
  • You eventually get a requirements document that is considered baselined or signed-off
  • You analyse these requirements to create test conditions and test cases
  • You write your test procedures
  • You then wait for a piece of software to miraculously appear in your test environment.
  • You now start executing your tests
  • Oh and now you begin re-executing some of these tests as you now start iterating through new builds which are released to fix bugs or they may even include new functionality
  • You then reach the acceptable risk= enough testing point (or the fixed immovable deadline) and the software is released

Now, while all the above sounds logical and “easy” to do, the real world we live in makes it not quite so straight forward! Requirements are never complete and there are always ambiguities to deal with. The worst case is the software meets its specifications but doesn’t meet the user needs.

Wouldn’t it be better to build smaller parts of the system, have the business work with the developers and testers to confirm that what’s being built is indeed what they want and need? So lets build the system in small increments, increasing the systems functionality in each release, and potentially deliver a working system at the end of each increment that actually meets the end users needs?

Say hello to “agile”!

Software development is currently having a “passionate affair” with the term “agile”. Unless you have been trekking in the Andes for the past 5 years, you will no doubt have heard somebody in your organisation talking about “agile” software development or read about some aspect of “agile” on any number of software development and technology related web sites.

The trend in adoption of an Agile based methods has increased significantly and Forrester Research [2005] reported:

Agile software development processes are in use at 14% of North American and European enterprises, and another 19% of enterprises are either interested in adopting agile or already planning to do so.”

Agile software development methodologies appeared in the early 1990’s and since then a variety of agile methodologies such as XP, SCRUM, DSDM, FDD and Crystal, to name but a few, have been developed.

The creators of many of these processes came together in 2001 and created the “Agile Manifesto” which summarised their views on a better way of building software.

Agile software development methodologies have flipped on its head, the traditional view of waiting for a fully built system to be available before higher levels of testing, such as Acceptance testing, can be performed.

Testing from the beginning of the start of the project and continually testing throughout the project lifecycle, is the foundation on which agile testing is built. Every practice, technique or method is focused on this one clear goal.

So what does testing now need to know and do to work effectively within a team to deliver a system using an agile method?

The concept of “the team being responsible for quality” i.e. “the whole team concept” and not just the testing team, is a key value of agile methods.

Agile methods need the development team writing Unit tests and/or following Test First Design (TDD) practices (don’t confuse TDD as a test activity as in fact it is a mechanism to help with designing the code). The goal here is to get as much feedback on code and build quality as early as possible.

The desire for information earlier in the development phases is to monitor what the current code and build quality of the latest checked code are. This requirement leads to the use of continuous build and integration practices which provide feedback every time code I checked into the code repository and the system is built, usually on a daily basis.

Brett Pettichord defined the role of testing within agile projects as:

  • Testing is the headlights of the project – where are you now? Where are you headed?
  • Testing provides information to the team – allowing the team to make informed decisions
  • A “bug” is anything that could bug a user – testers don’t make the final call
  • Testing does not assure quality – the team does (or doesn’t)
  • Testing is not a game of “gatcha” – find ways to set goals, rather then focusing on mistakes

The article, “Agile testing – changing the role of testers” looks at the difference between a tester on an agile project, versus a tester on a traditional V-Model project.

The key challenges for a tester on an agile project are:

  • No traditional style business requirements or functional specification documents. We have small documents (story cards developed from the 4×4 inch cards) which only detail one feature. Any additional details about the feature are captured via collaborative meetings and discussions.
  • You will be testing as early as practical and continuously throughout the lifecycle so expect that the code won’t be complete and is probably still being written
  • Your acceptance Test cases are part of the requirements analysis process as you are developing them before the software is developed
  • The development team has a responsibility to create automated unit tests which can be run against the code every time a build is performed
  • With multiple code deliveries during the iteration, your regression testing requirements have now significantly increased and without test automation support, your ability to maintain a consistent level of regression coverage will significantly decrease

The role of a tester in an Agile project requires a wider variety of skills:

  • Domain knowledge about the system under test
  • The ability to understanding the technology be used
  • A level of technical competency to be able to interact effective with the development team

Filed under: Agile Methodology

Like this post? Subscribe to my RSS feed and get loads more!