Skip Navigation
Git @programming.dev canpolat @programming.dev

What were your misconceptions about Git when you first started?

I used CVS and ClearCase before moving into Git, and it took me some time to adjust to the fact that the cost of branching in Git is much much less than ClearCase. And getting into the "distributed" mindset didn't happen overnight.

79

You're viewing a single thread.

79 comments

  • That given its popularity it would be more user friendly. Every good dev tool will have its internals or more advanced features. Git is no different. But it sure feels like it never took the idea of a polished user experience seriously. Which is fine. It’s a dev tool after all. But the UI conversation around git has been going on long enough (here included) that there has to have been a significant global productivity cost due to the lack of a better UI.

    • the UI conversation around git has been going on long enough (here included) that there has to have been a significant global productivity cost due to the lack of a better UI.

      I don't think this is true.

      Git is ugly and functional.

      People love to complain about it being ugly, but it does what it's meant to. If there was actually a persistent productivity hit from its interface, one of the weird wrappers would have taken off, and replaced it.

      But the truth is, those wrappers all seem to be written by people learning to use git in the first place, and just get abandoned once they get used to it.

    • there has to have been a significant global productivity cost due to the lack of a better UI.

      I'm not so sure about this to be honest. If it were really that big of a problem, someone would have made an effort to resolve it. The fact that people still use it anyway suggests to me that it's a bit of an overblown issue.

      • If it were really that big of a problem, someone would have made an effort to resolve it. The fact that people still use it anyway suggests to me that it’s a bit of an overblown issue.

        As I said in another reply ... how many GUIs and text editor plugins are there for git and how many use them?

        What other CLI tool has as much work put into GUIs, wrappers and plugins that do not try to replace the underlying tool/CLI, even accounting for popularity?

        • There is no other CLI tool like Git. But

          Shell or Bash has various alternative shells.

          Vim has numerous plugins and alternatives/extensions.

          Linux distributions are wide and varied, forking out.

          • Yea, I think they’re all different. Alternative shells are about more than polishing a UI, and in many ways so are distros. And text editors are basically platforms and have been for a while, though it is interesting to single out git as being more like something like vim compared to other CLIs (as you say, it’s different). But even so, it’s not nearly a platform like a test editor, most apps for it a UI wrappers that don’t alter its core utility/function, to my point.

            • I think the fundamental difference is that Git is a CLI tool. But that's not how or where people use and want to use it. So obviously various interfaces are being created. It's not alternative CLI that are created. It's UIs and GUI interfaces. For a lack of a [more-than-barebone] official one.

              Shells remain CLI. Distros are also technically/technologically driven.

              Maybe the better analogy is that with vim and nano, we see many text editors and IDEs with GUIs.

              • Maybe the better analogy is that with vim and nano, we see many text editors and IDEs with GUIs.

                Interesting. I'm not so sure about the divide you draw between vim/nano and GUI IDEs. Historically vim and nano were basically the GUIs of their time. Preceding vim was ex and ed, which were basically CLI text editing tools build for the actually printed on paper typewriter interfaces computers like PDPs used to run. If you're not familiar, and you think vim can be obscure ... try running ed MYFILE! It's basically a sort of grep and sed REPL for editing text (where, interestingly, historically tools like grep actually came out of ed not the other way round). Vim can be used in a sort of ed mode with vim -e (AFAIU it's actually ex mode, which is a more advanced version of ed).

                So I'd say vim is more like any sort of GUI/TUI or text editor plugin for git and git is like the old ancient CLI equivalent ed that no one knows about or uses anymore because having a visual mode just makes too much sense.

                And this is basically where I fall ... I think a vgit should exist, that provides a terminal TUI of some sort, and that as with vim and ed it should totally supplant git while also having a CLI mode too. That this hasn't happened, back to my original point, is a problem and honestly a little strange.

    • Probably important to remember that Git was designed by Linus Torvalds, the same dude who developed the Linux kernel, and who is infamous for going off on big rage-fueled rants when questioned about his methods. So yeah, it’s going to be clunky and obtuse.

      • Ha yea ... who's also been using his own customised emacs from an ancient 90s version for ages.

    • Git is no different. But it sure feels like it never took the idea of a polished user experience seriously.

      I've seen this sort of opinion surface often,but it never comes with specific examples. This takes away from the credibility of any of these claims.

      Can you provide a single example that you feel illustrates the roughest aspect of Git's user experience?

      • Yeah sure. git push says "did you mean git push -u branchname origin". Yes obviously I meant that. I always mean that.

        I'd been copying and pasting that for about 5 years before I discovered there's a feature (auto branch setup or something) which means it will automatically do that. But it's not mentioned in the error message! Why?

        Git has a load of --fixed-behaviour flags like that that are just not on by default and never mentioned.

        The terminology is very poorly chosen in a lot of cases. "The index"? Wtf is that? "Staging area" is at least slightly better but would "draft commit" have been too much to ask? Ours/theirs is also a stonkingly bad choice of words. How does Git know which code is mine? It doesn't. Hell it isn't even consistent about which way around they are.

        Someone has force pushed a branch and I want to update my local ref (without typing the whole branch name again). git pull gives a wall of text without the answer, which is.... git reset --hard @{u}. Catchy!

        Or maybe I've got a branch that is tracking my fork but I want to pull from upstream. Can I do git pull upstream? Nope. I have to repeat the branch name git pull upstream branch-i-am-on. (Please don't say "but git doesn't know which branch you want to pull.)

        Then there's the error messages... Make a branch called foo/bar. Now try to check out a remote branch foo. See that nice explanation about how git branches are actually files and directories, not just strings? Nope? Huh.

        This is just a few I can remember off the top of my head but it's the tip of the iceberg.

        • The completely useless error messages kill me. And the commands that don't do what they say... WTF is the point in "clean" and "force" if they don't clean or force? And then there's the inconsistency in command arguments. With one you have to use force, even though it doesn't actually force, and the other you have to use "hard". Hard? I mean I guess hard makes sense once you realize that force doesn't actually mean force. Now I'm just waiting to run across the switch "--seriouslyguysimeanitthistime".

          OMG, I can't up vote this thread enough... git is such a purposefully exclusionary step in software development that I can't believe it is the preferred solution. It is very powerful, but it is painfully obvious that no one has ever gone back and said, "but what if anyone else who wants to use this is not a Linux cli guru and already has an expert understanding of git commands?". Why is it that learning to check in code is significantly harder than learning the actual IDEs that the devel uses to develop the code?

        • yea this all generally tracks.

          The kind of "polish" I'm talking about is the sort that a good UI/UX/GUI dev would do by tracking common user behaviours and needs or having testing users run the app through its paces. All of these confusing instances where better terminology, commands and error messages would come up through a process like that.

          Now, one could say that this is a dev tool which shouldn't need to go through that process. That developers should be expected to understand the tool's inner workings and conceptual model well enough to not need any of that. But that gets back to my initial point. Git is so popular and basically ubiquitous now that that policy makes little sense. Many devs who use or are expected to use git are not capable of getting to terms with git's internals to the point of never having difficulty with the UI, either because of a lack of time, capacity or skill. Moreover, the time required to get familiar with git enough to never find the UI frustrating should not be underestimated ... it's not just conceptual but technical and specific to git's implementation details to the point of just knowing how the UI/CLI has been implemented.

          If you want to trash such developers ... go ahead ... but they're still developer's doing work and it's to the industry's benefit to have a standardised and powerful VCS ... which means that at some point it's worth thinking about meeting developers where they are.

          Beyond all of that ... one could also say "fuck that" and talk about how being popular and "the standard" requires being better. Git's centrality to the dev workflow as at text-editor levels. But while text editors have a portable format (IE "plain text" and character encodings) and so enjoy pretty healthy competition (vim, emacs, sublime, VSCode, Jetbrains ... etc) ... VCSs, AFAICT, don't have the same portability and neither the competition. I'm actually curious now ... are there drop in replacements for git that provide complete compatibility but are completely different implementations?.

          It's interesting, IMO, to think about why/how this has come to be, but in the end, it means that there's a lot on git's shoulders here. Even a little bit of an improvement can go a long way, and so being critical (rather than cultishly defensive), I'd argue, is the correct aspect here on utilitarian grounds.

          As for why git is in its current situation (without having really thought about it before) ... I'd actually speculate that there's something insidious here regarding it's imperfect/confusing UI. Namely that it has a monopolising force. Once it's gained critical mass, and once there are enough devs out there who have deep and experienced understanding of the tool, and enough internet content capturing that expertise, then moving off to another tool which doesn't have the same established expertise is prohibitively difficult. Comparing here VCS to text editing and programming languages may be part of it, where the basic difficulty of doing VCS (at least in so far as the complexity is exposed to the user) is likely somewhere between that of a text-editor and a programming language. In a similar vein, the solution space for VCSs is probably relatively small while text-editors and languages enjoy a good deal of design variety. And so, there's little interest or inventive or even capacity to come up with interesting alternatives for what is a relatively difficult/complex kind of tool, which gives any established VCS a good amount of competitive protection and inertia.

          Keep in mind though, I'm not talking about the UI here, but the core functionality. That many GUIs exist shows that the UI is a relatively open design space. But that git itself has hardly explored that space on their own is my critique (where comparing to text editors like vim/nvim and emacs and the built-in features they have might be informative here).

      • I mean sure. I personally haven't researched and become an expert on this ... it is an early-user's misconceptions thread after all. And a dev can justifiably reflect on all of their tooling and consider their general usability against their popularity.

        However, by the same token, your lack of any counter examples isn't exactly highly credible either.

        Nonetheless:

        • Whenever I've seen an opinion from someone who's used both mercurial and git, their opinion is always that the mercurial interface and model "actually makes sense"
        • AFAICT, the git CLI (at least up until the more recent changes) has widely been recognised as being unnecessarily janky and confusing especially for common and basic tasks
        • Apart from that, many devs have shared that they always struggle to remember git commands and always need to rely on some reference/cheat-sheet (obligatory XKCD), which IMO is a product of it both having a poor CLI in need of polish and being a program/tool that isn't naturally constrained to CLI usage but rather naturally implemented with a graphical of some sort.
You've viewed 79 comments.