Many months ago, Rebecca asked an interesting question about technical debt in projects. She asked,
How to start when there’s a really big mess? In that case, small, just being a professional clean-up acts may not even make a dent.
Of course, as with any good question, the answer is, “it depends.” And the biggest flavor of depends is whether the project is large or small and if the project is collocated or distributed. For the sake of argument, let’s assume it’s small and collocated.
When you transition to agile and you have a reasonably size codebase, chances are quite good that you’ve been working on the product for a while. You have legacy code. You might have legacy tests. You certainly have legacy ways of thinking about the code and the tests. How do you work yourself out of the technical debt you have accumulated over time? Can you approach the work in the way I outlined in Thoughts on Infrastructure, Technical Debt, and Automated Test Framework?
Yes and No. Let’s assume that for some small set of features you can eat some small pieces of debt. And, you have so much debt, that there are some areas of technical debt that you just do not want to touch those areas of code, or that if you touch those areas, you know you are going to wade into quicksand. You know you have to create more tests than you have “time” to create. That is, the size of the story is significantly smaller than the size of the debt, even with swarming.
Now, what do you do?
You tell people. You tell the product owner. You tell your colleagues. Me, I would probably write some tests for the code anyway, because I would want to know the next time I wade into quicksand. But I have much more gray hair experience now than I did when I was younger, so I make different choices about the product.
If I was a project manager for this project, I would want to know, because I would want to manage the risk. In my experience, that much technical debt affects a team’s ability to produce features. And, if I was a product owner, I would want to know, because the technical debt would affect our ability to do anything with the product.
And, this is a case, where you might want to consider having three backlogs as a funnel into one backlog for an iteration. Read Might Three Backlogs Be Better Than One? And, make sure to read all the comments. They are quite insightful.
The idea is you still only have one backlog for the an iteration. But you have visibility into all the work you have to do that you want to rank for the product.
It’s easy in hindsight to say, “Don’t get into that situation.” Well, duh. But organizations are in this situation. And, they need help. I still think the best answer is to pay off the technical debt is to work in small features and pay off the debt as you find it. That way you never pay off more than you need to, you never do more architecture work than you need to, and you never have this strange backlog issue.
On the other hand, some people don’t realize how much debt they have. Anything that helps them see what they have is useful. But maybe there is a better way. Maybe you have a better way?
Let me summarize:
- Pay off technical debt when you implement a story, if you can.
- Swarm to start and finish a story. This will help you avoid and pay off debt.
- Write more tests to expose the debt, so no one is surprised in the future.
- Expose the debt by creating a debt backlog so the debt can be ranked in preparation for iteration planning.
- When planning an iteration, take the top item off the debt backlog. Do pairwise comparison of that item with the top item on the feature backlog. Which item has more value? Put that item on the iteration backlog. Continue until the team says, “Stop, we cannot do more in this iteration.”
- Your very last solution is rearchitecting. Why? Because it prevents you from making progress in the project. Read Startup Suicide – Rewriting the Code. It’s not just suicide for startups.
Always make sure the technical debt is visible. That is key to managing it. Whether you like my solution(s) or not, make the debt visible. And, if you don’t like any of my ideas, please do comment. Heck, comment if you do like them. I would love to know what you think.
Reference: Transition to Agile, Large Technical Debt, Small Project from our JCG partner Johanna Rothman at the Managing Product Development blog.Related Whitepaper:
Agile development has become a cornerstone of most software development organizations.
Marked by iterative processes that deliver incremental value over time, agile development has enabled organizations to manage software complexity more effectively and to improve quality and time to market compared with previous development processes.