Git With the Flow!

maintainable git branching strategies

@terminon

github.com/bloveridge

Ben Loveridge

FOLLOW ALONG

bnjm.in/git-strategies

bnjm.in/git-strategies-feedback

LEAVE FEEDBACK

JOIND.IN

joind.in/14039

CODE IS KING

Developer cost

Branching cost

$$$

$

~40 bytes

Poor branching strategy

$$$$

Everything on master

Last good state?

Mistakes break everyone

Leads to big commits

Everything on master

You're probably branching without realizing it.

Branch per release

What is deployed?

Where do fixes go?

Branch per release

Branch per developer

What is being worked on?

How do you switch tasks?

When do you integrate?

Branch per developer

MERGE HELL

What to do?

When do you typically release?

Planned releases

gitflow

    1. http://nvie.com/posts/a-successful-git-branching-model/

   2. http://jeffkreeftmeijer.com/2010/why-arent-you-using-git-flow/

Continuous release

github flow

    1. https://guides.github.com/introduction/flow/

   2. http://scottchacon.com/2011/08/31/github-flow.html

gitflow

It's not as scary as it looks.

Primary Branches

Development branch

Deployment branch

Feature branches

Secondary Branches

Release-prep branches

Hotfix branches

Support branches

Long-lived branches

development

production

Branch naming

"development"

"production"

Feature development

Feature development

$ git checkout -b feature/cart development

$ git commit

$ # rinse and repeat

$ git checkout development

$ git merge --no-ff feature/cart

$ # cleanup

$ git branch -d feature/cart

Feature development

git-flow-avh

Feature development

$ git flow feature start cart

$ git commit

$ # rinse and repeat

$ git flow feature finish cart

Feature development

Preparing a release

Preparing a release

Merge tag into development to keep git-describe awesomeness.

Preparing a release

$ git flow release start 4.2.2

$ vim package.json # update version in package file

$ git commit

$ git flow release finish 4.2.2

Preparing a release

$ git checkout -b rel/4.2.2 development

$ vim package.json # update version in package file

$ git commit

$ git checkout production

$ git merge --no-ff rel/4.2.2

$ git checkout development

$ git merge --no-ff 4.2.2

$ git tag -a 4.2.2

Quick, push a hotfix!

Quick, push a hotfix!

$ git flow hotfix start 4.2.3

$ git commit # fix bug

$ vim package.json && git commit # update version in package file

$ git flow hotfix finish 4.2.3

Quick, push a hotfix!

$ git checkout -b hotfix/4.2.3 production

$ git commit # fix bug

$ git commit # update version in package file

$ git checkout production

$ git merge --no-ff hotfix/4.2.3

$ git checkout development

$ git merge --no-ff 4.2.3

$ git tag -a 4.2.3

Support old versions :(

Support old versions :(

$ git flow support start 1.8.6 1.8.5

$ git commit # fix bug

$ git commit # fix more bugs

$ git tag -a 1.8.6 # tag if you want to, but don't merge it

Support old versions :(

$ git checkout -b support/1.8.6 1.8.5

$ git commit # fix bug

$ git commit # fix more bugs

$ git tag -a 1.8.6 # tag if you want to, but don't merge it

github flow

Primary branches

Master branch

Feature branches

Feature development

Preparing a release

. . . um, we did that already.

summary

Pros

  • good production code always available
  • bug fixes get where they belong
  • release when you're ready
  • supports multiple versions
  • helpers make it quick and easy

Cons

  • multiple long-running branches
  • looks like a lot of steps
  • can feel slower and less agile

gitflow

Pros

  • deploy early, deploy often
  • one branch to maintain
  • integrate often; very agile
  • simple even without helpers

Cons

  • feature toggles
  • doesn't support multiple versions

github flow

Questions?

bnjm.in/git-strategies-feedback

JOIND.IN

joind.in/14039

Leave feedback

Resources

https://guides.github.com/introduction/flow/

http://scottchacon.com/2011/08/31/github-flow.html

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

http://jeffkreeftmeijer.com/2010/why-arent-you-using-git-flow/

https://github.com/petervanderdoes/gitflow

Git With the Flow!

By Ben Loveridge

Git With the Flow!

Creating branches in git is easy, fast, and cheap. When used well, branches can be a powerful tool for good in keeping your code progression and release cycle clear and understandable. When used poorly, branches can make your commit history unhelpful, confusing, or even downright unreadable. We will talk about two popular git branching strategies: Git Flow and GitHub flow. We'll discuss some of the pros and cons of each branching strategy, and what type of deployment strategy each workflow is best suited for. You'll know when to use a feature branch, why you should avoid support branches, and how to quickly fix bugs using a hotfix. Git workflows are strategies, not extensions--the only tool you need is the `git` command! That said, once you know the drill, we'll show how using some simple tools and aliases can make your workflow effortless.

  • 3,125