Are there crucial differences between stashing, pulling & popping vs. commiting & pull --rebase?

Question

My workflow goal is often to avoid a meaningless merge. To accomplish that I often do one of two things: - I commit my changes and `git pull --rebase` to prevent an unneeded merge. If I later wish to change an existing commit I make changes, commit and merge them in using `git rebase --interactive` - I simply `git stash` my changes and then `git pull` normally and simply `git stash pop` these changes later when I wish to modify and /or commit them. Some colleagues warned me that `git stash save` / `git stash pop` are unsafe. I am wondering if there are any subtle advantages to using commits and `git pull --rebase` vs. the stash list.

Accepted Answer

TL;DR version

Using `git stash` avoids the "meaningless merge" only if you have no commits of your own. The `git pull --rebase` method is more general.

Long, tutorial-ish version: what's happening, why, etc.

Using `git stash` just makes some commits,1 so to a first approximation, stashing and committing are basically the same. The stash commits take the form of what I like to call a "stash bag", which is hung off the tip-most commit of whatever branch you're on when you do the `stash`.

The first difference is that the stash-bag commits do not move the tip of the branch. That is, suppose the branch (let's call it `devel`) looks like this:

```
... <- E <- F     <-- devel
```

then after stashing, it looks like this:

```
... <- E <- F     <-- devel
            |\
            i-w   <-- "the stash"
```

(This is an ASCII-art depiction of [part of] the "commit graph": commit `F` is the tip of the branch. Commit `F` has, as its parent commit, commit `E`: `F` "points back to" `E`. Meanwhile `E` points back to its parent, and so on. The name `devel` simply points to the tip-most commit, which is `F`.)

If you did a regular commit, you'd get a new commit `G`, pointing back to `F`, and `devel` would be changed to point to `G`, "moving the tip forward".

The second difference with `git stash` (vs `git commit`) occurs at the "other end", as it were. When you run `git stash apply`,2 what git does is much like the following. (There are many implementation details that make an accurate description tough, but I think this is the way to think about it. If you `apply --keep-index` it's more complicated; keep in mind that this simplified picture is only "close enough" for the non-`--keep-index` case.)

- Diff the stash-bag against the commit it's hung from.

- Then, apply that diff as a patch to wherever you are now, using git's merge machinery to do a better job than just a simple straightforward patch. (I.e., git can tell if parts of the patch were already done, and if so, skip them.)

To see how this applies to your situation(s), we have to look at what `git pull` does, both with and without `--rebase`.

The `pull` command is best described as `fetch`-then-`merge`. (It even says so in the manual pages for it.) With `--rebase`, it's best described as `fetch`-then-`rebase`. So we have two very different cases with the two different ways of invoking `pull`.

The `fetch` step is easy enough to describe. You `fetch` from some "remote", which tells git to call up the remote repository over the Internet-phone :-) 3 and ask it what branches and commits and such it has. Then your git has their git hand over any new goodies, which your git stores away in your repository, so that you have everything they do, plus of course anything of your own.4

Again, let's say that you are on branch `devel` and you run this kind of `git fetch` step. Let's say further that when you do that, branch `devel` looks like this:

```
... E - F - G   <-- devel
```

When your git contacts their git, it may find new commits that you did not have before, such as commit `H`, which points back to some earlier commit as its parent.

Perhaps `H`'s parent commit is commit `G`. For this to happen, though, your colleague has to have had commit `G` already. Thus, assuming you made `G`, you need to have published (pushed) it, so that she got it, and made her `H` based on `G`.

But presumably you have not yet pushed `G`, and her commit `H` points back to `F`. That's the more general case, so let's draw it:

```
... - E - F - G   <-- devel
            \
              H   <-- (her/their idea of what "devel" looks like)
```

Since commit `G` is private to your repository, she, like everyone else, thinks the chain goes `E - F - H`. You must now do something to incorporate "your commit" together with "her commit".

The way that's the most accurate description of the work that occurred, is for you to make a new merge commit `M`:

```
... - E - F - G - M   <-- devel
            \   /
              H
```

This is what `git merge` will do, so it's what will happen with a plain `git pull`.

The annoying thing with being completely accurate, history-wise, is that it gets you these "meaningless merges".5 So what you can do is, instead, copy your old commit `G` to a new, slightly-different commit, `G'`. There will be two changes between `G` and `G'`: (1) in the work-tree associated with `G'`, you'll include her changes from `H` first; and (2) in `G'`, you'll say the parent-commit is `H` rather than `F`. This will look like this—let's move your old `G` up to make the line go `E - F - H`:

```
              G       [no longer needed, hence abandoned]
            /
... - E - F - H - G'  <-- devel
```

This is a "rebase" operation: copy your existing commits, changing their work-directory contents as needed, tacking the new commits onto the appropriate place (`H`), and then making your branch-tip point to the last commit in the new copies.

This works even if you made a whole bun…

Are there crucial differences between stashing, pulling & popping vs. commiting & pull --rebase?

Solution

Problem

Related problems