I'm so used to git at ths point I haven't really thought about that, but yeah that's jibberish

I had this printed beside my desktop for a while.

```
ITT: people who compare Git to CVS as if there were no other modern DVCSes around.

At our company we use Mercurial. It takes us approximately a day of real work (or say half an hour of teaching time) to teach new people who have never used VCS how to use basic commands, including merge and rebase. The only actual entity in Hg is a "changeset", which can have multiple parents and children and an optional branch name ("default" by default). It's trivial to understand.

OTOH it's 2016 and I myself still can't fucking use git. What's the difference between fetch and pull? How do you checkout a specific commit? What do all the resets do? How the fuck do branches even work? What's the point of a version control system when all you do is edit history all day? ELI5.
```
<https://www.reddit.com/r/programminghorror/comments/4qsywz/rant_git_sucks/>

I love how idiots keep throwing "it stores history like a Directed Acyclic Graph", as if it explained anything. I know what a DAG is, and it doesn't make understanding git's workflow any easier.

https://github.com/sympy/sympy/wiki/Git-hg-rosetta-stone

This also has a great table.

```
hg revert -a | git reset --hard
hg revert some_file | git checkout some_file ```

`hg resolve -a -m` vs `git add -u `

What does `git add -u` do? Well, here's the docs:
```
Update the index just where it already has an entry matching <pathspec>. This removes as well as modifies index entries to match the working tree, but adds no new files.```

Good for the index, I guess. Or maybe not?

I really want to strangle programmers that think generic abstract words, like "index", "context", "entry", "ref", "spec", etc, are meaningful.

What's the equivalent documentation for `hg resolve`?
```
hg resolve [OPTION]... [FILE]...

redo merges or set/view the merge status of files```

yeaht at this point I'm just so used to git I don't even question it. We use it super basic internally - nothing fancy - and everyone preserves the rules enough we have maybe max 1 issue a year

and that issue is usually resolved by just rebuilding a branch or going through stuff with meld

git really is the C++ of the VCS world - a ton of features and everyone uses it differently so you can be a master of it and still not understand what the fuck is going on with someone elses stuff

Except good C++ programmers understand very well how it works, and they can look up quickly what they don't know. Not so much with `git`.

not sure that's true. So many features have been neglected in C++ that soemtimes it's a mystery

I had a physical copy of the C++ standard for a while to look up arcane things

As Stroustrup said, "legacy systems are systems that are known to work."

[*techie arrives*] "what seems to be the problem?"
[*points to TV, NAS and router*] "not streaming media properly, here I'll show you"
[*accidentally jury-rigs the system so it stream*]
[*techie tries to get it to stream properly for the next hours*]
[*can't fix*]
"that'll be $110"

nigga wat

I disagree with equating git to C++

when you work in a language, the more projects you do, the more you start to get a deeper understanding of the language and it's features...but with git, you can go years never needing to do more than 3 commands (pull, merge, push)

so you aren't working your way to a better understanding of what git can do, something goes wrong and you just have to panic google until it isn't going wrong anymore

I'm the git "expert" in my company, so whenever something goes wrong people come to me to figure it out, and if my bag of tricks doesn't work, it's back to panic googling lol

@pandaxcentric that's my point though. C++ has an unfathomable ammount of features and a lot of them most developers don't use or even know about.

Direct qote from Bjarn Stroustrup about the issue:
```
Even I
can’t answer every question about C++ without reference to supporting material (e.g. my own books,
online documentation, or the standard). I’m
sure that if I tried to keep all of that information in my head,
I’d become a worse programmer.
```

http://www.stroustrup.com/japanese2010.pdf

I bet I could pick 3 features I know of in C++ off the top of my head and you wouldn't have known one of them existed

lol, I don't code in C++ so I probably wouldn't 😛

I get your point, but I feel like developers deepen their knowledge of the languages they work in as they work in them

if you ever get the chance check the ISO C++ standard book. It's insane

but for git, unless you're doing somethign weird, you never go beyond like 3 commands

I'd agree with you if this was Ruby or Python or even Java, but C++ is a totally different beast

it's crazy

haha, I work in golang, which is a beast too

I know of 5 different variable array types that are in the standard library alone

yeah, that kinda supports my point though, as you used C++ you learned about those 5

wait 6

yeah but those aren't even all of them

you'll never learn all of C++, but you'll continue to learn more about it , and learn more about how it works

right, but that's the point, same with git