Making a popping sound with my mouth when I do an array.pop() or git stash pop. Every damn time.

git stash saved my code and my life

My coworker enlightened me with git stash. Just :woah:

Inner Me: Where the fuck is this bug coming from
> Set a breakpoint in every single place where the method I'm using is being called.
> Try calling the method before every function call
Inner Me: FUCKING DAMNIT! It's been hours now
Inner Me: No way it's the library I'm using.
Inner Me: That couldn't possibly be the problem
> Try running it again and delete some more shit
Inner Me: FUCK MEEEEEEEE
> Getting delirious
> Begin to look at some stupid memes.
> Come back to it.
> Have an Ah-ha moment
> Try running it again but rearrange the order of the method calls
> Still no luck
> try git stashing a bunch of my changes
> git stash apply them back
> erase the method call entirely
Inner Me: well that sort of worked, but now all my numbers are incomplete
Inner Me: FUCKING FINE!!! I'LL LOOK IN THE GODDAMN LIBRARY
Inner Me: FUUUUUUUUUUUUUCCCCCCCCKKKKK a stupid integer casting was occuring to my floats!!!

Now Talking to my girlfriend.

Me: The problem was in the library I was using
Girlfriend: How are you going to fix it if it's in the library?
Me: ... I can, because I wrote the library...
Me: FUCK ME RIGHT?
Me: I guess moral of the story; sometimes the problems starts with ourselves
GF: Hahaha. Thats Deeep

I'm going to a friend's house because his computer won't boot. In case I don't return, please clear my git stash. No one needs to see that kind of crap.

Random shower thought: A sticky note is like a manual version of git stash.

git stash is ❤️

An intern came to us with a build issue, it was very difficult to pin point the cause of issue as there were many modified files in the project. So to figure out the cause one guy git stashed lot of fiiles. Now, intern being not aware of the git stash command thought that all his changes are deleted. The way he freaked out thinking all his changes were lost was amazing. Also other people jumped on the bandwagon, and started questioning the developer that how can you delete the changes of an intern. It went like this for 10 min and finally we told the intern that his changes are safe.

Been working with Git every day for the last 3 years and never had a problem with it.
Enters Windows.Stash changes, tries a simple stash apply:

error: cannot stat *file_name*: Permission denied

Please tell me you are fucking kidding me.. I did not just fucking lose all that work..

:q life

I don't want to ctrl+z my family.
But is there a way to git stash the lot till I get this project done?

git stash poop

Annoying git cli inconsistencies:

git branch --list
git stash list

Lost count of the times I have entered

git branch list

When you use a git command you don't really understand and it fucks up your day!!!!!!!

When you're wondering where all your work went and realize the IDE stashed it because you forgot to commit before merging/changing branches.

WTF PEOPLE!!
Some people really need to read their error messages.

Just now I got this teammate asking me how he should handle the error git returned. The error message stated: "Please commit your changes or stash them before you merge." He asked me what he should do to fix the error... I was astonished by his stupidity that he did not read the fucking error message.

Almost every fucking time a teammate comes to me with the question how to fix an error, there is a message that says how to fix the error. Why don't they read them?!?! I told you so many times to read your fucking error messages!!!

I'm really glad the project is over in a couple of weeks and I get a new team..

Yet another rant on cooperate world

The other day my colleague was telling me that he was with very senior architect (so called architect, who keeps on changing things on the fly) and when my colleague was telling that he doesn't have resources to work with, this senior architect opened up stash (Atlassian Git) and opened up profiles with names and was looking at commits in the git...and said "this guy doesn't have commits for long time...he is free"

WTF.... 0 0

Why is there `git stash pop` but no `git stash rock`? Come on, man!

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)

Dev Confession:
I wrote a bunch of code today that created more problems than it solved. I did not commit it. I used git stash to hide it. It took me hours to write. I didn't do a test on a small section of code beforehand. Literally hours of wasted man hours.

At least I didn't commit this garbage into the repo. The approach was fine, but the architecture made it a non-solution. Now I need to redesign this code or leave as is. It is production code I cannot just "change" on a whim.

I have officially dubbed this week as confession week. This should be a world wide thing. People should fess up to their terrible deeds. Lets start a trend and confess to our misdeeds in code and life. Make the world a better place!

What do you say?

What the fuck!!! Do I really have to explain `git stash` more than 2 times? 😬😬😬

git stash pop'd on wrong branch, hadn't realized it until after a bunch more work. Then continued screwing things up and unit tests are failing.

This is not a good coding day.

I keep typing `git stash poop` … am thinking of creating an alias for it

Hey DevRant, this is my first time working collaboratively on a project with Git and I'd like to know what's the best strategy to adopt.

Is it that every member has their own branch on origin that they push to, then we meet and plan out merges when it's time to release? Or does everyone just push to master, but stash or commit their local changes before they pull?

It's a Greenfield project, with just a bare repository on the central server. It's an MVC app where I've decided to do the View & Controller portions and the other person is doing Models and data services layers.

f()
{
cd "$1"
git stash ; git stash drop
while git checkout HEAD^; do : ; done
for b in $(git branch | tail -n +2)
do git branch -D "$b"; git checkout -b "$b"; git push -f; done
for t in $(git tag); do git tag -f "$t"; done
git push --tags -f
}

for p in $(find "$HOME" -type d -name .git ) ; do f "$p"/.. & done

How dangerous am I?
I code it live.

I code while people are working on our website and make all the changes live. And if I notice an abrupt stop in responses to our logs I git stash my changes.

temp commits are generally more useful than git stash.

instead of stashing, do a commit with a message like "THIS IS NOT A COMMIT, DON'T INCLUDE THIS". with some discipline you can then go back to your branch, `git reset --soft HEAD~1` and voila, it's similar to a `git stash pop`.

but it's better because you can do this in multiple branches at the same time and there's no fear of accidentally dropping some stashed commit.

What if life was on git? Where you can simply create new branches of it, stash shit, remove dumb people with dependencies and finally the ability to turn back time with this version control.

using git stash because i'm too lazy to retrace all the steps I did to create this mess.

So let's talk about today, spent the whole night awake fixing some code PYCHARM FUCKED UP! Technically i fucked up but I still blame pycharm for making the project structure a mess. Word of advise don't create a project with pycharm , I should have made mine on the terminal as all things of worth should be.

Gotta push the presentation for it to afternoon am beat . I've learned a lot though, recovering lost files is a bitch . And funny thing is i got saved by a git stash that had been auto saved earlier by accident 😂😂

Goodjob Self, you fucked up your Git local repo.
```
[ git checkout master || git stash ]

fatal: git-write-tree: error building trees
Cannot save the current index state
```

So I stashed my changes to switch branches and quickly fix a f**k up, then I switched back and went to 'pop' the stash.... only I didn't click 'pop' I clicked...'delete' and GitKraken or ShitKraken as it should be called, didn't ask for confirmation... it just deleted all my changes. FML

I always ask my teammates to git by saying
"git commit repeat"
I need a more catchy line to using which I can ask them to git.

Can you suggest?

Has anyone ever faced problems with VS Code Git GUI and git in terminal?
:/
I use the gui for some stuff and the terminal gets out of sync.
So it's like I have discarded changes from the gui and then WSL still says I have changes when changing branches, so I try to stash and it says there are no changes. It gets really frustrating.
😕

Git: "Your local changes to the following files would be overwritten by checkout. [...]
Please commit your changes or stash them before you switch branches.
Aborting"

Fucking nitpicking, that's not "Aborting", that's meant to be:
"Dear user, would you like to overwrite your current changes, even more so as you are currently in a so-called detached head state anyway, as you obviously just checked out an old tag to try a temporary rebuild of an old project state."
Yes, the build targets are checked in, as this can be very useful in some scenarios.
It's just! some! CSS! from the SCSS!
Stop "Aborting"!