Changes to software has been a problem since the dawn of computers, and it still is a challenge with every piece of software developed. Perhaps the biggest part of creating software is changing or expanding existing code. So handling changes is something we have to deal with all the time. It's the maintainability aspect of software development. The problem is that there are so many challenges involved, so many things that can go wrong. But do you know what the worst problem is? The fact that a lot of developers have very little focus on the issue in general, including the reasons behind it.
I tried to come up with a few of the top of my head, and listed almost thirty easily (Even without going into nitty gritty coding issues). No wonder it's hard to handle. There's no silver bullet to fix many of these issues, but as with everything else in life - you need to know about it to be able to do something with it.
Here's a number of things that affects and complicates changes in software:
- Many different developers over time
- Legacy codebase
- External system dependencies
- Developer with limited understanding of code in general
- Developer with limited understanding of the projects code and architecture
- Unmotivated developer
- Changes done just before end of day/end of week/end of year
- Different quality of developers
- Misunderstanding the time it takes to write quality code
- Not thoroughly understanding a problem
- The danger of quick fixes/hacks
- Lack of understanding of how software rot
- Unreadable code.
- High coupling in the system. Making a change in code that is used many places has a higher risk.
- Complex architecture (Hard to understand or wrong for the problem at hand)
- Duplicate code
- Illogical business logic
- Unavailable business people
- Time (Quality - if time permits)
- Bug acceptance
- Developer not feeling the pain of fixing production bugs
- Task-switching developer
- Picking up problems caused by changes
- Lack of testing
- Big bang releases / seldom releases
- Individual code ownership
- Refactoring / Not refactoring
- Adding additional features at end of test/iteration/project
This post would get way too long if I were to cover all the reasons in detail, so I'm rather going to cover various individual ones in separate posts.
Did you miss something on the list?