Oh Shit, Git?

(ohshitgit.com)

Show context

pitaj ◴[16 Jan 25 18:42 UTC] No.42729155[source]▶

Some changes I would make:

1. Always use `git switch` instead of `git checkout`

2. Avoid `reset --hard` at all costs. So for the "accidentally committed something to master that should have been on a brand new branch" issue, I would do this instead:

    # create a new branch from the current state of master
    git branch some-new-branch-name
    # switch to the previous commit
    git switch -d HEAD~
    # overwrite master branch to that commit instead
    git switch -C master
    # switch to the work branch you created
    git switch some-new-branch-name
    # your commit lives in this branch now :)

3. I'd apply the same to the `cherry-pick` version of "accidentally committed to the wrong branch":

    git switch name-of-the-correct-branch
    # grab the last commit to master
    git cherry-pick master
    # delete it from master
    git switch -d master~
    git switch -C master

4. And also to the "git-approved" way for "Fuck this noise, I give up.":

    # get the lastest state of origin
    git fetch origin
    # reset tracked files
    git restore -WS .
    # delete untracked files and directories
    git clean -d --force
    # reset master to remote version
    git switch -d origin/master
    git switch -C master
    # repeat for each borked branch

replies(11): >>42729838 #>>42729902 #>>42730974 #>>42731510 #>>42731713 #>>42731798 #>>42731885 #>>42732130 #>>42734933 #>>42737820 #>>42740404 #

lalaithion ◴[16 Jan 25 19:36 UTC] No.42729838[source]▶

>>42729155 #

The disconnect between git's beautiful internal model of blobs, a tree of commits, and pointers to commits, and the command line interface is so wild. All of these recipes are unintuitive even if you have a firm grasp of git's model; you also need to know the quirks of the commands! To just look at the first one... wouldn't it be more intuitive for the command line interface to be:

    # this command exists already;
    $ git switch -c some-new-branch-name
    # is there a command that simply moves a branch from one commit to another without changing anything else? It feels like it should be possible given how git works.
    $ git move-branch master HEAD~

replies(8): >>42729951 #>>42729992 #>>42730629 #>>42730721 #>>42730733 #>>42730978 #>>42731467 #>>42740395 #

Certhas ◴[16 Jan 25 20:49 UTC] No.42730721[source]▶

>>42729838 #

The real "internal model" of git contains much more data/moving parts.

There isn't one tree of commits, there are typically at least two: local and remote

Branches are not just pointers to commits, but also possibly related to pointers in the other tree via tracking.

Stash and index and the actual contents of the working directory are additional data that live outside the tree of commits. When op says "avoid git reset hard" it's because of how all these interact.

Files can be tracked, untracked and ignored not ignored. All four combinations are possible.

replies(1): >>42731353 #

lalaithion ◴[16 Jan 25 21:48 UTC] No.42731353[source]▶

>>42730721 #

None of these seem to preclude a command to make an arbitrary branch point to an arbitrary commit without changing anything else.

replies(2): >>42731671 #>>42732411 #

1. fragmede ◴[16 Jan 25 22:22 UTC] No.42731671[source]▶

>>42731353 #

This works if the branch exists or creates it if it doesn't exist, but not if it's checked out.

    git branch -f branch_name commit

if it's checked out:

    git reset --hard commit

replies(1): >>42734347 #

2. seba_dos1 ◴[17 Jan 25 05:19 UTC] No.42734347[source]▶

>>42731671 (TP) #

> but not if it's checked out

...and for a good reason that should be apparent to anyone who understands git's model (HEAD points to a ref in this case, so if you suddenly change what that ref points to without updating the working tree you create an inconsistency).

You can do that manually of course (with `git update-ref` or even a text editor), but then you get to clean up the mess yourself.

replies(2): >>42734445 #>>42735314 #

3. thfuran ◴[17 Jan 25 05:44 UTC] No.42734445[source]▶

>>42734347 #

Couldn't head just detach without any consistency issue?

replies(1): >>42734522 #

4. seba_dos1 ◴[17 Jan 25 06:00 UTC] No.42734522{3}[source]▶

>>42734445 #

Theoretically it could, but that would be a rather surprising side effect. You could also check the new revision out and leave HEAD intact. Which one of those outcomes you would expect and why?

"error: ref in use by higher layers" makes much more sense to me in this case.

replies(2): >>42735349 #>>42742361 #

5. Certhas ◴[17 Jan 25 08:36 UTC] No.42735314[source]▶

>>42734347 #

To me that looks like git is leaking implementation details left and right.

So much for "a branch is simply a pointer to a commit"...

replies(1): >>42744011 #

6. Certhas ◴[17 Jan 25 08:42 UTC] No.42735349{4}[source]▶

>>42734522 #

If you buy the "git is just a tree of commits and pointers" mental model it's absolutely not a surprising side effect but would be the logical thing to expect. I moved a pointer to a commit around, why would that change where HEAD is pointed.

Turns out it's a tree of commits and pointers to within that tree and a master pointer that come in two versions: pointing towards the pointers or pointing towards the tree. And pointers behave very differently when the master pointer is pointing to them...

Elegant. Simple. :P

replies(1): >>42743939 #

7. thfuran ◴[17 Jan 25 19:37 UTC] No.42742361{4}[source]▶

>>42734522 #

It doesn't seem surprising to me. It probably ought to print ought a warning that head has detached though, like some other commands already do. That error message on the other hand seems very unhelpful. It's lingo that only makes sense if you're neck deep in the plumbing.

replies(1): >>42743972 #

8. seba_dos1 ◴[17 Jan 25 22:26 UTC] No.42743939{5}[source]▶

>>42735349 #

> I moved a pointer to a commit around, why would that change where HEAD is pointed.

...because HEAD points to what's checked out. This pointer does not just exist and hang around, it has its semantics. Not understanding that reveals flaws in your mental model.

Besides, the side affect you find "not surprising" here is... rewriting HEAD to change what it points to. Then you ask "why would that change where HEAD is pointed". Sounds like you may be confused. Are you forgetting that a ref may point not just to a commit, but also to another ref? This is the whole idea behind branches after all, having HEAD point to a ref is exactly what makes branches semantically different from tags - if you don't understand it then no wonder you're confused.

(protip: if you find git's "pointers to pointers" confusing, perhaps because in C a "pointer" and "pointer to pointer" are separate types that make multiple dereferencing steps explicit, think of them as symlinks instead and it should become clearer - that's in fact how symrefs used to be implemented in the past)

When a pointer is in use by higher layers, a good UI will prevent you from making direct changes underneath it unless you force it or go low-level enough for it to not matter. The only sin of git I can see here is that `git` command provides you both high-level and low-level interfaces to manipulate the data structure you're working on with no clear distinction for the user.

9. seba_dos1 ◴[17 Jan 25 22:32 UTC] No.42743972{5}[source]▶

>>42742361 #

There's no such message there, it was a description of a situation written by me and it doesn't even actually match the git's lingo. Should have made it clearer I guess.

It is surprising. You wanted to edit the value of `main` ref, yet suddenly you now edited `HEAD` too without meaning it. Bailing out and letting you actually decide whether you want to do it or not is the correct thing to do for a high-level command like `git branch` (alternatively it could ask you what to do interactively). If you don't want such safeguards and you know what you're doing, use `git update-ref` which will happily let you break whatever you want.

10. seba_dos1 ◴[17 Jan 25 22:37 UTC] No.42744011{3}[source]▶

>>42735314 #

Do you react the same way when an OS prevents you from writing to a file with an exclusive lock placed on it? So much for "a file is simply a collection of data stored as a single object"...

If a git repo was purely a collection of meaningless pointers and graph nodes, git would be a graph manipulation utility, not a version control system. The fact that some of those pointers have a meaning is what makes it useful and it doesn't contradict the fact that what you're working on is still just a bunch of pointers and nodes.

↑