The Principle Behind the Practice | by Tyler Hawkins | Feb, 2022

A typical technique for engaged on a codebase with numerous builders is to make use of function branches. The grasp department serves because the supply of fact for the codebase, and builders create function branches off of the grasp department when writing new code. When the developer is able to merge his code again into the grasp department, he creates a merge request, will get a code evaluate, makes updates based mostly on suggestions as wanted, after which merges his code.

An excellent observe when creating merge requests is to ensure that your function department is updated with the most recent code from grasp. If, for instance, you could have a function department that’s 10 commits behind grasp, there’s a danger that the adjustments in these 10 commits could affect the performance you’re engaged on.

Typically, if another person has additionally touched the identical strains of code that you just’ve modified, you’ll see a merge battle and have to tug the most recent from grasp into your department to resolve these conflicts anyway.

However typically the problems will be sneakier than that, the place one thing has modified that impacts the performance of your function with out really straight modifying the information you’ve labored on or inflicting a merge battle. For those who merge your code whereas nonetheless 10 commits behind grasp, you could be in for a headache with damaged performance or damaged assessments as soon as each units of adjustments are collectively within the grasp department.

Now, is it at all times an issue in case your function department is just a few commits behind? Not essentially. If the lacking commits don’t contact the identical space of code that you just’re engaged on, you ought to be advantageous to merge even if you’re just a little behind the grasp department. Or, for those who’re engaged on a big monolith shared by your entire engineering group that builders decide to a whole lot of instances every day, chances are high that staying updated with the very newest code shall be a idiot’s errand. So long as you’re moderately updated if you merge, you ought to be okay.

So, let’s once more take a look at the ideas behind the observe. Why will we need to maintain our function branches updated with the most recent from grasp? Some ideas embody:

  1. We should always reduce the danger of deployment. (This is similar as the primary precept from the final part. Making certain that our function department additionally accommodates the opposite adjustments which are at the moment within the grasp department helps us keep away from surprises and is a technique we will implement this precept.)
  2. We should always keep away from simply preventable errors. (We don’t need to must troubleshoot what went unsuitable with two separate branches that labored effectively on their very own however broke issues when used collectively. We additionally don’t need to must combat a fireplace with damaged performance that was merged into grasp once we might have simply caught the problem beforehand. Protecting our function branches updated is a technique we will implement this precept.)

More Posts