This article will discuss the critical gaps in code review processes that need addressing as the software industry evolves.

Feature image displaying  the Alice in wonderland rabbit.

I’m late, I’m late, for a very important review!

What critical gaps in code review processes need addressing as the industry matures and becomes more complex? Many organizations run unit, integration tests, and even e2e tests, but few include performance tests.

Personally, I’ve received the feedback `It looks good to me!` more often than I care to admit. And one has to ask, is this the bar we want to set? I think we can all agree that this is not the case.

Code reviews - "It looks good to me"! - image 14

Source: Twitter

Code Reviews – what we need to be certain of

  • we understand the review objective
  • we provide courteous and actionable feedback
  • the code meets the operational standards
  • it contains no glaring issues
  • we keep an open dialogue to make sure it’s a smooth process
  • etc.

Code reviews – what is the performance impact on the system

As our systems grow more complex, and overall we shift more and more towards continuous integration and continuous deployment I believe that this step will become ever more important.

Code reviews – what we need to pay attention to

  • Does it introduce n+1 challenges
  • Are there potential caching benefits
  • Do we suffer from deadlocks
  • etc.

While many organizations certainly already run unit and integration tests on their pipelines, and more and more are also adding e2e tests few also include performance tests: This is a gap we need to cover as our industry matures.

It’s quite easy to say why we can also expose this information. However, remember to consider the downstream impact and potential issues at scale. When you’re fetching data from an external party, they might have to query other systems as well. 

Sometimes these scaling issues might lie in unexpected corners.  

Previously some organizational data was fetched in an async manner, which did not lead to issues initially. However, when we entered with our new use-case, we quickly ran into issues given that we did a lot of parallel calls which all needed exactly the same data. For the other party were all cache misses and thus with their current system also led to external lookups for this basic piece of information. 

There certainly are a lot of solutions out there:

  • Discuss with them if that field cannot be fetched and fetch it ourselves
  • Warm up their cache by first doing a single call
  • Aligning on a base cache
  • etc.

But if you do not monitor the performance or do load testing, such cases might be noticed much too late. Just firing a single call would not have triggered this.

The one major challenge: Time

We’ve all been there, tickets need to be resolved, code reviews need to be done, technical analysis to be fleshed out…

This is also why it’s important to make as many things as easy as possible. 

For local analysis, we can bring the telemetrics closer to the developer flow by using the IntelliJ IDEA plugin.  

If we’re using GitHub we can take advantage of the two new Digma actions.

* digma-ai/digma-actions/instrument allows us to add instrumentation to our application using OTEL data and send the captured data to the Digma Analytics Engine.
* digma-ai/digma-actions/assert-no-issues – can be used to verify that no dismissed issues are part of our pull request.

https://github.com/digma-ai/digma-actions

Performance Impact: The gap we need to cover

I think this gap should already be covered during development time. This is also why a tool we can use locally, while we perform code reviews such as Digma can be very handy. As mentioned above while many orgs certainly already run unit and integration tests on their pipelines, and more and more are also adding e2e tests few also include performance tests: This is a gap we need to cover as our industry matures.

Conclusion

This article was contributed to the Digma blog by Simon Verhoeven, a Senior Software Engineer and Java Consultant with a particular focus on Cloud quality and Maintainability.

Check out some of Simon’s previous articles:


Download Digma: Here

Spread the news:

Similar Posts

Leave a Reply

Your email address will not be published. Required fields are marked *