In an ideal agile development environment, all changes must be reversible.
Why? Because one of the fundamental principles of agile development is the concept of fixed timescales. Developing one feature at a time. Iteratively developing the product in small incremental steps.
So what happens when you’re at the end of a timebox (or Sprint in the Scrum agile methodology)? Inevitably, something doesn’t quite make it in time. Inevitably, something’s incomplete or just too buggy to release. Not on your projects – obviously – but maybe sometimes on other peoples 😉
And yet, still, in agile development we want to cut the release on time, when the fixed time is up.
Not easy. Well, technically straightforward. But in practice, not easy.
Imagine first a very simple situation. A situation where you have just one developer. One developer working in a Sprint that was planned to deliver 10 things – features, bugs, use cases, user stories (xp), whatever you call them – things. Working through the things in priority order, using Microsoft SourceSafe terminology, ‘label’ the code on completion of each feature. And remember, by completion, I mean ‘DONE!’, i.e. shippable. Then, when time runs out, you can pull out the code at the last complete feature and release the software! That’s what I mean by *Back to the future!*
So what’s so hard about that? Nothing really. But in practice it can be very hard to control.
Now imagine a more realistic situation where there are several developers, not necessarily all in one location, all coding furiously on the same application. Imagine one or some developers don’t quite get something to production quality before moving on to the next thing. Or thinking it’s done but finding issues with it later. Any break from the discipline of ‘DONE!’ and this approach breaks down.
So in practice it’s hard. Also because developers don’t all complete the features they’re working on neatly at the same time. Life’s just not as simple as that, unfortunately! As far as practically possible, get developers working together on the same feature. As well as spreading knowledge, this helps quality, speeds up the completion of each individual feature, and alleviates the complexity I’ve outlined above, allowing you to stick to fixed timescales.
Extreme progamming even recommends you go as far as ‘pair programming’, with two developers literally working on the same piece of code together. This makes a lot of sense, but in my experience, rarely do you find a team (or managers) that feel confident enough about the payback to apparently halve their productivity.
So what happens towards the end of a Sprint when some developers start finishing their features? Ideally they help their colleagues. Whether it’s development, testing, or whatever they are able to do. They help their team to achieve the Sprint. Because the Sprint goal is a *team* goal.
If, for some reason, you reach the point where they really can’t help the team any more, consider any necessary documentation, self-training, R&D, or any other thing that all good development teams need but often don’t get the time for!
And if, for some reason, that’s not possible, practical or necessary – if they really must move ahead of the team and onto the next thing – branch the code from the last shippable feature (‘label’) and make sure you merge the branch back in the next Sprint.
This discipline is very important for agile development teams to master.
It’s not easy, but it is important.