Branch workflow practices

Basic Concepts of Branch Workflows

Branches are one of Git's core features, allowing developers to work in isolated environments without affecting the main codebase. Each branch is essentially a mutable pointer to a commit object, with Git's default branch typically named main or master. When creating a new branch, Git creates a new pointer pointing to the current commit object.

// View current branch
git branch

// Create a new branch
git branch feature-login

// Switch branches
git checkout feature-login
// Or use a more concise method
git switch feature-login

The lightweight nature of branches makes creating and switching branches almost instantaneous, as Git only moves the pointer without copying files. This design makes branches a common tool in daily development.

Comparison of Common Branch Strategies

Centralized Workflow

The simplest branch model, where all developers submit changes to the same central branch. Suitable for small teams or projects just starting with Git.

// Typical workflow
git clone <repository>
git commit -am "Change description"
git pull origin main  // Pull the latest code first
git push origin main  // Push changes

Feature Branch Workflow

Each new feature is developed in an independent branch and merged into the main branch via a Pull Request upon completion. This is the most popular collaboration method on GitHub.

// Develop a new feature
git checkout -b feature-search
// Make multiple commits...
git push -u origin feature-search
// Then create a PR on GitHub to request a merge

Git Flow Workflow

A more structured model proposed by Vincent Driessen, consisting of five branch types:

• main - Stable releases
• develop - Integration branch
• feature/* - Feature development
• release/* - Version preparation
• hotfix/* - Emergency fixes

// Initialize Git Flow
git flow init
// Start a new feature
git flow feature start user-auth
// Complete the feature
git flow feature finish user-auth

Branch Management in Real-World Development Scenarios

Handling Long-Term Maintenance Branches

For version branches that require long-term maintenance (e.g., v1.x, v2.x), create them from stable tags:

git checkout -b v1-maintenance v1.2.0
// After fixing bugs
git tag v1.2.1
git push origin v1-maintenance --tags

Collaboration Model for Large Teams

When team size exceeds 10 members, consider adopting a layered branch strategy:

main
└── develop
    ├── team-a/feature/*
    ├── team-b/feature/*
    └── shared/components

Each sub-team maintains its own feature branches, regularly merging develop into team branches rather than merging in reverse to reduce conflicts.

Practical Techniques for Resolving Branch Conflicts

Best Practices for Preventing Conflicts

1. Keep commits small and granular.
2. Frequently merge changes from the target branch.
3. Use git pull --rebase instead of a regular pull.

// Interactive rebase to tidy up commit history
git rebase -i HEAD~5
// Continue after resolving conflicts
git rebase --continue

Example of Complex Conflict Resolution

When multiple people modify the same file, use graphical tools:

git mergetool -t vscode
// Or use the built-in diff tool
git diff --color-words

For binary file conflicts, it's recommended to keep both versions:

git checkout --ours image.png
git checkout --theirs image.png
// Then manually select the appropriate version

Automating Branch Strategy Implementation

Enforcing Branch Standards with Git Hooks

Add checks in .git/hooks/pre-commit:

#!/bin/sh
branch=$(git rev-parse --abbrev-ref HEAD)
if [[ $branch == feature/* ]]; then
  echo "On feature branch, commit allowed"
else
  echo "Error: Please commit on a feature branch"
  exit 1
fi

Branch Strategy in CI/CD

Example GitLab CI configuration:

stages:
  - test
  - deploy

feature-test:
  stage: test
  only:
    - /^feature\/.*$/
  script:
    - npm test

production-deploy:
  stage: deploy
  only:
    - main
  script:
    - ./deploy.sh

Advanced Branch Operations

Orphan Branches

Create completely independent historical branches:

git checkout --orphan gh-pages
git rm -rf .  // Clear all files
// Add static website content
git add .
git commit -m "Initialize project documentation"
git push origin gh-pages

Rewriting Branch History

Safe methods to modify already pushed branches:

// 1. Create a backup branch
git branch backup/feature-xyz
// 2. Interactive rebase
git rebase -i origin/main
// 3. Force push (ensure the team is aware)
git push --force-with-lease

Branch Performance Optimization

For large repositories with thousands of branches:

// Disable automatic garbage collection
git config --global gc.auto 0
// Clean up as needed
git gc --auto

// Sparse checkout of specific directories in large repositories
git clone --filter=blob:none --sparse <repo>
git sparse-checkout set src/client

Branch Visualization Tools

Use git log to display branch topology graphically:

git log --graph --abbrev-commit --decorate --format=format:'%C(bold blue)%h%C(reset) - %C(bold green)(%ar)%C(reset) %C(white)%s%C(reset) %C(dim white)- %an%C(reset)%C(bold yellow)%d%C(reset)' --all

Or use GUI tools:

• GitKraken
• SourceTree
• VS Code's GitLens extension