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.
You must log in or # to comment.
I initially found git a bit confusing because I was familiar with mercurial first, where a “branch” is basically an attribute of a commit and every commit exists on exactly one branch. It got easier when I eventually realized that git branches are just homeomorphic endofunctors mapping submanifolds of a Hilbert space.
git branches are just homeomorphic endofunctors mapping submanifolds of a Hilbert space
Yeah, once you realize that everything falls into place.
deleted by creator
It got easier when I eventually realized that git branches are just homeomorphic endofunctors mapping submanifolds of a Hilbert space.
Wow, thanks. I finally understand!
I initially found git a bit confusing because I was familiar with mercurial first, where a “branch” is basically an attribute of a commit and every commit exists on exactly one branch.
To be fair, Mercurial has some poor design choices which leads to a very different mental model of how things are expected to operate in Git. For starters, basic features such as stashing local changes were an afterthought that you had to install a plugin to serve as a stopgap solution.
That other people would care as much for a clean history like I do. Specifically, opening branches and leaving them open forever without merging them back into main, many useless commits rather than squashing or amending, or making branches-of-branches-of-branches. Drives me nuts
Omg so this. Also merging main branches into feature branches instead of rebasing.
Removed by mod
What is the advantage of rebasing?
You get a cleaner history that removes noise from the run-of-the-mill commit auditing process. When you audit the history of a repo and you look into a feature branch, you do not care if in the middle of the work a developer merged with x or y branch. What you care about is what changes were made into mainline.
Removed by mod
Instead of a commit history, you get a commit fairy tale, which is prettier than the truth, but probably less useful. You get something akin to merging the base branch into the feature branch but things look as if they were done in an order they weren’t instead of getting an ‘ugly’ merge commit.
In many providers it’s possible to set up an automatic squash policy when merging to main. At our company the git history is just linear with well defined commits.
I don’t think this is necessarily better. Some branches/projects are big enough that there are meaningful commits that should be made inside the project.
Yeah I agree but in my experience developers seem to struggle with “keep important things in history; squash unimportant things”. An open “merges allowed” policy leads to people unthinkingly merging branches with 50 “typo”, “fix” commits for a 100 line change.
Dunno what the answer is there.
The answer is Gerrit and learning interactive rebase.
How does that help?
The key thing gerrit provides is relation chains. You can push to the server your local branch and it will make a “patch” (like a pull request) for each of the commits in your branch. The patches are automatically put into a relation chain which lets reviewers go through them in sequence. Also your CI can test them together.
The idea is you need to locally make your commits ready for master. This is where interactive rebase comes in. You’ll have a normal local working branch and when you’re ready for review you use interactive rebase to squash some commits together, redo the commit message on some, change the order, etc. Basically you clean up your working branch into a series of commits ready for main.
Being able to easily push a relation chain of reviews up makes it way easier to make commits that land on main that just do one thing.
The second part of the solution gerrit provides is patchsets. When you need to edit a patch to deal with review comments, you actually rewrite your local history using git commit —amend or interactive rebase and push to gerrit again. In gerrit this will make a new patchset of your patch that you can diff between, see comments on, etc. It works very well for dealing with review feedback and for reviewers to quickly rereview.
It achieves this magic through a change-id that is added via git hook to the commit message. Even if you rewrite your history and your commit id changes it will still consider the rewritten commit to be the same patch as long as the change-id stays the same.
It’s pretty hard to just explain it like this. Using the workflow for a bit makes it much easier to see the value it has.
Yeah I get what you’re saying. Gitlab can pretty much do that too, you just need a branch & MR for each commit, and then you tell it to merge each branch into the previous one. It automatically rebases them when their dependency merges.
Definitely more tedious to set up than just pushing one branch though. Maybe I should make a tool for that… Does Gerrit test each patch in CI sequentially or just all of them together?
But in any case that wasn’t really the problem I was talking about. What I’m saying is that whether or not you should squash a branch depends on what that branch is. Neither “always squash” not “never squash” are right. It depends. And developers seem to have a real problem with knowing when a change is important enough to warrant a commit.
Though I suppose if people have to actually review each commit they would get a lot more push-back to “fix fix fix” type commits so maybe you are right.
Does Gerrit require each individual commit to be approved or can you just approve the whole branch/changeset?
I guess it’s dependent on project, but IMO if a commit is important enough to be in the main branch, then that should have its own merge request. I like it when all commits in the main branch have gone through all the build pipelines and verification processes.
But if having separate MRs is undesirable, then you could always overrule the squash policy. I know it’s possible on Gitlab at least.
Commits should be reasonably small, logical, and atomic. MRs represent a larger body of work than a commit in many cases. My average number of (intentionally crafted) commits is like 3-5 in an MR. I do not want these commits squashed. If they should be squashed, I would have done so before making the MR.
People should actually just give a damn and craft a quality history for their MRs. It makes reviewing way easier, makes stuff like
git blameandgit bisectway more useful, makes it possible to actually make targeted revert commits if necessary, makes cherry picking a lot more useful, and so much more.Merge squashing everything is just a shitty band-aid on poor commit hygiene. You just get a history of huge, inscrutable commits and actively make it harder for people to understand the history of the repo.
Well the MRs in the teams I’ve been working in have been small and mostly atomic. They’re focused on solving only one thing.
The team I’m currently working now in was bad at this before and often bundled way too many things in a single MR. It lead to overly long review processes and was error prone. It was too tough for the reviewer to get an understanding of what was going on.
Since we made the habit to make smaller MRs we have had much less of those issues.
If the MR is anything bigger than a completely trivial change in a file or 2, it most likely should be broken into multiple commits.
A feature is not atomic. It has many parts that comprise the whole.
In that case the feature is multiple MRs.
I’m glad I was able to establish a very mindful and structured approach to Git history in my team and project.
I think a common misconception is that there’s a “right way to do git” - for example: “we must use Gitflow, that’s the way to do it”.
There are no strict rules for how you should use git, it’s just a tool, with some guidelines what would probably work best in certain scenarios. And it’s fine diverge from those guidelines, add or remove some extra steps depending on what kinda project or team-structure you’re working in.
If you’re new to Git, you probably shouldn’t just lookup Gitflow, structure your branches like that, and stick strictly to it. It’s gonna be a bit of trial-and-error and altering the flow to create a setup that works best
git add . git commit -a git pushAt that point you might as well add an alias that does all these three things.
alias fuckit=“git add . && git commit -a && git push -f”
I think a common misconception is that there’s a “right way to do git” - for example: “we must use Gitflow, that’s the way to do it”.
I don’t think this is a valid take. Conventions or standardizations are adopted voluntarily by each team, and they are certainly not a trait of a tool. Complaining about gitflow as if it’s a trait of Git is like complaining that Java is hard because you need to use camelCase.
Also, there is nothing particularly complex or hard with gitflow. You branch out, and you merge.
Well to be clear, this was not supposed to be a jab at gitflow, or me complaining specifically about gitflow. I merely used “gitflow” as an example of a set of conventions and standardizations that comes nicely packaged as one big set of conventions.
But there’s nothing wrong with gitflow. I was just saying - it are not set in stone rules you must follow religiously. If you’re using it and it seems more practical to adapt the flow for your own use-case, don’t worry it’d be considered wrong to not stick strictly to it
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.
Git is ugly and functional.
I don’t even think it’s ugly. It just works and is intuitive if you bother to understand what you’re doing.
I think some vocal critics are just expressing frustration they don’t “get” a tool they never bothered to learn, particularly when it implements concepts they are completely unfamiliar with. At the first “why” they come across, they start to blame the tool.
If there was actually a persistent productivity hit from its interface, one of the weird wrappers would have taken off, and replaced it.
How many use a GUI or text editor plugin (eg magit) for git? AFAICT, such things, as a category, are rather popular.
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
vimcan be obscure … try runninged MYFILE! It’s basically a sort of grep and sed REPL for editing text (where, interestingly, historically tools likegrepactually came out ofednot the other way round). Vim can be used in a sort ofedmode withvim -e(AFAIU it’s actuallyexmode, which is a more advanced version ofed).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
edthat 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
vgitshould exist, that provides a terminal TUI of some sort, and that as withvimandedit should totally supplantgitwhile 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 pushsays “did you meangit 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-behaviourflags 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 pullgives 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 namegit 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 branchfoo. 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.
Removed by mod
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?”.
This x100. I mean I think I know the answer - Git was written by a C kernel guy, and the devs that it attracted are C guys. The kind of people who think user friendliness is a weakness. Guess how you contribute a patch to Git? Well step 1 is reading a 10 page essay… Needless to say that isn’t going to attract many people that care about beginners.
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.
Nonetheless
You didn’t provided a single concrete example of something you actually feel could be improved.
The most concrete complain you could come up was struggling with remembering commands, again without providing any concrete example or specific.
Why is it so hard for critics to actually point out a specific example of something they feel could be improved? It’s always “I’ve heard someone say that x”.
Because this is a casual discussion and that’d be more effort than I’m willing to put in. Also, your premise is false: it can both be
trivialNON-trivial to implement something better and relatively obvious that a better implementation could exist.Also, if you’ve encountered these sorts of discussions before, I’d dare say it’s because people often avoid flame wars and you give off flame war energy.
I’ve mentioned two pretty concrete examples: be like mercurial and have a built in GUI. The basic commands being janky is also pretty concrete given the recent additions that have been made to correct that. But I don’t trust that you want a discussion because you’re being pretty demanding and aggressive here. Sea lioning would be somewhat apt … there is such a thing as meeting people where they are … do you have an example of something people often criticise about git that you don’t think can be improved or not easily? “Why is it so hard for replies to actually have a discussion rather than be demanding, argumentative and aggressive”
Because this is a casual discussion and that’d be more effort than I’m willing to put in.
I didn’t asked you to write a research paper. You accused Git of suffering from usability issues and I asked you to provide concrete examples.
And apparently that’s an impossible task for you.
If you cannot come up with a single example and instead write a wall of text on you cannot put the effort to even provide a single opinion… What does this say about your claims?
Git’s internals are very easy to understand and once you know more about them, you’ll have a much better idea of how it works (especially when it comes to tags and branches). They’re so simple, you could even easily write your own scripts to parse git’s internal data directory if you wanted to.
I would highly recommend reading about them: https://git-scm.com/book/en/v2/Git-Internals-Git-Objects#
They’re not that simple because of packfiles. But yeah loose files are very simple. Also the documentation for packfiles is pretty bad. You end up reading other people’s random notes and the Git source code. (I actually have written a Git client from scratch.)
All I will need is push, pull, and commit.
Sure if you never branch, which is a severely limited way of using git.
Network engineer doing netdevops. branches don’t work like software, always commit to main.
Sure if you never branch, which is a severely limited way of using git.
It’s quite possible to use Git without creating branches. Services like GitHub can automatically create feature branches for you as part of their ticket-management workflow. With those tools, you start to work on a ticket, you fetch the repo, and a fancy branch is already there for you to use.
You also don’t merge branches because that happens when you click on a button on a PR.
Coming from SVN and Mercurial where commits are increasing integers, I thought the SHA-1 stuff would be a PITA. It’s not and no one cares about numbers anymore.
It’s not and no one cares about numbers anymore.
The only people who ever cared about svn’s numbering scheme were those who abused it as a proxy to release/build versions, which was blaming the tools for the problems they created for themselves.
I expected any operation involving
origin/foobarto be an online operation and work against the latest server-side version of the branch.I didn’t expect it to keep a local copy of the remote branch instead.
That it’s just like subversion but distributed. Both of those assumptions are wrong. It uses a lot of the same terminology as subversion, but most of the terms are conceptually different in sometimes major ways. It’s not really distributed unless you go out of your way to make it so. Most implementations use a single remote to sync back to on a regular basis. It is, however, really good about keeping changes in sequence locally until it can sync, something you can’t really do in subversion.
I don’t actually remember when I first learned Git. Maybe it was in a university lecture. I think my biggest struggles was learning how to resolve merge conflicts properly and efficient use of branching, but I never found any of the commands difficult to understand.
I thought it would be hard to use and confusing all the time.
I tried to follow tutorials that use the command line. In hindsight that is terrible way to teach Git, which is fundamentally quite a visual thing.
It’s like trying to teach people about filesystems only using
cd,lsandpwdinstead of just showing them a file tree.Actually it’s even worse because Git’s CLI is so notoriously awful.
Eventually I tried Sourcetree which made it all make sense. Though Sourcetree isn’t a very good GUI, mainly due to being hella slow. I eventually switched to GitX which is probably the best GUI I’ve used so far and makes everything extremely clear and easy. Unfortunately Mac only.
I now mostly use the Git Graph VSCode extension which is excellent and integrates pretty well with VSCode. Unfortunately it has been abandoned by its author and they frustratingly included a license clause saying only they could release versions of it, so it’s basically abandonware. But it still works so I’ll figure out a replacement when I have to.
Oh dang, I use that extension too and I didn’t know it was abandoned. Let me know if you find a good replacement
If you use the git command line (and I do) you should spam
git log --graph(usualy with--oneline).And for your filesystem example I sure do hope you use
tree!you should spam git log --graph
Yeah… but that’s just a poor man’s GUI. Why use that when you can use a proper GUI? The only reason I can think of is if you happen to be in a situation where using a GUI is a bit of a pain (e.g. SSH).
It’s a question of workflow. Git doesn’t guide you (it’s really workflow agnostic) and I find it easier to taillor CLI to fit my exact need, or use whatever was recently added (like worktrees a few years ago). I have yet to find a GUI/TUI that I’m not frustrated with at one point but everyone has its own preferences.
Wft isn’t there just a nice clean git UI that tells you in human terms what you are doing.
Command line interfaces suck ass.
Learn git with the command line with examples and visual aids.
Thank you for sharing this.
I found this long time ago then lost the link.
I think the lack of UI is the main reason for all the jokes about git being horrible to learn. Fork is a pretty good client, and there are also some pretty good VSCode plugins to show you how all the commits and branches fit together.
think the lack of UI
Even git ships with git-ui. It’s not great, but just goes to show how well informed and valid your criticism is.
Tbf I’ve been using Git for at least 10 years and I only just discovered this. I think nobody talks about it because it doesn’t show history which is 90% of the reason to use a Git GUI.
I think nobody talks about it because it doesn’t show history
What do you mean it doesn’t show history? It’s perhaps the only thing it handles better than most third-party git GUIs.
git: 'gui' is not a git command. See 'git --help'.If you’re going to try to smack talk like Linus Torvalds then maybe check your facts first
Sublime Merge is the best. Not easy but I’ve tried them all.
I’ve tried them all. Didn’t get on with Sublime Merge.
My recommendations:
- GitX (sadly Mac only, and a confusing array of forks).
- Git Extensions (which I avoided for ages because the terrible name makes it sound like it’s just explorer shell extensions but it’s actually a full GUI).
- Git Graph VSCode extension
Most of the others are kind of crap IMO.
Git Fork is amazing
I mean gitlab is pretty sweet
