Git - Branching

Git - Branching

What is a Branch in Git?

A branch in Git is simply a lightweight movable pointer to a commit. The default branch name in Git is usually main (formerly master). When you start making commits, you’re working on the main branch. Git branches allow you to create an independent line of development.

Every time you create a new branch, you’re creating a new pointer that you can move independently while retaining the history of the original branch. This enables developers to work on multiple features, bug fixes, or experiments simultaneously.

Checking Current Branch

git branch

Creating and Managing Branches

Create a New Branch

To create a new branch, use:

git branch new-feature

Switch to a Branch

After creating a branch, switch to it using:

git checkout new-feature

Or combine both steps using:

git checkout -b new-feature

List All Branches

git branch

Rename a Branch

# Rename current branch to new-name
git branch -m new-name

Delete a Branch

# Delete a local branch
git branch -d old-feature

# Force delete (if unmerged)
git branch -D old-feature

Remote Branches

Remote branches are references to the state of branches in a remote repository. They are prefixed with origin/.

List Remote Branches

git branch -r

Fetch Remote Branches

git fetch origin

Checkout Remote Branch

git checkout -b feature-x origin/feature-x

Push New Local Branch to Remote

git push origin new-feature

Delete Remote Branch

git push origin --delete old-feature

Merging Branches

Merging is used to combine changes from one branch into another. This is most commonly done when a feature is complete and needs to be merged into the main branch.

Fast-Forward Merge

Occurs when the current branch’s HEAD is behind the branch being merged in and can be moved forward.

git checkout main
git merge feature-x

Three-Way Merge

If both branches have diverged, Git will use a three-way merge strategy.

git checkout main
git merge feature-y

Merge Conflicts

If Git cannot automatically merge files, it will prompt a conflict.

# After resolving the conflict
git add conflicted-file.txt
git commit -m "Resolve merge conflict"

Rebasing Branches

Rebasing is an alternative to merging. It moves or “replays” commits from one branch onto another.

Basic Rebase

git checkout feature-x
git rebase main

This will reapply the commits from feature-x on top of main.

Interactive Rebase

Use interactive rebase to squash, reword, or reorder commits.

git rebase -i HEAD~3

Continue After Conflict in Rebase

# Resolve the conflict
git add .

# Continue rebase
git rebase --continue

Branching Strategies and Workflows

Feature Branching

Each new feature is developed in its own branch and merged into the main or develop branch after review.

Git Flow

Uses specific branches for features, releases, and hotfixes.

• main - production-ready code
• develop - development integration branch
• feature/* - feature development
• release/* - pre-release code
• hotfix/* - urgent bug fixes

Trunk-Based Development

All work is done on a single main branch with short-lived feature branches merged back frequently.

Forking Workflow

Used in open source. Contributors fork the repository, create branches, and submit pull requests.

Branch Naming Conventions

Best Practices

• Use hyphens to separate words: feature/login-page
• Prefix with type: feature/, bugfix/, hotfix/, release/
• Include issue/ticket numbers when possible: feature/123-user-auth

Branch Protection

Protected Branches

Platforms like GitHub allow protecting branches to enforce rules like:

• No force pushes
• Require PR reviews before merging
• Status checks must pass

Visualization Tools

git log --graph

Visualize branch history in the terminal.

git log --oneline --graph --all

GUI Tools

• GitKraken
• SourceTree
• GitHub Desktop
• VS Code Git Graph

Best Practices for Git Branching

• Keep branches short-lived
• Pull latest changes before merging
• Delete stale branches
• Use descriptive names
• Review code via pull requests
• Test before merging into main

Common Commands Summary

# Create a branch
git branch new-feature

# Switch to a branch
git checkout new-feature

# Create and switch
git checkout -b new-feature

# List branches
git branch

# Delete a branch
git branch -d old-feature

# Merge a branch
git checkout main
git merge new-feature

# Rebase a branch
git checkout new-feature
git rebase main

# Push branch to remote
git push origin new-feature

# Delete remote branch
git push origin --delete old-feature

Branching is an essential feature in Git that enables teams to develop features, fix bugs, experiment, and collaborate without affecting the main codebase. Understanding how to use branches effectively—creating, switching, merging, and rebasing—is key to leveraging Git’s full potential.

By applying good branching strategies and adhering to naming conventions and best practices, developers can create a clean, organized, and efficient code workflow. Git branches facilitate parallel development and support modern development practices like continuous integration, agile sprints, and DevOps pipelines.

Mastering Git branching will make your development process more reliable, collaborative, and agile—whether you're a solo developer or part of a large engineering team.