Monoculture misery

Most large organisations struggle to keep control of their software maintenance costs. Many try to do this by trying to restrict which tools and techniques are used. This seems a reasonable strategy – the more homogeneous environment you can achieve the easier it ought to be to maintain. To a certain extent this may be true, but taken too far the result is almost inevitably the opposite – an ever increasing burden of maintenance costs.

Whatever you're buying, a good rule of thumb if you're concerned about maintenance, is to go for quality. Software is no exception. In fact with some estimating that maintenance costs account for over 90 % of software costs, it's a textbook example of this. There's nothing that dents your IT budget more than buggy applications.

What happens when you try to achieve a monoculture of techniques and tools? The people building the product are forced to use tools and techniques which aren't quite up to the job. And since any standardization effort inevitably lags advancements in technology the product will be dated before it's released. Is there anybody who thinks this is a good strategy for improving quality?

I have a theory. This theory is that the three most important factors for reducing the cost of software maintenance are:

• The quality of the product – fewer bugs mean less maintenance.

• Building the right product – often up to 80 % of software “requirements” aren't really required but add to the maintenance burden

• Employing the right people – the wrong people will build the wrong product whether or not they use the mandated tools.

So what do you think? What's the most effective way of employing your brightest staff?

a) Set them to work mandating which tools and techniques are to be used and enforcing these policies.

b) Getting them to act as a motor for innovation by helping development teams to take advantage of modern advancements in software development.

I know which one I'd choose. And I know which organisation I'd choose to work for.

Agile Testing - Test early

A common feature on many scrum boards is a column with the title “Test” or “Verify” or perhaps “Acceptance”. This column is almost invariably towards the right hand end of the board. Implement first, test afterwards. Does that sound agile or are we just making the same old mistakes?

Once you've got your testers in the team, and teaming up with the programmers, it's time to get serious about testing early. Not just early programmer testing but early customer testing too.

Having a separate column for verification on your scrum board merely reinforces the traditional idea that testing is something you start doing when a feature is implemented.

You don't have to wait until features are complete before starting work on customer tests. And if you can successfully encourage testers and programmers to work in harmony you might even find that a feature is tested and accepted at the same time that the implementation is completed.

Agile Testing – Teaming up

Interesting things happen when you start using Test Driven Development. One revelation is that TDD isn't just about discovering bugs:

"The act of writing a unit test is more an act of design than of verification." (Bob Martin)

As I previously wrote, a first step towards agile customer testing is bringing your testers into the team. A second step is to encourage your testers to team up with programmers and work together on the development of features.

As we have brought testers into our team and encouraged them to team up with programmers we have also seen benefits that aren't just limited to finding bugs.

To paraphrase Uncle Bob:

The act of writing a customer test is more an act of process improvement than of verification.

So what are these process improvements? Here are a handful we have experienced:

• Stories get broken down into smaller stories that allow the testers to get testing early

• Customer tests define the features of the product, eliminating the need for many of the documents traditionally associated with testing

• There is no need for a separate acceptance activity – when the programmers have completed the feature the customer tester has completed their testing

• Programmers get involved in, and a better understanding of customer testing (and vice versa).

I'm sure we will discover more benefits as we get better at customer testing.

Agile Testing – The embedded tester

It's the obvious first step towards agile customer testing – bring the testers into the team.

There is certainly a risk that a tester will lose their objectivity when they become part of the development team. But would a good tester allow this to happen? Would an alert agile coach allow this to happen? Surely not.

Being an embedded tester means changing how you work. Instead of merely diagnosing bugs after they've become chronic, you can help to prevent bugs from infecting the product in the first place.

An agile tester doesn't have to be the person who just ticks off features against a list of requirements. They can, and should be much more than this. Working in the team the tester can take a much more active role in improving the product and influencing the development process. They can help build quality into the product rather than trying to test quality into it.

Not all testers find it easy, or are prepared to adapt to this change in approach. But it's not unreasonable to demand a degree of personal agility of your agile testers.

Success has it's foundation in people. So if you're serious about agile customer testing, make sure you have the right testers in the right place. In the team.

Agile Testing – Simple in practice

Agile developers know that a few basic practices can be used to drive simplicity into programming. Working in collaboration with the customer simplifies communication. Pair programming reduces the need for documentation and controls. Programmer testing drives you towards a simpler design.

So what are the practices which can be used to drive simplicity into agile customer testing?

Face to face communication is the simplest and most effective way for us to communicate, by a long chalk. So bringing the tester into the team is an obvious way of bringing programmer and tester face to face.

Another practice to simplify testing is encouraging testers to team up with the programmers - it's not just programmers that can make a pair. For the more open minded, why not try a threesome – programmer/programmer/tester? You'll find you simply don't need a lot of the documents that are traditionally required when testing.

Finally you can start customer testing early. Whether it's automated testing or exploratory testing, you shouldn't need to wait until the end of the sprint to perform them. And by encouraging the programmers to break up large features into smaller ones the tester can drive the team to deliver features that are simpler to test.

So there you have it – three basic practices to simplify agile customer testing:

• tester in the team

• teaming up with programmers

• test early customer testing

I'll stick my chin out and suggest that these are defining practices for agile customer testing. There are several other good practices that agile testers can adopt, but if you're not doing these three then you're not agile testing. It's as simple as that.

Agile Testing - Keep it simple

One of the things which always seems to make discussing testing difficult is the plethora of different types of testing: System Testing, Acceptance Testing, Functional Testing, User Testing, Integration Testing etc. Worse still, these terms can be combined to come up with almost endless variations: User Acceptance Testing, System Integration Testing, Developer System Testing, ...

And everybody seems to have their own individual interpretation of what these terms mean. No wonder it's so difficult to have a reasonable discussion about agile testing.

Kent Beck explained back in 1999 that simplicity is one of four values for extreme programming. Simplicity also appears as one of the principles behind the Agile Manifesto. Kent kept it simple even when talking about testing. He talked about just two types of tests; programmer tests and customer tests. Programmers write tests which must run flawlessly for development to continue. Customers write tests demonstrating that features are finished.

So let's see how far we can get by using just these terms. Hopefully it will make discussing agile testing simpler. Who knows, maybe even performing agile testing will be more effective if we can also keep it simple in practice.

In my next post I'll identify three practices which can simplify agile customer testing.

Testing, verification and validation . What's the difference?

Software testing, I've read, is the process of validating and verifying a software program/application/product. But what's the difference between verification and validation? Here's the clearest definition I've managed to find.

• Verification shows the conformance with specification
• Validation shows that the program meets the customers requirements

But wait a moment. Aren't the specifications just a way of describing some of the customers' requirements? At least they should be. Otherwise the customers are paying for something they don't need, or not getting what they're paying for.

In other words, verification and validation should be the same thing, at least when it comes to software testing.

Another thing that makes me deeply suspicious of the terms ”verification and validation” is the worrying frequency which the V model is used to explain them.

Why not how nor what

Here's a quick summary of my career as a programmer.

1. write working code
2. don't understand my own code when I return to it later
3. write lots of comments in my code
4. still don't understand the code since the comments didn't get updated when code changed
5. write clearer code and fewer comments

Interestingly one of the 97 things every programmer should know is write plenty of comments while another is write fewer.

Confused? No need to be. Just comment why you've done something a particular way. If you find yourself commenting on what your code does or how then make the code clearer instead.