What my team and I learned when improving code quality in an existing codebase
Tags: codequality, teams, softwareengineering, developmentflow
Published: 2019-09-16 18:56:41

---
title: What my team and I learned when improving code quality in an existing codebase
published: true
tags: Code Quality,Teams,software engineering,development flow
canonical_url: https://sourcelevel.io/what-my-team-and-i-learned-when-improving-code-quality-in-an-existing-codebase
---

In this article, I present a list of learnings and a general process for you to achieve a better code quality. The ideas I described here are based on my experience and don’t represent the only way to achieve a good source base. In case you don’t know where to start from, I hope this blog post helps you.

## Learnings of code quality improvement

During these years in the industry, I’ve worked along with many companies running in different business domains. However, I’ve noticed that some premisses worked just like the same in all of them. Here I show them as learnings. I take these points very seriously when defining an improvement process; otherwise, the chances of succeeding in improving and maintain the quality of your code are meager.

- **It’s not a single person job.** For real. Everyone in your team must be committed to improving existing code, and more importantly, writing quality code for new features.
- **Freezing new features while refactoring won’t work.** When your team doesn’t deliver anything for a while, business or product people tend to make sure _refactoring_ turns into a curse word, just like [Abracadabra](https://en.wikipedia.org/wiki/Abracadabra) or [Hocus pocus](https://en.wikipedia.org/wiki/Hocus_pocus_(magic)).
- **It’s not a proper time for “move fast, break things” mindset**. Big refactoring and architectural changes already have a more significant potential of breaking things; going fast only increases your chances. Focus on improvement at its pace and be sure that _the more automated tests you get, the more comfortable with changes you get_. Changing the production code without unit tests, acceptance tests, and integration tests are very risky. Remember, inserting too many bugs during refactoring may get this word cursed as well.
- **Trace a strategy and keep your team aligned.** That’s the best way to improve your code-base quality continually. From time to time, stop what you’re doing, check the metrics, change strategy (if needed), align your team, and keep working. Learn with your mistakes and improve this process as well.
- **Make quality improvements something natural**. It is a never-ending job. If you want to create this culture and make it last, I strongly recommend integrating practices into your development flow.
- **Don’t compare. Each team has its problems and pace.** It is a bad practice to compare “improvement scores.” The environment gets much tension, and the efforts of quality improvement soon turn into efforts for lessening a metric to be on top of a leaderboard or whatever. Different teams have a different view of quality and may be in different contexts. Compare your team with the very same team. “_Is the team having progress_?” that’s the question that matter.
- **Look to the short and long run**. When choosing a strategy, don’t pick only big working items. It kills your motivation as showing its progress may take some time. Think in the short-run (low hanging fruits and small fixes) and the long run.

With them in mind, here’s a suggestion of how to deal with messy code and how to take it to a better level.

## Dealing with poor quality code

### 1. Measuring your current code quality

You’re telling me your code quality is poor. However, is it? You won’t know until you measure it. Also, it allows you to see the progress of your changes. Are they improving code quality or just adding more complexity and code smells?

If you don’t know what measure, I’ve suggested in the last blog post [3 metrics that you can automatically collect by linters](https://dev.to/sourcelevel/measuring-code-quality-3-suggestions-on-how-to-start-and-why-they-are-important-35ee). You may run them by your own or by using a product like [SourceLevel](https://sourcelevel.io) to do it for you. It’s up to you, as long as you measure it.

### 2. Tracing an improvement strategy

When each member of your team works by their own, you lose track of the improvement progress and stick with the feeling of getting nowhere. That’s why you need a good strategy because it gives focus to the team.

A good strategy may vary depending on the business and on the phase of the product. If you work in a startup and hasn’t launched your product yet, you need to keep developing new features and fixing bugs to achieve that time-to-market date. Usually, this phase of the product introduces a lot of smells and design problems. However, that’s ok, because you don’t know your product very much. You’re learning the domain, and it takes time to get the big picture of your business. In this phase, I think the best strategy is introducing the least issues as possible and keeping track of the existing ones.

If your product is already launched and running, you can spot all those codes smells, calculate methods and classes cyclomatic complexity, duplicated code, etc. Then, you need to merge those improvements to the product evolution plan.

As I said, don’t stop delivering is something I’ve learned. Refactor what really matters, what impacts for your near future work and business demands. It works just like any other technical debt and must be included in or diluted into the roadmap.

When I say you should dilute into the roadmap, I mean don’t feed more than one board. Prioritize your board according to your business needs. Insert low hanging fruits and small changes through the selected cards for your sprint. Refactoring and significant changes may lead to an independent card as long as it makes sense for your business.

Be transparent to your team and prioritize issues that make future work easier and faster to change. If solving an issue has no significant gain for the next couples of weeks, let it there. **Remember, you don’t want to decrease the number of quality issues merely, you want to be improving your quality continually.**

Talk to your team and show them the value of improvements. Keep your product and business people engaged and aware of the successes and failures. Show how it impacts them by using their language: delivering faster, fewer bugs, better performance, and money saved or gained.

### 3. From time to time, share the results with your team

As I said, this is not a single person job. So, sharing the progress of your code-base improvement has a positive impact on both keeping your team engaged and motivated. Visibility is also essential for other stakeholders, like product or business people, or even the CTO.

It doesn’t matter if you’re a manager, a tech lead, or a developer. Gather everyone and celebrate small wins and, most importantly, the big ones. Make sure everyone is involved with the process.

You may ask, when and how should I share the progress?

Each team may find a proper opportunity. However, here go suggestions: you can have a 10 minutes walkthrough of the metrics during a Review Meetings (for those who run Scrum), a weekly 3 minutes follow up during a stand-up meeting, or even a separate monthly meeting only for communicating the numbers and aligning next steps. The time between the meetings depends on how fast the changes are going on. The faster you can see progress, the shorter the time between them.

Answering how to share the progress, I suggest plotting charts with metrics results and they’re history. They’re the most effective way to tell stories with numbers. Just by seeing a chart, you can tell whether your team has done an excellent job or not. Also, they help you a lot [asking questions about your process](https://dev.to/sourcelevel/measuring-code-quality-3-suggestions-on-how-to-start-and-why-they-are-important-35ee).

### 4. From time to time, review your strategy

As your team members keep working on the source base, they add new issues and solve old ones. It is essential to keep your metrics aligned with a good strategy. If metrics change too much, it’s time to review your strategy.

Your business may change too. If your competitor launches a new feature and your product must to catch them up, you’ll probably have to work harder on this. You may have to suspend a significant refactoring (in case the feature can’t wait for it), or even debate the trade-offs of inserting more poor quality code _versus_ having more time for improving it. That’s the perfect time to stop and draw a new plan. Don’t abandon improvements, even though you may not work on them for a short time.

### 5. From time to time, review your metrics

Another essential aspect of a health code is to define what quality is. If you know this, then measuring does the job of telling you how good it is. To achieve this, you need to measure the right things.

The problem is that we won’t know for sure what’s the right things to measure before we start measuring it. That’s why collecting new metrics and stop collecting unnecessary ones is a job to do regularly.

## Conclusion

Having a health code-base takes time, and the development flow must integrate as part of the process. Here I presented some learnings (so you don’t have to fail for those reasons) and a general process you can implement at your company or team.

Share your thoughts in the comments below.

If you don’t know what to measure or don’t want to collect the metrics manually, check SourceLevel’s [supported linters](https://docs.sourcelevel.io/engines/) and [Sign up for a 14-day trial](https://app.sourcelevel.io/pricing).

The post [What my team and I learned when improving code quality in an existing codebase](https://sourcelevel.io/what-my-team-and-i-learned-when-improving-code-quality-in-an-existing-codebase) appeared first on [SourceLevel](https://sourcelevel.io).