Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Does git branch -m have side effects for other developers?

Tags:

git

branch

merge

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?

like image 666
Jim Puls Avatar asked Mar 31 '09 23:03

Jim Puls


People also ask

Can 2 developers work on the same branch?

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.

What happens when you git branch?

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.

Is git branching good?

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.


1 Answers

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.

like image 113
Pat Notz Avatar answered Oct 21 '22 06:10

Pat Notz