Home Contact Gallery RSS Best Practices for Git in a Team -- How to Use Git Flow Correctly

We have switched from SVN to Git for many years. Now almost all projects are managed using Github. This article talks about why to use Git and how to use it correctly in a team.

Advantages of Git

There are many advantages to Git, but here are just a few that I think stand out.

1. Because it is distributed, all local libraries contain all the contents of the remote library.
2. Excellent branching model, branching and merging branches, machine-friendly.
3. Fast. In this era where time is money, Git has fast branching and merging because all the codes are local. Those who use SVN can deeply appreciate this advantage.

If you are interested, you can take a look at the design of Git itself. The internal architecture reflects many advantages. It is worthy of the hand of the genius programmer Linus (the father of Linux).

Version management challenges

Although there are such excellent version management tools, we still face great challenges when it comes to version management. We all know that everyone works on the same repository, so code collaboration will inevitably bring many problems and challenges, as follows:

1. How to start the development of a feature without affecting other features?
2. Since it is easy to create new branches, how to manage the branches? After a long time, how to know what each branch is for?
3. Which branches have been merged back into the trunk?
4. How to manage releases? How to freeze features when starting a release? How to allow developers to continue developing new features when preparing a release?
5. How to quickly fix a bug in the online code? And how to include the fixed code in the developer's branch and the next release?

Most developers now use Git with only three or even two branches: Master, Develop, and various branches based on Develop. This is barely enough for small projects, because many people only have one Release for their projects. However, when there are more people and the project cycle is long, various problems will arise.

Git Flow

Just as code requires code standards, code management also requires a clear process and standards

To solve this problem, Vincent Driessen proposed a Successful Git Branching Model.

Below is the flowchart of Git Flow

You don't understand the picture above? Don't worry, it's not your fault. I think there is something wrong with the picture itself. This picture should be rotated 90 degrees to the left, and everyone should be able to understand it.

Git Flow commonly used branches

• Production branch

This is the Master branch we often use. This branch contains the code recently released to the production environment and the recently released Release. This branch can only be merged from other branches and cannot be modified directly in this branch.

• Develop branch

This branch is our main development branch, containing all the code to be released to the next Release. This branch is mainly merged with other branches, such as Feature branches.

• Feature branches

This branch is mainly used to develop a new feature. Once the development is completed, we merge it back to the Develop branch to enter the next Release.

• Release branch

When you need to publish a new Release, we create a Release branch based on the Develop branch. After the Release is completed, we merge it into the Master and Develop branches.

• Hotfix branch

When we find a new bug in Production, we need to create a Hotfix. After completing the Hotfix, we merge it back to the Master and Develop branches, so the changes in the Hotfix will go into the next Release.

How Git Flow works

Initial branch

All commits on the Master branch should be tagged

Feature branches

Branch name feature/*

After the Feature branch is completed, it must be merged back to the Develop branch. After the branch is merged, the Feature branch will generally be deleted, but we can also keep it.

Release branch

Branch name release/*

The Release branch is created based on the Develop branch. After the Release branch is created, we can test and fix bugs on this Release branch. At the same time, other developers can develop new features based on it (remember: once the Release branch is created, do not merge new changes from the Develop branch to the Release branch)

When publishing the Release branch, merge Release into Master and Develop, and at the same time put a tag on the Master branch to remember the Release version number, and then you can delete the Release branch.

Maintenance branch Hotfix

Branch name hotfix/*

The hotfix branch is created based on the Master branch. After development, it needs to be merged back to the Master and Develop branches, and a tag is added to the Master branch.

Git Flow Code Examples

a. Create a develop branch

git branch develop
git push -u origin develop

b. Start new feature development

git checkout -b some-feature develop
# Optionally, push branch to origin:
git push -u origin some-feature    

# Make some changes git status
git add some-file
git commit

c. Complete the Feature

git pull origin develop
git checkout develop
git merge --no-ff some-feature
git push origin develop

git branch -d some-feature

# If you pushed branch to origin:
git push origin --delete some-feature

d. Start Relase

git checkout -b release-0.1.0 develop

# Optional: Bump version number, commit
# Prepare release, commit

e. Complete Release

git checkout master
git merge --no-ff release-0.1.0
git push

git checkout develop
git merge --no-ff release-0.1.0
git push

git branch -d release-0.1.0

# If you pushed branch to origin:
git push origin --delete release-0.1.0   


git tag -a v0.1.0 master
git push --tags

f. Start Hotfix

git checkout -b hotfix-0.1.1 master

g. Complete Hotfix

git checkout master
git merge --no-ff hotfix-0.1.1
git push


git checkout develop
git merge --no-ff hotfix-0.1.1
git push

git branch -d hotfix-0.1.1

git tag -a v0.1.1 master
git push --tags

Git flow tools

In fact, once you understand the above process, you don’t need to use any tools at all. But in fact, most of us can’t remember many commands and processes. What should we do?

There are always smart people who create good tools for everyone to use, that is Git flow script.

Install

• OS X

brew install git-flow

• Linux

apt-get install git-flow

• Windows

wget -q -O - --no-check-certificate https://github.com/nvie/gitflow/raw/develop/contrib/gitflow-installer.sh | bash

use

• Initialization: git flow init

• Start a new Feature: git flow feature start MYFEATURE

• Publish a Feature (that is, push it to the remote): git flow feature publish MYFEATURE

• Get the published feature: git flow feature pull origin MYFEATURE

• Finish a Feature: git flow feature finish MYFEATURE

• Start a Release: git flow release start RELEASE [BASE]

• Publish a Release: git flow release publish RELEASE

• ReleaseRelease: git flow release finish RELEASE
  Don't forget to git push --tags

• Start a Hotfix: git flow hotfix start VERSION [BASENAME]

• Release a Hotfix: git flow hotfix finish VERSION

Git Flow GUI

Having said so much above, I know some people still can’t remember, then someone has made a GUI tool, you just need to click next, the tool will do these things for you!!!

SourceTree

Once you have initialized Git-flow, basically all you have to do is click on the git flow menu and select start feature, release or hotfix, then select the git flow menu again and click Done Action when you are done. Holy crap, I can’t imagine it being easier than this.

Currently SourceTree supports Mac, Windows, and Linux.

How much does this great tool cost? It's free!!!!

Git flow for visual studio

Good news for VS
GitFlow for Visual Studio