We've already learned how to switch which branch points to what using git branch -m
. If I do this, is it going to make life difficult for the other people pulling from my repository?
Say I do a bunch of stuff on a branch topic1
and then do a
git branch -m master old_master
git branch -m topic1 master
git push origin master
and then somebody else pulls master
from the my remote repository, what will they have to do to make everything point to the right place? Will I have to tell everybody to repeat my steps?
Is this akin to the problem of rebasing commits after pushing them and leaving other developers with dangling objects?
For every discreet feature (bug, enhancement, etc.), a new local branch is made from dev. Developers don't have to work on the same branch, since each feature branch is scoped to only what that single developer is working on. This is where git's cheap branching comes in handy.
The git branch command lets you create, list, rename, and delete branches. It doesn't let you switch between branches or put a forked history back together again. For this reason, git branch is tightly integrated with the git checkout and git merge commands.
The Benefits of GitHub Flow Because of the simplicity of the workflow, this Git branching strategy allows for Continuous Delivery and Continuous Integration. This Git branch strategy works great for small teams and web applications.
I'm not exactly sure what your repo looks like but here's the worst-case scenario.
Suppose your origin
repository looks like this
origin: o---o---A---B---C master
And your local repository looks like this,
JimPuls: o---o---A---B---C master, origin/master \ D---E---F topic1
Then, after your branch renames your local repository looks like this:
JimPuls: o---o---A---B---C old_master, origin/master \ D---E---F master
Now, when you push master
to origin
that'll be a non-fast-forward update. After the push, the origin
repository will look like this:
origin: o---o---A...B...C (B & C are orphaned commits) \ D---E---F master
This can be cruel to your friends who may have done commits on top of C
. For example, if Sally was working with you her repository may look like this:
Sally: o---o---A---B---C origin/master \ G---H---I master
Now, if you do your non-fast-forward push and Sally does a fetch
her repository will look like this:
Sally: D---E---F origin/master / o---o---A---B---C \ G---H---I master
Now Sally has to figure out how to get her work (G, H, I) back into the repository. If she simply does a merge with origin/master
then the changes in B and C will be back in the repository (oops!). Instead, she'll have to cherry-pick
or rebase
her G-H-I changes onto origin/master
.
It's cool that Git lets you do that but it's kind of asking for trouble. You're really hoping that Sally notices the situation. This is why you should warn all the other contributors when you do this so they can deal with the change appropriately.
NOTE: the above is a worst-case scenario. If your topic1
branch departed from master
at C then that change is a fast-forward and there are no problems.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With