Cat: *walks onto keyboard*
Me: Aww how cute
Cat: $ git reset --hard HEAD

Coworker in my team recently said to boss:

"Thanks, this conversation with you has taught me so much about single-threaded blocking I/O"

Some random PR comments from our company's repository:

"Are you insured? I hope you are insured"

"Learning git is not that difficult. You only need one command: git reset --hard"

*Link to amazon for dog poop bags*
"Please clean up your shit, before I step in it"

"Have you thought about a career in sales? At least there you might sell your bullshit"

Customer: "I want this."
Dev: "Cool! We can do that!"
*delivers product according to spec*
Customer: "Hmm, now that I see it, I want something else instead.."
Dev: "git reset --hard origin/ifreakingknewit"

Coworker: You've merged the wrong PR. It is broken.
Me: is it marked as broken? Is there a mail marking it as broken?
Coworker: yes. I wrote something in the chat.

Me: 🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕

I do NOT read and click every brain fart from the chat. I had the PR (as reviewer and dependent developer) open on my desk and waited for the coworker to fix his merge conflicts.

OK then, try to revert. Git reset hard. Push -f. Policy does not allow master modification. 🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕🖕

Fuck this company. Fuck the policies. Fuck them all with a chainsaw. Forced me to work 2 weeks more. 17.04 should have been my last day at this circus. Let 3 other guys go to vacation while I have fix their management's mistakes. Fuck. You. All. Eat shit and suffocate in piss.

I wish i could git reset --hard my life

Best find of the week:
alias nah="git reset --hard;git clean -df"

alias "git commit"="git reset --hard HEAD"

Git alias

fuckthat=reset --hard

Because it's easier on the eye.

Code with syntax coloring fascinates my young nephew, so after I commit and push, I let him do his thing then later I do a
git reset HEAD --hard

FUCK I stupidly did git reset --hard while having open changes.

Slap me

It was all black, I couldn't see anything but the words:

git reset --hard

And then I woke up.

Me: How can I delete pushed commits from origin?
Colleague: Just do git reset --hard and then git push -f
Me: But this is dangerous
Colleague: Wait, I'll do it myself
Colleague: Done
Me: But nothing happened
Colleague: Fuck. I just removed all changes on my own branch

git reset --hard

2 sec later:
Oh there was that other thing

$ git reset --hard life

Programming while being sick was not a good idea.

That git reset --hard on the other hand was

Boss(In company chat): Guys we only need 100 votes to win this award.Do vote and also push your friends and family to vote.
Me: git push -f origin master
Boss: I'll see you tomorrow.
Me: git reset HEAD --hard.

(I think I am gonna get fired)

"git reset --hard HEAD~1" after push

Life could have been way better if God has used some version control system and let individual take care of their life.

git revert l@$tHaPP¥d@¥

Or

git reset --hard beginningOfLife

Up
Up
Up
Enter

Fuck!
Accidentally hit 'git reset --hard'

git push --force

Because I always push after every commit, when the slightest fuckup happens I just hard reset, commit again, and force push...

...even if it's just a typo in the commit message

Even if you are solo, use version control and commit often. When you are working on something completely new, git reset --hard can really get you out of a bind.

Just delete the whole local repo and clone again!

(He definitely didn't know about git reset --hard head)

Used a starter to scaffold a new project. Have never used that starter before but it has more than 1400 starts on Github.

Two days after.... so far so good. The created project structure used some tools I haven't used before, some are good, others are not so good, but anyway I am towards the first release of my codes. I have done countless 'npm run build', 'npm run test', 'npm run fix', etc., but.... my fault, I haven't committed once since starting the project, thinking I would commit when the next function is implemented, next test case passed.... after all, what could go wrong anyway?

Finally, one last test case passed, I think I will commit and run 'npm publish'.... but wait, had a glimpse of the scripts section in package.json, there's a command named 'all'. An voice came out of nowhere was talking to my subconscious mind, "all.... build, lint, prettier, test..... yeah you should run all... it's another build script, the worst you can get is just some harmless error messages.....", and my fingers typed 'npm run all'...

Time stopped for a few seconds, file structure in project explorer was shifting, files & folders were disappearing & appearing, what's happening... and I looked at the 'all' script closely for the first time....

WHAT THE HELL, WHO SHOULD PUT 'git reset --hard' IN A BUILD SCRIPT WITHOUT ANY PROMPT????!!!!!!!

MY PLAN WAS TO COMMIT AND GO TO SLEEP, IT'S 1AM NOW!!! WHERE CAN I RECOVER THE LOST FILES????

Hitting hard reset on git instead of soft. Lost two days of work.

alias suicide = git reset --hard

I think the reason why git beginners have a hard time with it is because the api is a bit untuitive.

For example: if you want to "unstage" staged changes, you run git reset, and if you want to "delete" those changes from your working copy, you git checkout those files.

But then, you find out that you can do all of that if you git add . and git reset --hard.
So you're like "huh..."

And then you discover that if you end the resethard with a branch name/commit id then you also make current branch point to the commit or that branch/commit (respectively).
So you're like "huh..."

And also if you add a commit id or branch name to git checkout, you change the current branch to specified/enter detached state with HEAD pointing to that commit (respectively).

Oh and you don't use git branch to create branches, you use git checkout -b because it's a lot shorter.

So here's a rundown: git reset mutates things related to files, but also mutates things related to branches.
git checkout also mutates things related to files and mutates things related to branches too (in a diff way). Also, creates new branches.

I don't think this is intuitive. We users use the same commands for different purposes with just a different flag.
Commands shouldn't mutate different types of things. But don't composite commands (as in, "smart" commands that mutate different things) shoudln't be a flag in an existing command, it should be a single new command of its own.

Maybe if I reread the internals of git now, I'll be able to disgest the dozens of technical terms they throw at you (they are many). And in my mind, the api will cognitively fit to the explanations.

Here's another one that feels weird too.
If you want to make your changes start on top of someone else's commit, you do git rebase.
But git rebase -i can be used for that, and also to delete, modify changes or message of, reorder or combine previous commits of the current branch.

Maybe the reason why several things we do overlap with the same commands is because they internally do similar things, and while not separating those commands might make it less intuitive, it makes them more sensible? i dunno...

disclaimer: I'm not setting this opinion in stone though, and am aware that git was created by one of the most infuential programmers.

What a satisfying and yet freaking scary thing when you run

# git checkout -b feature/lostHoursWorkingOnThis
# git reset -- hard <commit from 3 months ago>
# git push upstream master --force

Just when you're at the final sign off of a major change and the business goes "nope, we want to make even more changes before we sign off ok this"

🤷‍♂️out of scope gone wrong!!

Well fuck you, I got shit to deploy, all this work can get out of my way!

TFW when you do a git reset HEAD --hard because nothing works anymore for unknown reasons, and the moment you press Enter, you realize that you havent committed or pushed any of your work for the last three days or so...

TeamWork 1 week before release de projet

Guys i dont know why but all the projet is fuckup in Git ...

Me: where is your firts commit of all these shit ?

He: just there

Me : git reset eb23ae --hard && git push origin HEAD --force

Me: now you sit there and you play with your pencil ! 😡😠

Thx

Begin working on new project

Don't know how to implement a feature

A billion solutions online, understand one of them

Spend hours implementing and google-bug-fixing

Get it working

Incompatible with everything else I want to do

Mfw.jpg

$ git reset --hard HEAD~

git reset --hard

I love git stash.

It's helps a lot for doing refactors to me. I guess it's not the most complex workflow, but it wasn't obvious to me when I started with git. Let me explain.

Refactors. As you start writing the first lines of a refactor, you start to notice something: you're changing too many things, your next commit is going to be huge.

That tends to be the very nature of refactors, they usually affect different parts of code.

So, there you are, with a shitload changes, and you figure "hey, I have a better idea, let me first do a smaller cohesive commit (let's call it subcommit) that changes a smaller specific thing, and then I'll continue with the upper parts of the refactor".

Good idea, but you have a shitload of changes nearly touching every file in your working copy, what do you do with these changes? You git stash them.

Let's say you stash and try to do that smaller "subcommit". What sometimes happens to me at this point is that I notice that I could do an even smaller change inside this current "subcommit". So I do the same thing, I git stash and I work on that even smaller thing.

At some point I end up `git stash pop`ing up all these levels. And it it shows that git stash is powerful for this.

* You never lose a single bit of work you did.
* Every commit is clean.
* After every commit you can run tests (automated or manual) to see shit is still working.
* If you don't like some changes that you had git stashed, you can just erase them with git reset --hard.
* If a change overlaps between a stash you're applying and the last "subcommit", then
if they differ, git shows conflicts on the files,
if they are identical, nothing happens.

with this workflow things just flow and you don't need to wipe out all your changes when doing simpler things,
and you don't need to go around creating new branches with temp commits (which results in bloated temp commits and the work of switching branches).

After you finish the refactor, you can decide to squash things with git rebase.

(Note: I don't use git stash pop, because it annoys the fuck out of me when I pop and you I get conflicts, I rather apply and drop)

What the fuck did I drunk code last night.. git reset --hard to the rescue.

git reset --hard HEAD~1
= throwback Thursday

People who delete a repo and clone again instead of a hard reset because 'they can't undo the changes they made" are the kind of people who shouldn't be using git in the first place.

Fuck Android Studio and Gradle!
Especially Gradle, you fucking slow RAM consuming shit!

It consumed like all of my RAM and my computer is lagging like shit

It can't even import my SVG!

Because of frustration I accidentally hard reset my local git repo and lost 3 hours of work!

I've been using Git since 2014. So why do I STILL cringe whenever I have to revert commits or do a hard reset back to HEAD? What's going to disappear? What will remain? Will my entire Git history be vaporized? It's a total game of Russian Roulette to me. So, without the certainty level I want, I just do what feels safer...I grab the versions of the files I think are what I need and stick them back into my repo, then git status and commit the correct changes back in.

Today I did 'git reset --hard'

Didn't go se well. Time to install BackInTime

So today my colleague is installing new dependency to our react native project and do something cool with it.

Him: I already push it in new branch and make a pr, would you review and merge it to master.
Me: ok let me try first.
.
.
Me: it is not working, i get this error.
Him: try change these xxx in xcode.
Me: ok, wait.
.
.
Me: now I get this error
Him: hmm... Try 'react-native link xxxx'
Me: ok
.
.
Me: I get same error like first error.
Him: now try 'react-native unlink xxxx'
Me: hmm... Wait.
.
.
Me: I still get same error, what's wrong?
Him: I don't know, it's working in my mechine .

*Me 'git reset - - hard' and try to build again.
**After building

Me: hey it's working after I git reset lol.
Him: nice
Me: let me clone it and try 1 more time.

*after cloning and building
.
.
Me: I still get same error like 1st error hahaha.
Him: so try to 'react-native link xxx' again.
Me: OKkK
.
.
Me: still get same error
Him: try git reset and build again
Me: hmm
.
.
*after git reset and build again
Me: I still get same error. I think the correct steps is :
1. Clone
2. Do something in xcode
3. React native link
4. React native unlink
5. Git reset - - hard
6. Build

I can't stop laughing 😂🤣😂🤣🤣😂🤣😂

Accidentally ran

$ git reset --hard

On my 2 weeks worth of uncommited code.
Thankfully Intellij has a local history. 😥

if you're new to git, becareful not to do something like git reset --hard

it works similar to
git checkout --
rm -rf.

and deletes your files that haven't been checked in

Anyone else out there feel like Git is like Charlie Brown’s “stupid kite-eating tree” that just lies in wait at code deploy time to ruin you? I can never get it right. Either I’m doing some edits and realize I’m on the wrong branch or the master is inexplicably ahead of local (or vice versa) and even though I can see in the git log where things went wrong, it’s like crossing a freeway blindfolded and hoping my git fetch or reset or merge doesn’t blow everything to hell. WHYYYY IS THIS SO DAMN HARD?!

git suicide:

git() { if [[ $@ == 'suicide' ]]; then git reset --hard origin/master; git push origin master --force; fi }

So I apparently forgot to encrypt some parameters when sending error reports from our app to the server.
Which means the server tried to decrypt them but couldn´t and just threw an error...

No error logs for the app this week I guess. Yay!

I need "git reset --hard head~1" for my brain this weekend, to get rid of this week...

When not even a
git reset --hard doesnt work anymore, so you just
alias fixeverything="rm -rf /*" and then you just
fixeverything

Handing a Stradivarius to a baboon is better than letting a newbie hard reset a Git repository.

fucking muscle memory added a '^' to "git reset --hard head".

at least it gets faster when you have to write it a second time, but I lost about 20 files