Round Table Code Review Practice

Introduction

At Lineate, we are committed to improving the overall quality of development. In that spirit, we recently started implementing Round Table Code Review sessions, which are  one-to-one code reviews to ensure not only code quality and accuracy but also overall understanding of the project for engineers. We believe this practice will help spread knowledge across different levels of engineers, facilitate engaging team-building conversations, and improve code quality in the long run.

Team code review practice

Each team member during the regular working process can submit a question or suggestion in a shared place (for example, a Slack channel with a specific tag). These comments and questions are not urgent but are considered topics of interest, aimed at improving overall project quality. Team leads and senior tech members review the topics and choose the ones to discuss in order of relevance and importance, then announce the topics in advance and invite the team to the meeting.

Team building

The normal code review process for a feature usually involves just one or two reviewers, sothe rest of the team may not be aware of the technical solutions implemented as a part of each feature. On the one hand, this is a reasonable use of resources because we shouldn’t waste everyone’s time reviewing every small feature, all of which are similar to hundreds of other features in a given project. On the other hand, this approach loses big, important updates, which may have a significant impact on the overall project development, and other team members could have positively affected the specific implementation. 

Unlike regular code reviews, Round Table Code Review sessions involve everyone from the current team as well as engineers from other projects who may have relevant experience in the field and are interested in sharing it.

In addition to software developers, team leads invite management and QA engineers who can provide interesting thoughts on the technical implementation and business need aspects of the solution.

As a result, everyone can provide their ideas and thoughts and get immediate feedback. This approach also allows people to ask questions about solutions they are not familiar with.

Round Table Code Review sessions have sparked lively, face-to-face discussions about different projects right in our common areas, making everyone more engaged. Some topics—like RHEL9 migration, Java 21 migration, typical pitfalls for Docker configuration, Ansible best practices, and new features of Solr 9—caught so much interest that they led to bigger presentations for the entire company.

In addition, we’ve put together all the key points and insights from these sessions into a single document. This has turned into a useful guide for new team members, helping them get up to speed quickly. 

Most importantly, these discussions have been a big confidence booster for our junior engineers. They feel much more comfortable asking questions and getting involved, which helps them become part of the team faster.

Code quality improvement

This approach allows us to focus more reviewers’ capacity on the most important and most challenging features. As a result, we get more opinions from people who would not have seen a specific solution during the normal code review process.

In addition, people who work on other projects but have similar tasks can provide relevant recommendations for the topic, helping to analyze how other clients solved similar problems and adjusting the solution according to their experience. As a result, we’re spreading learned lessons across the whole company.

For example, in one of the most recent Round Table sessions, during the review of a problem with an outdated operating system, an engineer from another project suggested two new options. Instead of migrating to the newer version of the current OS, which would have been complicated, he suggested migrating to another supported OS or even purchasing an extended support for the OS distributor. Because other projects had recently experienced the same problem, spent some effort on options analysis, and even had an experience with results, the team could reuse those solutions.

There are also two positive side effects that help to improve code quality:

• We can provide recommendations for other team members, helping to avoid some mistakes in advance.

• We can discuss the solution more broadly than just during normal code review and, while moving from one point to another, find some ideas for improvements of the code that would not have been reviewed. 

For example, during one session, a team discussed how network resources are resolved for their infrastructure. When they discussed local host files, DNS resolution, AWS Route 53, and local Nginx configuration, they figured out a better way to set up access to customer services, and we were able to eliminate usage of AWS VPN services and the associated costs.

Conclusion 

Round Table Code Review sessions at Lineate have markedly enhanced our project development process by fostering a comprehensive understanding across various teams. This practice not only ensures code quality but also integrates a broader perspective by involving engineers from different projects, management, and QA teams. These discussions have proven invaluable for spreading knowledge, facilitating dynamic team-building, and refining our technical solutions based on collective insights and shared experiences. Moreover, by encouraging such diverse input and collaboration, these sessions pave the way for innovative solutions that could significantly benefit overall project delivery, pushing our projects toward more creative and effective outcomes.

Authors: Artem Bezlepkin, Levan Tsiklauri