[dan-robertson]

I think all git has going for it is its existing inertia and GitHub. I think the foundations were a bigger deal when git was newer. Other DVCSes have decent foundations.

Going against git is an atrocious user interface (if it were good then [1] would be neither funny nor sad). Most people just memorise a few commands and if they stop working they transfer their changes elsewhere, delete the repo, and start again. Sometimes a team will have a “git expert” who has merely memorised a few more commands and is better able to get a repo out of a broken state. Git fails badly at an important for a developer tool: largely getting out of the way.

[1] https://git-man-page-generator.lokaltog.net/

[dreamcompiler]

The light finally came on for me when I bit the bullet and dug into git's internals. It's a beautifully simple model. Git's internals are much easier to learn than its dumpster fire UI, and once you understand the internals, the UI can be understood as something that started out reflecting the internals but then had a boatload of edge case convenience features glued on without an overall design plan.

[rvdginste]

This! I did the same thing: read about the model for the commits, the blobs and the hashes. When you know that (just the basic data model, which is really simple), it's a lot easier to understand and memorise the different git commands.

In fact I often work with git using the tools that come with it: git on the commandline, gitk for the visualization of the history and 'git gui' for committing work. They might look outdated, but they work really well and are really fast.

There are a lot of modern graphical tools to work with git repos, but some of them introduce their own vocabulary in an attempt to make using git 'simpler', but this just ends up making everything more confusing.

My impression is that a lot of people want powerful tools, but do not want to invest the time to learn how to handle them. The Pro Git book is available to read for free online and after reading the first 3 chapters, you should know about the most important things for day-to-day use. Some people would do anything to avoid reading the documentation: they'd rather spend a whole day checking different guis that make things look easy and familiar instead of spending that time reading the documentation.

[merijnv]

Can you enlighten me how git's internal model is more beautiful than, say, Mercurial? Which has the added bonus of having a UI which isn't a dumpster fire...

[dreamcompiler]

I haven't studied Hg's internals. I much prefer Hg to git (because its UI makes sense) but I no longer have the happy option of using it. So rather than continue to fight a battle that was already lost, I decided to embrace git.

[merijnv]

For what it's worth, I've been using Mercurial + hg-git to interact with git repos since 2010 and I still do with all my git and github using colleagues.

[reificator]

You'll never hear me say that git's interface is good, but this seems to be blowing things way out of proportion. I haven't seen someone blow up and recreate a git repo in maybe a decade.

I've definitely pulled out the BFG here and there to clean up credentials but that's an issue in any VCS.

Maybe I'm biased because I'm "better able to get a repo out of a broken state", but for the record it's definitely not because I've "memorised a few more commands".

[theon144]

Your attitude seems to mirror this xkcd https://xkcd.com/1597/ and I honestly never understood it.

I'm by no means a git expert (I've actually just recently learned about bisect for instance), but I have never in my entire career been in a state where I'd just delete the repo and recreate it from scratch.

I've only ever used a handful of commands, the most advanced of which could be probably considered `reflog` when I wanted to revert some changes; or `rebase` (because strictly speaking, it is more complex than merge I guess), but I never ran a command I did not understand or had to memorize.

I actually do share the sentiment about the tool getting out of your way, and my knee-jerk reaction to learning about git internals is just repulsion, because you're right! I'm not there to tinker around with version control, I'm there to solve problems. That said, I've never felt like Git got in my way.

[andrewzah]

I find the vast majority of complaints come from people who refuse to put any time into learning a mildly complex tool, and thus I have no sympathy for them. The documentation is right there in your terminal, in addition to many websites, videos, and books.

The one and only time I messed up a repo beyond repair was when I deleted some git pack files while trying to delete some binary files from the git history. This is known as user error.

In my day to day use I find that I rarely have to venture beyond rebase, bisect, reflog, cherry-pick, and the standard commands.

[sterlind]

I nearly did once, because I couldn't stage a file. Git's content-hash store had gotten corrupted, so the object for the staged blob had a bunch of zeros in it and didn't match its sha. That was more the filesystem's fault than Git's, though.