Best practices with GIT Following some standard processes in GIT branching saved numerous nights in figuring what went wrong while merging some branches.

1. Managing releases effectively through Git
- By Mohd Farid

2. Agenda
● Git branching support
● Why branching strategy?
● Introducing git-flow
● Different branches for different purposes
● Different Workfows while using git-flow

3. Git branching support
● Git allows us to create multiple branches.
● Merge any branch into another.
● Pull changes from any branch to any branch.
Note: With great power comes great responsibilities

4. Why do I need a branching
strategy?

5. Git branching strategy - Why it is important ?
Frequent overwriting of my commits by this guy.

6. Git branching strategy - Why it is important ?
Difficult to debug what went wrong from the clumsy tree
structure.

7. Git branching strategy - Why it is important ?
Situation goes out of control: We call the experts …
and they do things like..
git reset HEAD
git reset HARD
and .. evil
Our hearts start beating faster and faster… with each
command they type !!!

8. Git branching strategy - Why it is important ?
We always have a stable branch ready to be deployed to
production.

9. But before we solve it, lets see,
how things go wrong…
The good, The bad and the ugly

10. The Good - Single developer days

11. The Bad - Two developers on the project

12. The Ugly - Multiple developer days..
It definitely needs a genius (+ time) to decipher this tree.

13. What is the way out from this
….. life ?

14. Lets meet a branching strategy.. Git-flow
Git-flow is a way to manage our code such that:
● There are no code overrides by my colleague.
● If something goes wrong, I can easily figure out which
commit failed by referring to a very simple tree.

15. Lets meet a branching strategy.. Git-flow
Ques:
Do I need to learn new set of commands for this
Ans:
NO, We just need to be follow a simple process and
everything will fall in place.

16. Most frequently used commands
git pull origin development
git checkout -b branchName
git commit -am “Commit message”
git merge --no-ff feature-branch
git rebase
git branch -d
git push origin development

17. What is git-flow

18. What are these different kind of branches
● development branch
● feature branch
● release branch
● master branch
● hotfix branch

19. Branches

20. Merging a feature branch into development
1. git checkout development
2. git checkout -b JIRA-103
3. work on the feature.
4. commit your changes to the branch.
5. git checkout development
6. git pull origin development
7. if no new changes are received in the pull
8. git merge --no-ff JIRA-103
9. git push origin development
10. git branch -d JIRA-103

21. Merging a feature branch into development
1. ….
2. if some new changes are received in the pull
3. git checkout JIRA-103
4. git rebase development // Rebasing the current branch (JIRA-
103) with development
5. git checkout development
6. git merge --no-ff JIRA-103
7. git push origin development
8. git branch -d JIRA-103

22. Work flow 1: Working on a feature
1. git checkout development
2. git checkout -b JIRA-103
3. work on the feature.
4. commit your changes to the branch.
5. git checkout development
6. git pull origin development
7. if there are no new changes recieved in the pull
8. git merge --no-ff JIRA-103
9. git push origin development

23. Work flow 1: Working on a feature
1. ...
2. git checkout development
3. git pull origin development
4. if there are some new changes received in the pull
5. git checkout JIRA-103
6. git rebase development
7. git checkout development
8. git merge --no-ff JIRA-103
9. git push origin development

24. Workflow 2: Releasing to production
1. git checkout development
2. git checkout -b release-2.1
3. up the application version and commit this change.
4. git push origin release-2.1
5. test the release branch on staging environment
6. if there are any issues, fix them only on release branch
7. once satisfied, git checkout master
8. git merge --no-ff release-2.1
9. git tag v2.1
10. git push origin master

25. Workflow 2: Releasing to production
...
once satisfied with release-2.1
git checkout master
git merge --no-ff release-2.1
git tag v2.1
git push origin master
git push --tags
deploy the master branch to production.

26. Workflow 3: Addressing the Production issues:
Hotfix branch
Once the master has been deployed to production and there is some issue
on production.
1. git checkout master
2. git checkout -b hot-fix-2.1.1
3. increase the application version.
4. fix the issue and commit the changes.
Merge the hotfix branch on master & development *(if there is no
active release branch. If there is one then merge it on master and the
active release branch. )

27. Workflow 3: Addressing the Production issues:
Hotfix branch
Merging the hotfix branch on master..
1. git checkout master
2. git pull origin master
3. if there are no new changes:
4. git merge --no-ff hotfix-2.1.1
5. git push origin master
6. git branch -d hotfix-2.1.1
if there are changes in master then rebase the hotfix and then merge

28. Workflow 3: Addressing the Production issues:
Hotfix branch
Merging the hotfix branch on development..
1. git checkout development
2. git pull origin development
3. if there are no new changes:
4. git merge --no-ff hotfix-2.1.1
5. git push origin development
6. git branch -d hotfix-2.1.1
if there are changes in development then rebase the hotfix and then
merge

29. Few rules that worked for us..
● Never pull on one branch from another. In order to get those changes,
we do a rebase.
● Delete the feature branches, release branches and hotfix branches
once they are merged into the desired branch/es
● Never commit again on a branch which has already been merged into
the destination branch.
● Use feature branch names like ticket numbers, they help in quickly
identifying the purpose of the branch.

30. Must read..
http://nvie.com/posts/a-successful-git-branching-model/

31. Questions