By Idris Azeez July 30, 2018

How Should Teams Review Code?

With the invention of source code management applications like Git, writing code is no longer a one-person action. Since code written by one programmer is at one point or another edited by another programmer, code ownership changes very fast.

Code written by one programmer yesterday can be edited and owned by another programmer today. So it is important that code is reviewed by a team before it is merged to ensure that every team member understands the status of a code. In line with that, one of the best ways to ensure code quality is to always review code.

Code review is an established software quality practice and this means that if you want to continue to tell yourself you are a world-class developer, code review has to be a part of your everyday tasks.

Some interview processes now include code review. This means that code review is a task that must be completed just like every other software development task.

It is tempting to see a code that needs to be reviewed and simply accept the code without going through it. This is sometimes due to too much work at the current time, but this should never stop you from creating time to review code. Even though code review is boring, always make sure you understand the code first.

Below are some suggestions on how code review can be made better.

Understand the Code First

Before you certify that the piece of code is fine, ensure that you first understand the code and the aim it is supposed to achieve. Only when you understand what the code is supposed to do can you determine if the code is a good fit or not. So until you understand a code, keep on reviewing.

If a method or function was tested, make sure you understand the previous action the method performed and the upgrade the new implementation provides. If a variable was renamed, understand why.

These are some of the basic things that must be confirmed when you review code, without which code quality can be greatly reduced. And once code review does not go right, the quality of your code will begin to deteriorate and you will have to do extra work to get it back to its previous glory.

Ask Questions

Ask questions when you do not understand a certain piece of code. You want to look smart and, as such, you do not want to ask silly questions (yes, some questions are truly silly), but when you really do not know something, the best thing you can do for your team is to ask.

This goes a long way to help other team members who probably think they already understood the code to better understand it, and to help those who do not understand to have a better grip on the code. This is important, as a lot of issues in code come from people not understanding what the other programmer was trying to do. The more people who understand the code, the more issues can easily be identified and fixed.

You might be the owner of the code, but you do not always have to be around to explain what you are doing. Code review is a period where other programmers should have the same mindset as the programmer who wrote the code and, as such, questions should be asked.

In the end, it is better for every programmer who writes a code to have more people understand what they are trying to achieve, because as a programmer, sometimes you forget exactly what you were trying to achieve with a code you wrote yourself.

Answer All Questions Before Merging Code Reviews

Code should never be merged if questions are still pending. Due to the speed of code development and deployment, it is important that we consider not only the present, but also the future in everything that we do.

Whenever any team member asks a question, even when the code has been merged, answers should be provided.

On a code review, questions left unanswered sometimes come back to haunt the team or the developer who wrote that code without answering a question when it was asked again on another code review. All that needs to be answered should be covered the first time the question is asked, so that people do not spend energy doing the same thing more than once.

It happens that sometimes, another developer experiences some error while developing their code. It takes them a while to figure it out and that time could have been saved if one of the developers had answered a question that was asked on the code review. It would have saved the entire team a whole lot of time rather than having to spend extra time trying to research and solve the problem.

Also, long after developers have merged their code, questions pop up about how some function was executed and this could also have been resolved if a developer had simply taken time to respond to questions that were asked during reviews. Now the developer has to spend extra time trying to remember what they were trying to achieve.

Add Visual Code Output

Sometimes, some code logic is so simple that we do not see any way that it would fail. With such code, we simply make requests and go to bed.

But at times, it is important to add the output of the code to our code review so that other team members can see. This is because occasionally, even when we test our code and do not try to emulate the same situation, we get something else when we try to run the code again.

To avoid wasting time on code reviews, endeavor to always add the outcome of your code on the code review so that others are at least sure that the code does what it is supposed to do.

With a visual output of our code, code reviews can easily be understood without having to spend too much time understanding the code, as all you have to do is backward chaining.

Start from the result and follow the code. Following from the code to the solution is the basic way code review works, but when you start from the solution, it can save time.

Write Minimum Code for Review

As a developer who wants to provide a code to be reviewed, ensure that the code to be reviewed is minimal—the more code people have to review, the more errors that can easily go unnoticed.

As such, it is better to break a code into different code reviews than to simply merge all the code into a single code review. This is sometimes difficult, as you are mostly engulfed in trying to complete the code rather than think about who would review it, but thinking about code review while writing code is one of the attributes of great developers.

That means that you need to remember the people who would have to review your code and the time it would take them to review your code. So ensure you create code reviews that can easily be reviewed.

Set Time for Code Review

As the role of a software developer is mainly to write code, it sometimes is difficult to find time to review code, especially code written by another developer.

As such, it is important that organizations and various teams set time to review code so that the attention of developers is undivided as to what the task at hand is. Since most developers review code when they are usually less busy, code review can be slated for times when most of the developers are not as busy, so that it is done with minimal effort, but the number of people reviewing the code at the same time makes the process efficient.

Having more people reviewing code at the same time is much more effective than simply having each person go in one after the other.

Create World-Class Code Reviews

The list of how a team should review code should can never be exhausted, as new platforms are created every day that seek to resolve some of the issues with code reviews.

But do the best that you can every day to ensure that the code you review is truly world-class code. In the end, what is an organization if its code is not well reviewed?

About the author

    Idris Azeez

    Idris is a backend Software Developer with experience in developing Enterprise applications using Java. He is also a Software Developer with programming experience of close to 3 years. He loves to code and also teach. You can find him on LinkedIn.