I hate it.
You change something and you can’t tell if your change broke something in the system.
If you’re lucky, you did not break anything. Or nobody noticed it.
Next to that, on the same scale of luck, the potential bugs are found in the manual testing phase.
But often there is no time to do all the regression testing by hand. It will take days and days, and the change you made looked so insignificant. It should go live. What could possibly go wrong?.
Then it happens. You’re live, your changes work, but the inevitable happens. Regression!
Of course, this has to be fixed. We can’t let our customers have a product with new features while the features of the previous version(s) are broken.
And so the patching process begins.
I call it patching, because often you are not done with one patch. While you were working hard to get the first patch live, other regression bugs are found and need to be patched asap as well! And so you end up with a few patches. You could be done with with a few patch releases. But it could easily extend ten-fold.
This process is very stressful for the customer and the development team. As the team is working to get these patches out soon, the customer is unhappy with his ‘broken system’. Even worse, once a few bugs are found, more testing is done on the live system to make sure everything still works, and more regression bugs poor in, adding up to the stress. To the development team it begins to look like…
From the customer’s point of view, it looks like the team working on the product is not in control. It is as if the team does not seem to know what they are doing. To them their product, which seemed rock solid at start, is degrading to a house of cards.
You can debate about high and low impact issues, and the matter of urgency to fix these issues. The perception of the customer is likely to be the same, regardless.
This is how I see it:
It is us developers who are responsible for letting regression happen.
Not project managers.
Not the customer.
It is us and us alone.
We write the code, we change the code, we are in control of the code (at least we should be!).
Even if you happened to be depending on a third-party system, it is your job to keep an eye out on that system. Verify that it behaves as you would expect it to. Why? Your system depends on the behaviour of another system, trusting that this behaviour does not change is not enough. You have to be *sure*.
Its all about attitude
Do you always deal with regression bugs after each release?
Stop accepting it, it is not normal.
Rather, start thinking about how you can prevent this. Don’t look how other people could prevent this. Think of what you could do right now. There are many ways to reduce the amount of regression bugs. For instance: add tests before changing any code. Fixate the behavior with black box tests. When you refactor, keep running your tests so you know you did not break existing behaviour. Add new tests for new features you introduce. Create a test suite that you can trust. Make integration tests. Is it hard to write tests? Make it easier. Don’t back away from the code, it is your code and you should be in control.
Besides the code, improve your own skills. Start reading about how to deal with legacy code. Attend a legacy code retreat to hone your skills. Practice, practice, practice! Get better.
Reap what you sow in your daily work.
But isn’t the whole team responsible?
Ah, of course! But does that mean that you, as a developer can now do less? Would it be okay in a team to not test, because you have testers? (“its their job right?”).
In a team we all have our strengths and weaknesses.
We understand code, and we can change code. No other role in your team is responsible for understanding the code then you. Being in a team does not make you less responsible.
Again, it is all about attitude. Stand for your craft, deliver high quality work and make sure the system is in check. It should be you who controls the system.
There are developers out there who really think they know everything of the system. And to be honest, I once had a time where I always knew what changes had impact and what I could do. And even though I was right about the impact on changes…
…I was at least wrong as many times as I was right.
But sometimes it is not just being over-confident. Sometimes it is being ignorant, or even arrogant.
Please, don’t be like this guy…
Just because it is hard, doesn’t mean you shouldn’t do it
Regression is a pain. It can be dealt with.
It is not easy.
You will not completely eliminate regression bugs. But with the correct mindset, tools and safety-net(s), you will greatly reduce the amount of regression bugs.
It is necessary. Just do it. For the love of our (your!) craft, do it, for everyone who depends on us:
The project managers.
Yes, even the testers.