Git & Git Flow - DevWithShawn

Introduction#

In the software development process, you will certainly have to work as part of a team. Gitflow is a branching model and a tool that helps organize the software development workflow more efficiently. It supports managing branches in the development process, ensuring clarity in how software is deployed, tested, and released.

Gitflow is suitable for projects with long development lifecycles, multiple team members, and strict control requirements between stages. The tool is implemented through the git flow command, which automates the creation, merging, and deletion of branches according to defined rules.

Main Branches in Gitflow#

Gitflow defines 5 types of branches with different roles:

1. Permanent Branches#

`master`#

Purpose: Contains stable source code that has been deployed to production.
Rules:
- Only merge from release or hotfix.
- Every commit on this branch must be accompanied by thorough testing.
In practice:
- When a client requests an urgent hotfix (e.g., fixing a failed payment bug), create a hotfix/bug-payment-fix branch from master.

`develop`#

Purpose: Contains the latest updated source code, not yet released but ready for testing.
Rules:
- This is where all feature branches are merged.
- Used to prepare for releases (release).
In practice:
- After completing a new feature, the DEV creates a Pull Request from feature/add-payment-method into develop.

2. Temporary Branches#

**`feature/*`**#

Purpose: Develop new features.
How to create:
```
git flow feature start add-user-login
```
In practice:
- When you need to add a login feature to the application, create a feature/add-user-login branch from develop. After completion, the DEV merges it back into develop and deletes the feature/add-user-login branch.

Basic Gitflow Tools and Commands#

Initialize Gitflow: git flow init.
Create a new branch:
- Feature: git flow feature start feature-name.
- Release: git flow release start release-name.
- Hotfix: git flow hotfix start hotfix-name.
Finish a branch:
- Feature: git flow feature finish feature-name.
- Release: git flow release finish release-name.
- Hotfix: git flow hotfix finish hotfix-name.

Commonly Used Git Commands#

Command	Description
`git add`	Add changes to the Staging Area.
`git commit`	Save changes to the Local Repository.
`git push`	Push changes from Local Repository to Remote Repository.
`git pull`	Update new code from Remote Repository into the Working Directory.
`git fetch`	Fetch data from Remote Repository to Local Repository.
`git branch`	Create and manage branches.
`git checkout`	Switch between working branches.
`git merge`	Merge branches together.
`git rebase`	Restructure commit history for a cleaner log.
`git reset`	Undo changes at different levels.
`git status`	Check the current status of the Working Directory.
`git log`	View commit history.
`git diff`	Compare differences between versions.
`git tag`	Create, list, and manage tags.

Conventions When Working with Gitflow#

Branch Naming Conventions:#

Features: feature/*
Bug fixes: bugfix/*
Releases: release/*
Hotfixes: hotfix/*

Commit Conventions:#

feat: Add a new feature.
fix: Fix a bug.
chore: Changes that do not affect logic (e.g., configuration, documentation).
refactor: Improve code without changing functionality.

Workflow with Gitflow#

1. For DEVs#

Main responsibilities:
- Develop features (feature).
- Fix bugs (bugfix, hotfix).
Workflow:
1. Create a new branch from develop or master (depending on the case).
```
git flow feature start add-new-payment
```
2. Work on the dedicated branch, commit changes.
```
git add .
git commit -m "feat: add new payment method"
```
3. When complete, create a Pull Request to merge into develop.
4. Delete the branch after it has been merged:
```
git flow feature finish add-new-payment
```

2. For LEADs#

Main responsibilities:
- Review code, ensure quality before merging.
- Organize release branches to prepare for releases.
Workflow:
1. Check the develop branch before creating a release branch:
```
git flow release start v1.1.0
```
2. Fix bugs and update documentation if needed.
3. Merge release into master and develop when complete:
```
git flow release finish v1.1.0
```

3. For EMs (Engineering Managers)#

Main responsibilities:
- Manage releases and urgent bug fixes.
- Ensure all important changes are updated in both master and develop.
Workflow:
1. When there is an urgent bug, create a hotfix branch from master:
```
git flow hotfix start fix-crash-error
```
2. Fix the bug, test thoroughly, and merge into master:
```
git flow hotfix finish fix-crash-error
```

Case Study: Implementing Gitflow in a Real Sprint#

Context#

Sprint RC13 runs from October 1, 2023 to October 15, 2023, requiring 3 releases:

RC13-release1: October 5, 2023
RC13-release2: October 10, 2023
RC13-release3: October 15, 2023

Implementation Process#

Task distribution:

Create feature branches for PBIs:

git flow feature start add-user-authentication
git flow feature start improve-performance

Merge completed features into develop.

Preparing for release:
- Before the RC13-release1 release date, create a release branch:
```
git flow release start RC13-release1
```
- Fix bugs on the release branch if needed and merge into master.
Urgent bug fixes:
- If RC13-release2 encounters a critical bug after release, create a hotfix branch:
```
git flow hotfix start fix-login-error
```
- Fix the bug, test, and merge back into master and develop.

Rules for Projects Using Gitflow#

If CI/CD pipeline fails -> Reject pull request.
Code must be reviewed by at least 2 people.
No direct commits to master or develop.

Conclusion#

Gitflow brings clarity and better organization to the software development process, especially for large-scale projects. Understanding and applying Gitflow will help teams work more efficiently, minimize code conflicts, and ensure high-quality products when delivered to customers.