Branching Definition
February 28, 2020

Branching Definition — What Is a Branch?


Code branching enables software development teams to work on different parts of a project without impacting each other. Teams can more efficiently organize work on a shared codebase by branching and merging.

So, What Is a Branch?

A branch is a copy of a codeline, managed in a version control system (VCS). Branching helps software development teams work in parallel. It separates out “in-progress work” from tested and stable code.

The codebase in a VCS is often referred to as the trunk, baseline, master, or mainline. Perforce uses the term mainline. Developers create branches –– originating either directly or indirectly from the mainline ­­–– to experiment in isolation. This keeps the overall product stable. It is a best practice to update these working branches with changes in related codelines. This is done by merging.

What Is Merging?

Software branching creates a relationship between the branch and the codeline the branch originated from. As a developer is working their own branch, other people may also be submitting changes to the related codeline.

It is a best practice to merge these changes from the related codeline into the working branch frequently. Merging new changes into the branch helps decrease the likelihood and complexity of a merge conflict. Your motto should be “merge early, merge often.”

What Is Code Branching and Merging?

Code branching and merging is how developers work on changes and merge them back into the mainline.

Every version control system has its own approach to code branching and merging. What some of these systems — like Git, TFSSVN, and Clearcase for example — have in common is that they do not systematically track the relationships between branches.

When a developer wants to submit their changes, they need to determine where to merge. To overcome this issue, companies often implement complex (and expensive) scripting on top of the VCS. Or they might outline a branching strategy on a whiteboard or wiki and just hope that everyone follows along appropriately.

And as codebases, projects, and teams grow, so do potential issues around code branching. When thousands of developers are all working on the same code, it can be next to impossible to track everything.


Not using version control yet? Get started for free.


What Your Branch Management Strategy Needs

So how can you better manage software branching? Use our version control branching best practices.

Try to Keep Things Simple

With a lot of systems, you need to keep your software branching model simple. Branches should only live as long as necessary because you cannot them. This is unless you are using a VCS that can handle it.

Have Well-Defined Software Branching Policies

Each branch should have a single policy for who can make changes, when builds occur, what tests to run, etc.

Give Codelines an Owner

Appoint a single owner for each codeline or branch to resolve any issues that may arise.

Define a Strategy for Working Branches

Creating branches for a task or feature can be helpful for teams. And with some version control systems, it is vital to keep these branches short-lived and remove them at the earliest opportunity.

Having too many branches adds complexity that many systems are unable to manage. This increases the risk of using – or merging to – the wrong branch.

Use Branches for Releases or Milestones

With most projects, releases have to be cut while development continues. Create branches to isolate a release so future development can continue in parallel.

Protect Your Mainline

A common pattern for CI/CD is to have a single mainline. This ensures the mainline is always buildable and can be reused. To protect the mainline, all commits have to be high quality. Use code reviews and pre-commit CI as part of your build and test process.

Merge Down & Copy Up

Merging down and copying up is a best practice that keeps code stable. Merging down is merging code from a parent branch into a work-in-progress branch. It is also called a child branch.

Copying up brings the resulting merge — with all conflicts resolved — from the child branch back to the parent branch. The advantage of this strategy is that merging down gives you a preview of what the parent codeline will look like once you’ve copied back to the parent. This preview can also be tested in isolation before being copied back to the parent.

Best Branching Strategies to Accelerate Development >>


Get Software Branching Best Practices Built-In

Not all version control systems are the same. Depending on what you are using, it can be difficult to implement a branch management strategy.

With Helix Core –– version control from Perforce –– software branching best practices are built in. With Perforce Streams you can implement a robust workflow out-of-the-box to guide development.

Your team no longer needs to rely on naming conventions to determine how branches are related. And forget about documenting it on a white board! Because with Streams, you always know where your code needs to go.

You get higher-quality code, while keeping development productive. And with Helix Core, developers get faster access around the globe and enhanced security. 



Related Content: