Asked: August 10, 2024In: Programmers

How do I undo the most recent local commits in Git?

CodieGirl Enlightened

Added an answer on August 10, 2024 at 7:42 pm

Undo a commit & redo $ git commit -m "Something terribly misguided" # (0: Your Accident) $ git reset HEAD~ # (1) [ edit files as necessary ] # (2) $ git add . # (3) $ git commit -c ORIG_HEAD # (4) git reset is the command responsible for the undo. It will undo your last commit while leaving yourRead more

Undo a commit & redo

$ git commit -m "Something terribly misguided" # (0: Your Accident)
$ git reset HEAD~                              # (1)
[ edit files as necessary ]                    # (2)
$ git add .                                    # (3)
$ git commit -c ORIG_HEAD                      # (4)

git reset is the command responsible for the undo. It will undo your last commit while leaving your working tree (the state of your files on disk) untouched. You’ll need to add them again before you can commit them again.
Make corrections to working tree files.
git add anything that you want to include in your new commit.
Commit the changes, reusing the old commit message. reset copied the old head to .git/ORIG_HEAD; commit with -c ORIG_HEAD will open an editor, which initially contains the log message from the old commit and allows you to edit it. If you do not need to edit the message, you could use the -C option.

Alternatively, to edit the previous commit (or just its commit message), commit --amend will add changes within the current index to the previous commit.

To remove (not revert) a commit that has been pushed to the server, rewriting history with git push origin main --force[-with-lease] is necessary. It’s almost always a bad idea to use --force; prefer --force-with-lease instead, and as noted in the git manual:

You should understand the implications of rewriting history if you amend a commit that has already been published.

What is the HEAD in git?

CodieGirl Enlightened

Added an answer on August 10, 2024 at 7:41 pm

This answer was edited.

I always thought HEAD~5 means go to 5 commits before. But it doesn't carry the GO part of the command. It only carries the reference part of the command. What you can do with that reference varies by the command you select In layman terms it's used to answer the question of: WHERE should I go? To whRead more

I always thought HEAD~5 means go to 5 commits before. But it doesn’t carry the GO part of the command. It only carries the reference part of the command.

What you can do with that reference varies by the command you select In layman terms it’s used to answer the question of: WHERE should I go? To which commit?

HEAD means (the reference to the) current commit
HEAD~1 means (the reference to) 1 commit before
HEAD~ ALSO means (the reference to) 1 commit before
HEAD~87 means (the reference to) 87 commits before
HEAD~3..HEAD means from 3 commits to current commit (in total 3 commits)

Usage:

git checkout HEAD~1 will actually GO/checkout to 1 commit/reference before
git reset HEAD~3 will uncommit your last 3 commits — without removing the changes, ie you can see all the changes made in the last 3 commits together, remove anything you don’t like or add onto it and then commit them all again.
git reset --hard HEAD~3 will uncommit your last commit and remove their changes. It will completely remove those changes.
git diff HEAD~3 to look into the changes of the last 3 commits
git diff someFile HEAD~3 to look into the last 3 changes of a specific file
git revert --no-commit HEAD~3..HEAD. Reverts 3 commits, without automatically commiting i.e. you have to do git commit -m yourself.
git rev-parse HEAD~2 outputs the SHA of two commit before.
See all changes between a pull request and main. It’s a multi-step process.

git fetch origin/feature22
git checkout feature22
git merge-base feature22 main # will return the SHA of their 050dc022f3a65bdc78d97e2b1ac9b595a924c3f2
git reset 050dc022f3a65bdc78d97e2b1ac9b595a924c3f2

You could just do git reset main, but that only works if your colleague who created the pull request has the latest changes with main. If they’re working on a big feature (and haven’t merged with main for a couple days) and you just want to see what additions they have after their last pull from main, then you have to follow the steps above.

More Detail:

Make sure you see this answer for What is a detached HEAD. It has some good info on cat .git/HEAD

Out of scope, but super interesting: Other than HEAD, there are other kinds of heads. See git revisions: ORIG_HEAD

ORIG_HEAD is created by commands that move your HEAD in a drastic way, to record the position of the HEAD before their operation, so that you can easily change the tip of the branch back to the state before you ran them

To undo a git merge

git reset --hard ORIG_HEAD

ORIG_HEAD: is set only as part of something dangerous like a hard reset, where the old head would otherwise have no reference.

MERGE_HEAD I got this error message after I tried to merge again before concluding an existing merge

fatal: You have not concluded your merge (MERGE_HEAD exists). Please, commit your changes before you merge.

To fix this, I had to conclude my merge. Then do another merge. FETCH_HEAD

records the branch which you fetched from a remote repository with your last git fetch invocation

CHERRY_PICK_HEAD

records the commit which you are cherry-picking when you run git cherry-pick.

More official explanation

Highly recommend to see this page from the docs. Git as a system manages and manipulates three trees in its normal operation. (By “tree” here, we really mean “collection of files”, not specifically the data structure.) The role of HEAD is:

Tree	Role	My Explanation
Head	Last commit snapshot, next [future] parent	Something stored in the stone. Fully recorded. Will be the parent record of the next record/commit.
Index	Proposed next commit snapshot	Something stored in paper. Is likely to be recorded permanently in the stone. You can remove/alter your paper. Unlike records/commits stored in the stone, if you remove or alter the paper, then you don’t have a record of its previous state.
Working Directory	Sandbox	A playground environment. From here you decide if you want to store something in paper, so you can later store in stone.

HEAD is the pointer to the current branch reference, which is in turn a pointer to the last commit made on that branch. That means HEAD will be the parent of the next commit that is created. It’s generally simplest to think of HEAD as the snapshot of your last commit on that branch.

tldr HEAD is always moving you in between commits, it doesn’t help you move between staging steps or sandbox.

See less

- 2

Asked: August 10, 2024In: Programmers

What is Detached HEAD?

CodieGirl Enlightened

Added an answer on August 10, 2024 at 7:40 pm

If git was to rename detached HEAD I would have it named as a HEAD that isn’t identified by a branch and will soon be forgotten. We as people can easily remember branch names. We do git checkout new-button-feature / git checkout main. main and new-button-feature are easy to remember. And we can justRead more

If git was to rename detached HEAD I would have it named as a HEAD that isn’t identified by a branch and will soon be forgotten.

We as people can easily remember branch names. We do git checkout new-button-feature / git checkout main. main and new-button-feature are easy to remember. And we can just do git branch and get a list of all branches. But to do the same with just commits you’d have to do git reflog which is very tedious. Because you have thousands of commits but only very few branches.

A detached commit’s identifier is just its SHA. So suppose you checked out a commit (not a branch) i.e. you did git checkout d747dd10e450871928a56c9cb7c6577cf61fdf31 you’ll get:

Note: checking out ‘d747dd10e450871928a56c9cb7c6577cf61fdf31’.

You are in ‘detached HEAD’ state.

…

Then if you made some changes and made a commit, you’re still NOT on a branch.

Do you think you’d remember the commit SHA? You won’t!

git doesn’t want this to happen. Hence it’s informing your HEAD is not associated to a branch so you’re more inclined to checkout a new branch. As a result below that message it also says:

If you want to create a new branch to retain commits you create, you may do so (now or later) by using -b with the checkout command again. Example:

git checkout -b

To go a bit deeper a branch is built in a way that it’s smart. It will update its HEAD as you make commits. Tags on the other hand are not meant to be like that. If you checkout a tag, then you’re again on a detached HEAD. The main reason is that if you make a new commit from that tag then given that that commit is not referenced by anything (not any branch or tag) then still its considered a detached HEAD.

Attached HEADs can only happen when you’re on a branch.

HEAD is a pointer, and it points — directly or indirectly — to a particular commit:

Attached HEAD means that it is attached to some branch (i.e. it points to a branch).

Detached HEAD means that it is not attached to any branch, i.e. it points directly to some commit.

To look at from another angle, if you’re on a branch and do cat .git/HEAD you’d get:

ref: refs/heads/Your-current-branch-name

Then if you do cat refs/heads/Your-current-branch-name then you’d also see the SHA of the commit that your branch is pointing/referencing to.

However if you were on a detached HEAD you and cat .git/HEAD you’d just get the SHA of the commit and nothing more:

639ce5dd952a645b7c3fcbe89e88e3dd081a9912

By nothing more I mean the head isn’t pointing to any branch. It’s just directly pointing to a commit.

As a result of all this, anytime you checkout a commit (without using the branch name to checkout), even if that commit was the latest commit of your main branch, you’re still in a detached HEAD because your HEAD is not pointing to any of your local branches. Hence even checking out a tag will put you in a detached HEAD. To add onto that, even checking out a remote branch that you have fetched into your computer would result in a detached head ie git checkout origin main would also end up as a detached head…

Summary

All of the following will cause detached head:

checkout any commit
checkout any tag
checkout any remote branch

You’re only on an attached head, if you’ve checked out a local branch

See less

- 3

Asked: August 10, 2024In: Programmers

Quota exceeded for quota metric 'Requests' and limit 'Requests per minute' of service 'mybusinessaccountmanagement.googleapis.com'

CodieGirl Enlightened

Added an answer on August 10, 2024 at 7:20 pm

I get this error after making my first request: Quota exceeded for quota metric 'Requests' and limit 'Requests per minute' of service 'mybusinessaccountmanagement.googleapis.com' How can I be over my quota after my first request? if(File.Exists(ApplicationVariables.CertPath)) { GoogleCredential credRead more

I get this error after making my first request:

Quota exceeded for quota metric ‘Requests’ and limit ‘Requests per minute’ of service ‘mybusinessaccountmanagement.googleapis.com’

How can I be over my quota after my first request?

if(File.Exists(ApplicationVariables.CertPath)) { 
                    GoogleCredential credential;
                    using (var stream = new FileStream(ApplicationVariables.CertPath, FileMode.Open, FileAccess.Read))
                    {
                        credential = GoogleCredential.FromStream(stream).CreateScoped("https://www.googleapis.com/auth/business.manage");
                    }

                    // Create the service.
                    var service = new MyBusinessAccountManagementService(new BaseClientService.Initializer()
                        {
                            HttpClientInitializer = credential,
                            ApplicationName = "Google Reviews Downloader",
                        });

                    //var bookshelves = await service.Mylibrary.Bookshelves.List().ExecuteAsync();
                    var accounts = await service.Accounts.List().ExecuteAsync();

                    Console.WriteLine("accounts:" + accounts);

                }

See less

- 2

CodieGirl

How do I undo the most recent local commits in Git?

Undo a commit & redo

Further Reading

What is the HEAD in git?

Usage:

More Detail:

More official explanation

What is Detached HEAD?

Summary

Quota exceeded for quota metric 'Requests' and limit 'Requests per minute' of service 'mybusinessaccountmanagement.googleapis.com'

The header length of an IPv6 datagram is _____.

How to approach applying for a job at a company ...

In the IPv6 header,the traffic class field is similar to ...

CodieGirl

Stevemark

Ragini

Crypto Rover

Lark Davis