Feature Branching
March 31, 2020

How to Accelerate Your Feature Branch Workflow

Version Control

A good feature branch workflow allows teams to effectively use feature branching to maintain the main codebase. While this strategy has gained traction with Git users, many teams still struggle with their feature branch workflow. Learn the challenges of feature branching and how to collaborate better to accelerate development.

Table of Contents

What Is a Feature Branch Workflow?

A feature branch workflow segments work in progress based on features or tasks. This allows multiple developers to experiment and work independently from the rest of the team. This helps keep the codebase stable.

Why Teams Use Feature Branch Workflows

Feature branch workflows allow you to more easily manage large scale projects because instead of tackling an entire release, you can focus on small sets of changes. Teams manage their changes on their own branches, allowing you to more tightly control code entering your codebase. This works especially well for remote or outsourced teams.

Adopting a feature branch workflow can also accelerate your software delivery pipeline. Teams can work on aspects of the same feature in parallel. It also creates an advantage for teams adopting Continuous Integration. Developers can work on smaller chunks of code, submit it, and then build and test in the isolated branch. When code is ready, changes can be integrated back into the main codebase.

Challenges Using Feature Branching

With some version control systems (VCS), feature branch workflows can be difficult to manage. Let’s review some common challenges. Once you can overcome these obstacles, you can start making gains.

Merge Frequency

One of the potential issues with feature branch workflows is that while it allows developers to work in isolation for stability, it can result in long-lived feature branches that are not merged with the main codebase frequently enough. This results in painful merge conflicts down the road.

To overcome this challenge, developers should merge early and often. Merging early and often keeps the feature branch up to date with how the main codebase is evolving. It minimizes merge conflicts which can lead to reduced velocity.

When merge conflicts do arise — which is bound to happen — you want to reduce the overall size of the conflict.  The more time spent on merge conflicts, the less time spent actually developing. This can lead to release delays, lost revenue, and disappointed stakeholders. It is important to consider whether or not you are working with a VCS that tells you when new changes are available to merge.

Testing Your Feature Branch Workflow

Teams should ideally create an environment for each feature branch for testing in isolation.  This allows teams to ensure code quality before submitting changes back to the main codebase.

A proper CI/CD workflow will increase overall velocity by decreasing the number of broken builds, especially late in a release cycle.  The later a bug is found in the release cycle, the more costly it is to fix. Feature branch testing supports the DevOps “shift left” (i.e., find bugs as early as possible) best practice.

Document Branching Strategies

When using a feature branch workflow, teams need to communicate their branching strategy. Depending on your VCS, this may need to be done using an external tool or script. External tooling on top of a VCS is costly to implement and maintain, as it often requires a team of administrators. As this kind of tooling is built on top of your VCS, you are limited by the capability of your VCS system and the overall complexity of managing and interacting with this layer often reduces development velocity.

Using a wiki or whiteboard can help. But as more teams work remotely, this can prove to be ineffective. Because a feature branch workflow leads to an intentional increase in the number of overall branches, using a wiki or whiteboard isn’t good enough.

This is because the diagram is in a constant state of change It is unlikely that any one person is able to manage that amount of change. It also adds manual work for something that can be automated. Again, more time spent on overhead activities is less time spent on actual development.

Coordinate and Collaborate with Feature Branching

Feature branch workflows help developers work faster. But with some version control systems, you will not know when new changes are available to be merged.  While some development teams may rely on external communication tools like Slack, wouldn’t it be easier if the VCS simply notified you?

If you are using a microservices model, you also need to deal with another level of complexity. Which feature should be released first? Which branch needs the changes first? To coordinate with your team, ensure that you are creating communication across components teams.

Gain Visibility into Your Feature Branch Workflow

To maximize the benefits of a feature branch workflow — and eliminate the challenges — you need a VCS that can allow developers to see changes and merge easier.

Helix Core — version control from Perforce — allows you to automate your branching strategy. It tracks relationships between your branches, simplifying merges with no additional scripts.

Use Streams to Branch More & Merge Easier

Implementing Perforce Streams adds additional benefits that makes a developer’s life easier. It helps them code more instead of dealing with overhead. And admins don’t need to spend time implementing workflows, writing complicated scripts, and sending angry emails.

With Streams, the structure is built-in to support complex feature branch workflows. Plus, Streams are flexible enough to adapt to how your team works.

How Perforce Streams Works With Feature Branching

When a developer creates a branch, Streams sets up their workspace automatically. It knows what files are available and developers can see which ones are being worked on (and by whom). Developers can see the flow of change between branches, allowing them to branch and merge easier.

Your team no longer needs to rely on naming conventions or whiteboards to determine or outline your branching strategy. Because with Streams, you always know where your code needs to go.

Using the Stream Graph, developers can visualize how code is propagated. And development managers can see what features everyone on the team is working on. When changes become available, new code can be merged down. Then changes can be copied up. This helps keep your branches and codebase stable.

Remove obstacles and implement your feature branch workflow with Helix Core and Streams. You can get started today with a free trial today.


Want to learn more? Explore version control branching.