The Symptoms of Low Internal Software Quality

The first post of Low Internal Software Quality series.

Not only physical matter deteriorates, software does too

It’s known that physical matter deteriorates. People accept that and have always dealt with it. What people don’t accept so easily is that software “deteriorates” too. Unlike physical matter, it doesn’t happen due to some physical or chemical phenomenon. It usually happens because of some business change or people change. Let me give you an example.

Imagine you’re leading the tech or product team of a startup; you’re the CTO. You already launched your product’s first version, and it was a success. Your business model was validated, and now you’re in a growth stage. That’s awesome! But it has its costs, and it brings a new set of challenges.

The first version of your product is working, but the codebase is not in the shape you’ll need from now on. Maybe your team’s velocity is not as good as it used be. Your team keeps complaining about the code quality. The CEO and the product director want new features, and your current projections will not meet the business needs.

It’s not uncommon that one of the main sources of all these problems is the poor quality of your product’s codebase. You may need a refactoring 1 or a rewrite.

When the codebase is not in good shape, everyone can get frustrated

If the internal quality of your product is not good, everyone becomes frustrated.

Your whole team, including developers, will get frustrated because they would like to ship features faster, but the current code quality and architecture are not helping.

The IT, product, and software departments suffer because they’re not able to meet the expectations of the other departments.

The customer also suffers because of frequent bugs, how long it takes for them to be resolved, and how long it takes new features to be launched.

You get the picture.

Identifying the symptoms

It’s the leader’s job (let’s say the CTO) to identify when a refactor or a rewrite is needed. In order to do that, he or she can look around for some symptoms, like the ones below:

  • Everything is hard: Almost every feature or bug fix your team needs to do is hard. It was not always like that. You remember the good old days when your team was fast and everything ran smoothly.
  • Slow velocity: Your team’s velocity decreased or is decreasing. When you were building the first version of your product, it was fast to develop a new feature, and your team used to build lots of them every iteration. Now it’s different.
  • Slow test suite: Your test suite takes 10x, 20x, 30x more time to run than before.
  • Bugs that don’t go away: Your team fixes a bug, then in a week or so it appears again. Every now and then your team is fixing a regression bug.
  • Your team is demotivated: Your team keeps complaining that working in the project is not as productive as it was in the past. A single person can’t build one feature alone; there are too many moving parts.
  • Knowledge silos: There are some parts of the software that only a single developer knows well enough to maintain. It’s difficult for the rest of the team to work with that specific code.
  • New developer ramp-up time is taking too long: When new developers join the team, it takes too much time for them to be fully productive.

The reason you got into one of these situations is probably not a technical one. Maybe you needed to deliver too much, too fast while you were building the first version of your product. Maybe your team didn’t have the maturity and experience in the past they have now. Analyzing the root cause is important too, but you need to do something else. You need to solve your problem.

If you’re experiencing the symptoms above, you probably have a low internal software quality problem. Recognizing the symptoms is already a big step. The next step is to think of solutions. Some solutions you may take include refactoring or a rewrite process.

Refactor or rewrite?

There’s no definitive guide about when you should do a big refactor or a rewrite, because it depends on a lot on your context. That said, there are some rules of thumb that you should consider when evaluating which solution to go with:

When to rewrite

  • The technology you use is outdated, and it’s not maintained anymore.
  • Your software is really slow, and changing the architecture is not enough or is not viable.
  • The supply of software developers that know the technology you use is low and decreasing.
  • There are new technologies that offer a significant advantage compared to what you’re using.

When to refactor

  • The technology you use is still maintained and relevant.
  • It’s viable to improve your application in an incremental fashion.
  • The problem you’re solving is just technical and not a business one.

Choosing one of these options is not an easy decision, and once you go with one of them, there will be an entire new set of concerns you’ll encounter. Stay tuned, in our next blog posts we’ll talk about what to consider when doing a big refactor or a rewrite.

Now I would like to know about your experiences. Have you ever been in a similar situation? How did you identify that your problem was low internal software quality? Please share with us!

Posts of the Low Internal Software Quality series

  1. The Symptoms of Low Internal Software Quality
  2. Key points to consider when doing a big software refactoring
  3. Key points to consider when doing a software rewrite

  1. I prefer the term “code refurbishment,” but people aren’t generally used to it. So I’m using “refactoring” in this blog post for the sake of clarity. 

3 responses to “The Symptoms of Low Internal Software Quality”

  1. rlmflores says:

    Nice blog post Huguito!

    Normally, I like to use think about the parts of code mentioned on “knowledge silos” as snakepits: that part of your code where members on your team are afraid to even touch ot. If you have any of them on your code, and it is at least fairly important, consider giving it some attention.

    Also, I would add another symptom for a “sick software” : when it is really hard to write a test for a class (and doing so requires a lot of setup).

    Last, I would add that rewriting a software is a very radical decision, and if your codebase doesn’t have a nice test coverage (or documentation), you’ll for sure forget to treat some cases (not to mention that would cost a lot of time, money and effort to do so). If it is possible, I would try to rewrite some parts and toggling them on whenever they’re ready (even on a different application).

  2. Luiz Rocha says:

    Not a long ago, I stopped thinking about “refactoring” as a thing in itself and more of a limited-scope rewrites. In the end, is all about rewriting a piece of code, varying only how big/large the scope of this change is.

    And the reason for this is to stop having to make a “choice” between refactor or rewrite. Code will need to be modified to best suit the business and the development model, period. Mentally, it allowed me to focus only on the scope and not in the terminology.

  3. hugobarauna says:

    Never thought in this way, “refactor” as a “limited-scope rewrite”. Interesting point of view.

    Anything that could help people going ahead and improving their software quality is valuable.

    Thanks for sharing.