Waterfall development has a drawback - it can be so functionally driven that testing of more abstract concepts such as “is the user interface any good?”, “can I migrate from version X to version Y” and “does my software handle failures?” can suffer. Why is this?

The core reason is that these concepts often span so many functional items, that they cannot be easily contained within testing of a single functional item. They tend to slot into the system verification test cycle - yet in the waterfall method this is at the end of the development cycle and probably subject to the tightest time constraints, when it is probably too late to fix any major architectural problems.

How can agile help here? I would like to see specific stories - and even specific sprints - designed entirely around these more nebulous concepts. This necessitates a “hold the front page” attitude: a willingness to stop development of new functionality, and instead focus on consumability/failover/documentation based on testers’ experience of earlier stories. Perhaps this is a way to implement SVT in agile…

Not much activity on here recently, must be stuff going on somewhere.

Anyway, I’ve been pondering the role of testing in an agile environment more and more recently as its something we need to get right. I’ve already touched on tester driven design in an earlier post.  Now I’d like to look at three basic concepts that may help us move on. The three concepts are:

1. Forget about test phases and replace with ‘user stories’
2. The coding, testing continuum for a user story
3. The roles in an agile team

The first concept is probably the most scary. Most teams are familiar with the Design, Code, Unit Test, Functionally verify, System verify approach to developing software. So the assumption is that in an agile environment you will still need an FV phase followed by an SV phase. This is what I want to challenge.

I’d like us to think of it more simplistically. We write some code, we do some testing. What code and testing we do should be clearly defined by the user stories that are driving the delivery. So, if for example we are delivering a new API, we would have user stories to describe how the API would be used in the single user environment (equivalent to FV type testing) and stories that describe how it might be used in a high load environment (equivalent to SV type testing). So the right type of testing still gets done, we are just driven by the user story deliveries rather than by the traditional test phases.

This then leads nicely into the second concept which I’ll cal the ‘code/test continuum’. When you have user stories as described above you’ll find that some have a large amount of coding and a relatively small amount of testing. (Delivering an implementation of an industry standard API that already has a conformance test suite would be a good example of this). At the same time you will also have user stories that have very little coding, but large amounts of testing required (using the API in a complex environment under heavy load for instance).

So the two extremes may be expressed like this.

CODE………test..

code….TEST…….

But in reality the user story can fit anywhere on the continuum.

This is an important step to realize, because I think traditionally use cases and user stories have been geared towards the functional or code end of the spectrum and we need to ensure that all aspects of a delivery are considered.

Now how do we deliver on this sort of continuum? Well that’s where my third concept comes in. The roles of the agile team. For too long we have had the split in roles between coders and testers. This has to change if we are to be more agile. What we need is skilled software engineers who are capable of coding and testing. If we had a one person project then  it is obvious that that one person would need to perform both roles. so why is it that when our project team s grow  we feel we have to split the roles across different people?

If you take an ideal sized project team (about 10) I’d expect to see a spectrum of people ranging from a small number of pure coders at one end to a small number of pure testers at the other, but with the bulk of the team sitting in the middle as ’software engineers’ who can switch roles depending on the needs of the user story. The team would morph with each delivery making much more effective use of the team’s resources.

I’ll be carrying on this thread as its close to my heart at the moment. Let me know your thoughts.

Big business frequently looks to the sporting world for fresh approaches to improve teamwork, motivation and goal setting. All too often the focus tends to be on the high achievers and their results, whilst overlooking the need to plan, develop and perform more like their sporting heroes.

The modern business trend is to adopt an increasingly flexible or agile business model.

In this article we will examine some of the techniques used by athletes and their coaches and explore how these can be harnessed to support such a business environment.

(more…)

I went up to London this week to attend my first British Computer Society (BCS) event. The Specialist Group in software Testing (SIGIST) hold quarterly conferences open to testers around the UK. Over 250 testers turned up for a day of presentations and workshops. I opted for all the presentations as the theme was Agile testing (my hot topic of the moment), but I hear the workshops were good too. I’d like to attend more of these and hopefully get the opportunity to present.

I picked up a few useful links:

• The QAGuild (Quality Excellence) has some good tooling information

• A collection of Testing blogs called TestingReflections. Well worth a read.

• Another collection of useful Test information and blogs - The UK Tester Forum

I’ve been having some thoughts about how we could measure the effectiveness of an agile test process.

One of the measures I think could work is ‘Time to defect’ (TTD). That is the time between a coder injecting a bug into the system and the time the official defect reporting the problem arrives back on their desk. The lower the TTD the better.

A low TTD has many benefits, not only does it indicate that the testers are finding defects quickly, but it also gives the coders the chance to fix the problem when the code is still fresh in their minds.

(more…)

I’ve just returned from a two day ‘Disciplined Agile Development Workshop’. Inspiring stuff! It HAS to be the way to go. Short iterations delivering real stakeholder value. Test driven development, continual integration - all that good stuff. But I must admit I have been wrestling with what that means for system test (SVT). My initial reaction was, well that’s easy, everyone else in the development team moves to the agile model and then SVT use the last iteration, when the code has stabilized and all the dependencies have been sorted out, to execute their scenarios, giving the testers several iterations of wonderful ‘prep’ time - much as we did in the waterfall model.

Fortunately I have seen the light!
(more…)

In discussion with a friend it hit me that one of the biggest obstacles in going Agile is trying to convince people to deliver “little and often”.

What this means is that you deliver just enough code to get the feature working and leave out any “I’m gonna put this here for later use” code. You also accept that this may lead to re-writes of that code in later iterations. This implies that your code is not designed to be extensible from the outset.

On the opposite side is that of having a long delivery time for your feature. This gives you the flexibility of spending a considerable time up front designing the infrastructure to support any code that will follow in that release. Unfortunately with this approach you get the inherent problems of having a long waterfall release; little customer interaction and often it’s too late.

Now, what does this mean for Test? Well, going back to the first statement in this post. I think in the transition to Agile it can be really tough to break a developers’ mentality to write extensible code. Thus from a Test perspective you get elements of both extensible and time-to-market, meaning…

Too much to test in too little time.