I'm going to sit down and actually learn git this week

git out

Sit and git

Also, a way to never have to work again!

git reflog, you can get your old commits back

this is easily fixed by copy pasting the files into a new directory and never opening git again out of fear

One key thing that can help you wrap your head around rebasing is that branches get switched while you're doing it; so, say you're on branch feature and do git rebase master, for any merge conflict, whatever's marked "current" will be on master and what's "incoming" is from feature.

There's also git rerere that should in theory remember a resolution you do between two branches and reuse it every time after the first; I've rarely used it in practice; it would happen for long lived branches that don't get merged.

LazyGit may actually be black magic from Satan to tempt programmers into sin. And to that I say: 'where is a goat I can sacrifice to my dark lord?'

Wow this looks great. Amend an old commit dealing with a rebase? Sign me up!

I'd still probably prefer the usual CLI for setup, commits, pushes etc. but this looks like a godsend for any branching/rebasing operations!

It was conceived for experts so the new user experience is shit and the UI is not intuitive. But it has become such a widespread standard that it is very hard to completely overhaul the UI.

Yeah. It's got no abstraction between the UI and the implementation. You just want to manage code versions, but to use Git, you need to learn how to manage history graphs.

Oh, you haven't seen my lack of skill then.

This is great, but I just want to say that the best way to use git is to simply stop doing so much in one branch. Branches should not last longer than a week, ideally

this is bad advice. Never force git to do anything. If you're forcing something you're doing it wrong.

you can always git fetch -a; git merge -X theirs remote-branch or rebase your branch.

git gud. HA, GOTTEM

It's what americans from a rural area say when they want you to go away.

is what people who don't know vim and rsync have to use to mimic 1% of our power

It's the thing you use to create a local copy of the main code base, and then merge your changes back in.

OP hasn't done anything, and there's 7 conflicts between his code and main. Presumably because someone else merged their changes in the time between when OP pulled his local copy and tried to push his (non-existent) changes.

A very complicated way to do

My project
My project (1)
My project WORKING
My project (2)
My project (2) (1)

git gud

Go, Team Rebase!

sccs

1973

rcs

1982

git

2005

How long are your years?

Subversion is as good as it can get with centralized version control system.

CVS is only one step up above FTP file server for all your code.

Solving merge conflicts or rebasing is not simple

If it was dead simple you wouldn't need to learn 10 new concepts and google commands regularly even after using it for a couple of years. You probably forgot how you struggled at first. I have taught it multiple times and I see how beginners struggle.

It's not THAT complicated but I wouldn't call it dead simple. When you understand how git works internally yeah it's pretty simple but people usually start with the idea that it's a tool to put your code on a server to synchronize with other people and only later learn that you have both a local and a remote (or multiple remote) tree and how the tree really works.

I think the problem is most git 101 tutorials teach it wrong, IMO the best git tutorial is this: https://wildlyinaccurate.com/a-hackers-guide-to-git/

Unfortunately it's pretty dense so it's gonna scare off a lot of newbies.

I would actually say it's VERY complicated but in daily work you probably need like 5 commands and those aren't hard at all.

Its not dead simple but its also not extremely complex.

I'm currently working with some interns and there's just concepts they were never exposed to. Without decent mentoring, git can be difficult because a lot of the workflow does come with experience.

That being said everyone needs to stop acting like its an impossible task to properly do source control. There is some truth that if you don't care enough to do your source control, you don't care enough to write decent code. Its not a moral failing, just take some pride in your craft.

Show the newbies how to care and they'll care enough to want to do it right. Measure twice, cut once and all that.

It's definitely not simple to use but I agree that the conceptual model it represents is straightforward. I think a lot of the problems people have with git come from not understanding the underlying data structure before learning how to manipulate it.

sublime merge is pretty great, but having a working familiarity with the underlying tool is invaluable when shit inevitably goes sideways while collaborating

In my experience, using GUIs is how people fuck themselves, and then I have to unfuck them via the command line.

Git's interface is bad, yes. It has a step learning curve, yes. But I truly think the only real way to overcome those obstacles is to learn how git works, learn all the nitty gritty details, not hide from them.

lazygit or tig are terminal interfaces for git. very nice, best of both worlds imo. every action shows the git command ran at the bottom, and its a lot easier to see at a glance the status, diff, log, etc.

My take is use a GUI for anything read-only/nondestructive (i.e. anything that won't modify your local or remote state). It's nice for example to compare the state of two branches.

For anything that does changes make sure you know what's happening under the hood, otherwise you might shoot yourself in the foot. It's convenient for example to do a commit and push in one go, but then you lose the ability to edit any changes (you're forced to either do another commit, or change your local commit and force push).

In VSCode you can go to the Output pane and switch to Git - there you'll see everything that gets done through Git's CLI for whatever you do through the GUI (although it can be a bit noisy); same goes other GUI utils.