Question

I’m starting to learn Git, reading the ProGit book from time to time. I’ve heard that the most powerful feature of Git is the branches, so I tried to use them. I’m hacking on the KDE project, so there is a remote server and a local copy.

So here’s my situation. I’ve coded a bugfix, but the developer responsible for that code area has gone offline without having given me a shipit, so I decided to do a different fix in the meantime. I’ve heard that branches can (and more importantly, should) be used for such situations. OK, I created a local branch

git branch bugfix

then switched to that branch

git checkout bugfix

ad then discovered that the files I had modified for the original fix were still modified. (Of course, I needed a clean directory to be able to push only the second bugfix without the first one.) Well, no problem, I thought, let’s reset if that’s what git status tells me to do. I did a reset and indeed got a clean dir. But hey, after I switched back to master

git checkout master

the modified files were no longer modified there! It was a clean dir.

Now what’s the point of branches? Can’t have two versions of a file, modified in one branch and unmodified in another one? I know about git stash, but if I do that, unstashing the changes will kill the second bugfix, because IIRC stash simply replaces one file with another one, no merging is done.

What am I doing wrong here? Why is it impossible to have the file modifed in one branch and unmodified in another?

Answer 1

So, here’s what happened. You started off with a commit A from the original developer. You fixed some bugs and now you’re in B. There’s a remote branch pointing to A called origin/original-branch, and there’s a local branch pointing to B called my-changes. I don’t know what they’re actually called (use git branch -a to list them).

....->  A  ->  B
        ^      ^
        |      +-- my-changes
        |
        +-- origin/original-branch

If you’re on B and you make a branch and start making changes, you’ll get this:

....->  A  ->  B  ->  C
        ^      ^      ^
        |      |      +-- bugfix
        |      |
        |      +-- my-changes
        |
        +-- origin/original-branch

This is not what you want. You want this:

               +-- my-changes
               v
....->  A  ->  B
         \
           ->  C
        ^      ^
        |      +-- bugfix
        |
        +-- origin/original-branch

So you have to make your new branch start where the other developer’s branch is.

git branch bugfix origin/original-branch
git checkout bugfix

That specifies that the new branch starts from the other developer’s work. If you do this instead:

git branch bugfix # not what you want

This will cause the bugfix branch to start from wherever you are right now.