News for hackers. Stuff that matters.
Re:What I Hate About Git by klodolph on Saturday August 04, 2012 @09:31PM (#4340268)
Number 1-5 are mostly "I don't want to learn new things", so I'll ignore them. Do you remember when you learned source control for the first time? I don't, it was too long ago. Just like you have to learn SVN if you've never used source control before, you have to learn Git if you've never used distributed source control before.

* "Unsafe version control", and then gives examples using -f or +<refspec>, both of which advertise their destructive nature. Yes, you can also go in with SVN and obliterate history too, using svnadmin dump and svnadmin load. Git's reflog will have your back when you make mistakes, as long as the mistakes don't get too old.

* "Power for the maintainer, at the expense of the contributor" Yes, most people write code on one branch for a long period of time. Git does this just fine.

* "Burden of VCS maintainance pushed to contributors" First of all, nobody says that contributors have to merge. That is a decision that each project makes. Plenty of projects have the lead developers merging in everyone else's work. Second, the reason this is even an issue is because merging is such a pain in SVN that most people don't want to do it.

* "Git history is a bunch of lies" Again, this is up to the individual project. Some developers like to work on six different things at the same time, and then they go back and rewrite history so that their six changes end up as six commits. The difference with SVN, is that these same developers would simply avoid committing until they're done with all six changes. Some projects expect rebased patches, some prefer proper merges. Worse, the author says that "filtering" should solve this problem, but doesn't propose how such a filter would work.

* Complexity of simple tasks: Let's try not to artificially inflate the complexity of the Git tasks. For example, the Git examples assume no commit access, whereas the SVN examples assume direct commit access. If you don't have commit access to an SVN project, how do you do it? You either use git-svn and mail them a patch, or you use svn and mail them a patch.

A recurring complaint seems to be that "git add" is not the same as "svn add". I don't see why it would be. It's not the same as "ssh-add" or "useradd" either.

Re:What I Hate About Git by ender7 on Sunday August 05, 2012 @12:33AM (#4340595)
Like others, I think telling people to RTFM is unhelpful.

The OP already pointed out that the official Git documentation is bad, bad bad. So, already it's not just "RTFM" but "Google around for a decent Git tutorial and hope you pick the right one." Great.

Add to this the fact that the Git commands are simply poorly designed. Yes, it is possible to understand what they do after expending a significant amount of time simply learning to think like Linus, but why should we have to do that? I refer you to the gitref.org entry for 'git reset':

git reset is probably the most confusing command written by humans. I've been using Git for years, even wrote a book on it and I still get confused by what it is going to do at times. [0]

This is not a problem of people not wanting to learn DVCS concepts. This is simply people who don't want to jump through a set of arbitrary, confusing, and completely unnecessary mental hoops in order to get to the DVCS concepts they wanted to use.

[0] http://gitref.org/basic/#reset (gitref.org is maintained by GitHub)

Re:What I Hate About Git by encoderer on Sunday August 05, 2012 @02:06AM (#4340770)
> The OP already pointed out that the official Git documentation is bad, bad bad. So, already it's not just "RTFM" but "Google around for a decent Git tutorial and hope you pick the right one." Great.

I have a hard time believing that there are scores of software developers out there who have learned their craft enough to want source control but are somehow overwhelmed by the basic task of finding a good Git tutorial.

The real impediment that I've observed is developers that certainly could learn Git but don't because they don't see it as a good investment. That's where they're so, so wrong. Git is like power tools for your code. If you embrace and learn it, you'll be much better off for it. Yes, SVN is easier. It's also a lot less powerful.

And there's always Mercurial, which is very similar to Git and addresses some of the confusing-API criticism.

Re:What I Hate About Git by CJefferson on Sunday August 05, 2012 @10:29AM (#4341510)
The problem with git isn't following a tutorial, the problems I have had are nasty corner cases. I have to keep looking up strange a-symmetries, like why does 'git push' push just the current branch, and 'git pull' pull all branches? Then I have to look up how to make 'git pull' pull just the current branch.

Also, due to inconsistencies in how commands take branches, I sometimes realise I have a branch called 'origin/stuff', when I meant to do something with stuff on origin. It's also hard to find which branches are tracking what. Of course, you can find the options to do all these things. But there are just so many little things to learnt.

The fundamental question is, does the complexity of git come from the power it offers over svn, or does it come from the most terrible UI I think I have ever seen on a command line tool? I think it is the second.

I still use git every day, but I think it is putting usability by less computer-savvy users back years.

Re:What I Hate About Git by EdiX on Sunday August 05, 2012 @12:02PM (#4341759)
> like why does 'git push' push just the current branch, and 'git pull' pull all branches?

It's the opposite, "git push" pushes all branches and "git pull" only pulls the current branch. I think it's because push will only do fast-forward merges while pull will do any merge, and that could require a working directory to exist (but why not make push just push the current branch?)

Re:What I Hate About Git by CJefferson on Sunday August 05, 2012 @01:23PM (#4341983)
Sorry yes, I got the asymmetry the wrong way around :)

The problem this causes (for me) is that if I have commits in other branches, 'git push' will fail (as other branches can't be fast-forwarded), but 'git pull' won't fix it. Of course, I can get around it, but it's annoying.

Re:What I Hate About Git by ben_h on Sunday August 05, 2012 @10:54PM (#4343503)
You can configure `git push` to push just the current branch to its configured remote, by setting 'push.default' to 'upstream'.

`git config --global push.default upstream`

The relevant docs (droplr'd, since you can't anchor-link into the online manpages): http://d.pr/Rlqn

Re:What I Hate About Git by encoderer on Sunday August 05, 2012 @01:36PM (#4342010)
What you mean when you say "you can get around it" is just specifying the branch you want to push. Just sayin'. It's not like you have to muck with settings and jump hoops.
Re:What I Hate About Git by onedognight on Sunday August 05, 2012 @05:28PM (#4342714)
The git maintainer is trying to fix this asymmetry by making "git push" only push the current branch (rather than all branches). It's a slow process to change the defaults in something as widely used as git because doing so breaks scripts.

See the new destined-to-become-the-default "simple" mode for "git push" in these release notes: https://raw.github.com/git/git/master/Documentation/RelNotes... .

Re:What I Hate About Git by LiveTheDream on Sunday August 05, 2012 @12:03PM (#4341764)
> why does 'git push' push just the current branch, and 'git pull' pull all branches?

What version of git are you using? "git pull" definitely just pulls the current branch. It will fetch all the other remotes, but will only pull the current branch.

Re:What I Hate About Git by chris_wot on Monday August 06, 2012 @05:24AM (#4344516)
Which kind of makes sense, because you don't normally want to pull in all branches, just one particular be, but you often do want to push all your branches.
Re:What I Hate About Git by mgkimsal on Sunday August 05, 2012 @07:56AM (#4341237)
"...but are somehow overwhelmed by the basic task of finding a good Git tutorial."

Ummm.... when you don't know the tool, you're not in a good place to judge what a 'good' tutorial is. This is the same reason we've got generations of bad PHP developers out there - they can't tell what's good or not.

"scores of software developers out there who have learned their craft enough to want source control"

How many people 'want' to learn source control, and how many people are told 'this is what we use here, go learn it'? I suspect far more of the latter, especially with git. People would not flock to git purely based on the documentation quality. Further, I suspect that had git just been written by some random dude off the street with no major project behind it, it would have never taken off. Using it for Linux kernel work has ensured a sizeable number of people are going to have to use it, whether they like it or not.

Re:What I Hate About Git by encoderer on Sunday August 05, 2012 @01:28PM (#4341993)
How many kids want to go to school and how many are told by their parents that 'this is what you do so you can be happy and successful later.' I suspect more of the latter.

But like leaning Git, earning your education will pay off. Does that mean Git is without flaws? Of course not. And if you want to work to improve it, and release a better version, go for it. But anybody that sticks with SVN and refuses to learn modern DVCS is not somebody I'd hire.

Maybe this is a problem on IT-department, line-of-business teams (where most software developers work) but if Bay Area tech companies are a leading indicator, a big majority of Engineers I work with use and love DVCS's like Git and HG and there's not this groundswell of resistance.

And while this isn't related to my previous comments:

To anybody who has tried Git and ended up "losing work" because of a misunderstanding of the commands, let me assure you: It's actually a lot harder to lose work than you think.

Anything you add to the Index (eg git add foo.py) or commit is stored in the Reflog (which is just a DAG). The reflog is garbage collected periodically -- see below for details. Within that window, you can recover any lost state from the reflog.

So how long does Git keep things around by default?

Intermediate products of conflicted merges - 15 Days

Unreachable commits (do a git reset --hard HEAD~1?) - 30 Days

Intermediate products of a resolved merge conflict? - 60 Days

Everything Else? - At least 90 days.

Re:What I Hate About Git by flatline3 on Sunday August 05, 2012 @08:31PM (#4343197)
> But anybody that sticks with SVN and refuses to learn modern DVCS is not somebody I'd hire.

You wouldn't hire me. I'm OK with that.

I use git (required for an assortment of OSS projects), but for my own work, at at work, I use SVN. I'd never willingly choose git.

It's complex, involved, powerful, and incredibly distracting from the actual thing I want to do, which is write software.

The minute someone says something like this, my eyes glaze over: "Anything you add to the Index (eg git add foo.py) or commit is stored in the Reflog (which is just a DAG)."

Not because I don't understand git's fundamental model, or I'm unfamiliar with a DAG, but simply because I SHOULD NOT HAVE TO CARE.

My job is to write software, not operate heavy revision control machinery to some arbitrary level of dvcs revision control fetish perfectionism.

I don't want to hide my work from my coworkers, I don't wind to hide my work history from my coworkers, and I don't want to maintain wildly diverging branches (the cost of branches is primarily found in code divergence, not SCM headaches). Git isn't for me.

Re:What I Hate About Git by lparry on Monday August 06, 2012 @10:29AM (#4345309)
You sound like you've got a "production line" mindset. "This is my narrowly defined job, I'm not interested in learning new things, I just wanna do what I'm paid to do and get out."

That's fine and all, but I want to work with craftsmen. People who give a shit about their trade, love their tools and relish in the oportunity to learn something that will help them do their job better. I wouldn't hire you.

Re:What I Hate About Git by pwang on Monday August 06, 2012 @02:42PM (#4346537)
"I want to work with craftsmen"

And craftsmen are picky about their tools.

Git has a terrible, terrible, command line UI. It's entirely possible to do distributed source control with an easy command line interface: Mercurial. I've never had trouble teaching people how to use it, and I've almost never had to sit around scratching my head, wondering what arbitrary set of command line arguments I need to pass to it.

Maybe git is the most powerful chainsaw ever devised, but the fact that so many of its users are either covered in bandages or fastidiously studying man pages and googling proper usage so they don't end up covered in bandages is not a good sign.

Re:What I Hate About Git by samspot on Monday August 06, 2012 @09:07PM (#4348147)
I really like Mercurial, but even with it I've had some trouble getting the other developers I work with to really understand it. I could not imagine trying to show them Git. I think those who have mastered Git are blinding by how Smart and wizard-like they feel.

I also think its worth pointing out that many of the people here complaining about Git (including the OP), use it very frequently. These are the people who have bothered to invest the time in learning the tool and hate it anyway.

Re:What I Hate About Git by flatline3 on Monday August 06, 2012 @09:15PM (#4348171)
I'm fine with learning new things. I do use git on a number of projects: I just don't think it helps me do my job better.

The job of a SCM, in my opinion, is to be as invisible as possible. Record my commits, and then stay out of the way of what I'm really here to do: write code, architect systems, engineer products.

Futzing around with an overly complex revision control system doesn't help me do a better job.

This is also why I switched from Linux & BSD desktops to Max OS X. I can still write an XFree86 config file by hand, and the fact that I spent time and effort learning this is mind bogglingly awful.

Re:What I Hate About Git by manveru on Sunday August 05, 2012 @04:43PM (#4342582)
I almost had an heart attack after doing `git push --mirror`.

It deleted 95% of branches locally and on origin without leaving much of a trace, or any way to undo (well, none that i know of).

Good thing I had a clone on a machine at home, so I drove home, made local branches for each remote branch and then pushed each.

So yeah, there might be a way to get that stuff back, and I don't even have experience with non-DVCS, but the lesson I learned a long time ago with darcs is that you better have up-to-date off-site backups of your repositories, never trust yourself or your DVCS too much.

The upside is that keeping backups is easy, and good practice anyway, so if you're not doing it yet, don't wait.

Re:What I Hate About Git by qu4z-2 on Monday August 06, 2012 @12:09AM (#4343676)
My worst experience on that front was with jekyll.

Running jekyll without parameters compiles the source in the current directory, putting the output either in $PWD/_site, or wherever the config file for the project says.

I was in the parent directory, and thought I'd try to run jekyll projectname rather than having to cd in and out of the project.

The end result? It tries to compile the project in the current directory, writing output to the directory specified. As an added bonus, it completely nukes the target directory, including the .git subdir. And to add insult to injury, $PWD didn't even contain a valid project, so it error'd out immediately after wiping out the entire source.

The morale of the story: Always keep offsite backups.

Re:What I Hate About Git by StavrosK on Sunday August 05, 2012 @09:15AM (#4341348)
I started out with VCSes with bzr, which spoiled me very much, as everything's straightforward, it does whatever I want it to do, and it just works. I then moved to git, because it was much faster, but I couldn't handle it. Which command does the equivalent of "bzr revert -r -3"? What do I do to unstage things? What if I want to only revert some files? I don't even remember which of these things I know, because git threw random errors about things while running commands that were supposedly straightforward, or did things I didn't expect.

I tried hg for a time, which was much better, but in the end I went back to bzr (hg confused me in merging, with it thinking that "what is this three-way vimdiff window with all the colors? I'll just leave this and examine the files one by one" meant "okay, everything is correct now"). It interoperates with everything, and it's the sanest of the three, so why wouldn't I use something that just works, rather than fight my tools?

Re:What I Hate About Git by mattdeboard on Sunday August 05, 2012 @06:57PM (#4342945)
> Which command does the equivalent of "bzr revert -r -3"? What do I do to unstage things? What if I want to only revert some files?

git has well-documented and simple commands to perform these operations (except if you're talking about reverting some files in a commit, that's not a thing git does afaik? though it might, but I doubt it would be straightforward).

If you're confused by hg & git and just wound up back where you were it sounds like you just didn't have the patience to learn a new tool. Either that or you failed to evaluate what each tool did before you tried switching.

Re:What I Hate About Git by numeromancer on Monday August 06, 2012 @09:51AM (#4345163)
\sarc{bzr revert -r 3? What does that do? Jeez, bzr is so confusing.}

I don't think git's CLI design is that bad, but the commands for quotidian usage are hidden among a large and confusing array of commands for which serve to make git more powerful for the experts. This is also where the manuals are confusing: all the commands are listed, and beginners don't know where to start. It's like a woodwork hobbyist walking into the workshop of an expert carpenter and wondering where in the hell the hammers are.

As for subversion, try using it for branching and merging many parallel versions of code for very long and you'll welcome the arrival of git like that of Jesus into a leper colony.

Re:What I Hate About Git by redbad on Sunday August 05, 2012 @05:59AM (#4341064)
Stop defending bad design. We can do better than this.
Re:What I Hate About Git by aneth4 on Sunday August 05, 2012 @08:26AM (#4341273)
Here here. Any design that needs to be defended so vociferously and causes so much confusion is clearly flawed.

Distributed version control is not as complicated as this.

Re:What I Hate About Git by mikescar on Sunday August 05, 2012 @11:03AM (#4341607)
Feel free to fork and make it better. Not sure what you want improved though.
Re:What I Hate About Git by myspy on Sunday August 05, 2012 @07:20AM (#4341172)
Tried to learn the basics to manage the code for my thesis. Gave up widely confused. After trying to revert changes, I went back to it, this time trying eGit and playing with the commands. Managed to get it to work, but still struggling with branches and merging of changes into master.

The whole time I was thinking if I'm stupid or talentless.

The discussion here showed me that git is indeed far from perfect.

Re:What I Hate About Git by cshesse on Sunday August 05, 2012 @02:50AM (#4340822)
Learning Git would be an investment with a much lower cost if it wasn't so terribly obtuse.
Re:What I Hate About Git by chris_wot on Sunday August 05, 2012 @07:12AM (#4341155)
I don't see that it's obtuse. If you learn the basic concepts (as you have to do when you are a beginner to subversion or CVS) then you shouldn't have much of an issue.
Re:What I Hate About Git by chris_wot on Sunday August 05, 2012 @09:19AM (#4341356)
Now why would that be voted down? Obtuse means "mentally slow or emotionally insensitive", so that could hardly have been what was meant. I assume that by "obtuse" you meant "hard to understand". So I stand by my comment that if you learn the basics then it shouldn't be that hard to understand!
Re:What I Hate About Git by chris_wot on Sunday August 05, 2012 @03:30PM (#4342354)
yb66 - you are hellbound. Not sure why the OS X dictionary would consider obtuse to be the same as abstruse (that's wrong!), but at least I now know what is really meant. Which is what I had assumed was actually meant (if you followed my original comment, then that's what I said!).
Re:What I Hate About Git by retrogradeorbit on Monday August 06, 2012 @02:04AM (#4344013)
> but _why should we have to do that?_

This is exactly my feeling. Sure, I can, but why should I? I just want to get work done, not become a git fanboy.

The place I work at compared DVCSs and chose mercurial, and I'm very happy, I've never looked back, and heres the point... I really have no understanding of HOW mercurial works. It just works.

Re:What I Hate About Git by ak217 on Saturday August 04, 2012 @09:53PM (#4340312)
> Number 1-5 are mostly "I don't want to learn new things"

Git has a lot of wonderful properties, but it has horrible usability. Things like rebasing, remote branch tracking and push/pull, merge conflict resolution, stash management, and reverts are straightforward concepts! Once you grasp the concept of distributed VCS, those things should be a joy to use. But the standard Git CLI and most interfaces to it basically just drop everything on the floor and tell you to sort out the mess yourself as soon as something non-trivial happens.

This learning curve has no reason to be so steep. There need to be clearer explanations, better discoverability, and better interactive modes for all of the things I listed, and more. Telling people to RTFM just misses the point.

This is not to say that the OP makes a particularly coherent point. Just that the overall sentiment has merit.

Re:What I Hate About Git by pyre on Saturday August 04, 2012 @10:33PM (#4340399)

  > Telling people to RTFM just misses the point.
To be fair, most of these "git sucks" posts in the past have been people moving from svn and complaining that git doesn't do it the Right Way(tm) "like svn does." In most of these cases, it has boiled down to:

1. I tried to use git like svn without attempting to do much learning at all and it bit me in the ass.

2. svn does things The Right And Only True Way(tm) and git doesn't, therefore git sucks.

3. svn has a command named 'svn <action>' and git has a command named 'git <action>' but they do different things. Therefore git sucks because (obviously) svn has the One And Only Correct Definition of <action> that 'makes sense.'

The other arguments amount stuff like:

1. I use mercurial all of the time and I don't understand how anyone can use git because of <filter-branch | commit --amend | rebase --interactive | etc> that allows you to rewrite commits. If people are allowed to rewrite commits, then obviously all developers using git do things like rewrite the X year-old commit that introduced the bug rather than creating a new commit to fix the bug. <Here is where I continue to rant about how scary the ability to rewrite commits is while demonstrating that I have little to no actual experience with git, or a single bad experience that I'm extrapolating from>.

In general, I find that I can empathize with people that get worked up over "git sucks" rants, because for the most part they either make no compelling arguments, or they bury a couple of compelling arguments under a ton of unstructured ranting about strawmen.

Re:What I Hate About Git by ubernostrum on Sunday August 05, 2012 @07:14AM (#4341162)
Hi.

I'm someone who is neither unwilling to learn, nor attached to how Subversion did things. And I dislike git.

Superficially, I dislike it because it seems very little thought has been put into giving it a coherent interface. TFA points out instances of this, and it's true: whether something is implemented as its own command or as a flag to another command sometimes seems to have been decided via dartboard rather than any sort of intelligent process.

I also do intensely dislike git's own man pages, which are the first thing I'd ordinarily turn to. Unfortunately, the concept of an acyclic graph has not yet arrived in that part of git.

I dislike the way git overloads "branch" with multiple meanings or, rather, forces end users to do so. Mercurial does a better job of this currently, and has built-in support for the most important case (bookmarks vs. branches, in hg's terminology).

I dislike the fact that every repository and every branch is on equal footing except for all the commands that work differently with a remote branch or require you to do extra setup before they do work.

I dislike the fact that side-by-side inspection of different branches requires me to jump through hoops, since git only wants me to see one branch at a time. SVN, for all its faults, at least got that one right -- I can actually see two different branches, at the same time, using tools that require no knowledge of anything beyond my filesystem.

I dislike the fact that even people who use git day in and day out still can't seem to agree on a workflow. And I'm not just talking about things like whether rebasing is fashionable this week, but very basic things like when and how to branch.

I also agree with the article's point about contributor workflow; git and GitHub are more complex for contributors. There's also very little that's "decentralized", since GitHub is full of canonical central repositories, which makes me wonder what we gain from pretending we're using the "D" in "DVCS".

And that's really just the tip of the iceberg.

Re:What I Hate About Git by chris_wot on Sunday August 05, 2012 @08:52AM (#4341308)
Superficially, I dislike it because it seems very little thought has been put into giving it a coherent interface. TFA points out instances of this, and it's true: whether something is implemented as its own command or as a flag to another command sometimes seems to have been decided via dartboard rather than any sort of intelligent process.

The examples given weren't illogical. The author's examples were git pull, which he complains is a git fetch followed by a git merge... which is quite logical, given that to pull from a repository you must first fetch the files, and then merge the files into your repository.

The second example that he complains about git commit not commiting a file if it's not specified on the command line. This makes sense, as you need to explicitly add the files via git add - something the documentation makes clear. As one of the complaints is that the documentation isn't clear, I think it worthwhile mentioning that the git-commit man page specifically says:

  The content to be added can be specified in several ways:

  1. by using git add to incrementally "add" changes to the index before using 
     the commit command (Note: even modified files must be "added");
  .
  .
  
  3. by listing files as arguments to the commit command, in which case the 
     commit will ignore changes staged in the index, and instead record the 
     current content of the listed files (which must already be known to git);
  
  4. by using the -a switch with the commit command to automatically "add" 
     changes from all known files (i.e. all files that are already listed in 
     the index) and to automatically "rm" files in the index that have been 
     removed from the working tree, and then perform the actual commit;
The third example he used was that the shortcut for git branch and git checkout is git checkout -b. However, this makes sense because a branch doesn't populate automatically with any files and needs a checkout. Thus git checkout -b makes perfect sense.

Perhaps there needs to be a git branch -c?

I also do intensely dislike git's own man pages, which are the first thing I'd ordinarily turn to. Unfortunately, the concept of an acyclic graph has not yet arrived in that part of git.

I think some of the opening descriptions are a little terse, but not entirely sure what you mean by the acyclic graph comment... I haven't been able to find anything obvious in the man pages that references a man page that then references the original man page... of course, I might have missed something!

I dislike the way git overloads "branch" with multiple meanings or, rather, forces end users to do so.

Could you clarify what you mean? Branches have only one meaning in git!

I dislike the fact that every repository and every branch is on equal footing except for all the commands that work differently with a remote branch or require you to do extra setup before they do work.

Could you clarify what you mean?

I dislike the fact that side-by-side inspection of different branches requires me to jump through hoops, since git only wants me to see one branch at a time. SVN, for all its faults, at least got that one right -- I can actually see two different branches, at the same time, using tools that require no knowledge of anything beyond my filesystem.

Can't gitk do this? Genuinely interested...

I dislike the fact that even people who use git day in and day out still can't seem to agree on a workflow. And I'm not just talking about things like whether rebasing is fashionable this week, but very basic things like when and how to branch.

I really can't see that's a valid argument. Some folks need to branch differently than others. This isn't just a git thing, the same can occur in SVN. As has been pointed out, branching tends to be discouraged because merging can be a regular pain.

I also agree with the article's point about contributor workflow; git and GitHub are more complex for contributors. There's also very little that's "decentralized", since GitHub is full of canonical central repositories, which makes me wonder what we gain from pretending we're using the "D" in "DVCS".

I disagree. The github workflow might be a little tricky, but as has been pointed out there are other workflows possible in git. git != github!

Re:What I Hate About Git by ubernostrum on Sunday August 05, 2012 @08:17PM (#4343162)
Thus git checkout -b makes perfect sense.

Does it? Pull and then merge is a common operation; it gets a top-level command. Create a new branch from the one I'm working on and check it out is a common operation; it gets a flag on an existing command. What logical, coherent process decides that in each case?

Branches have only one meaning in git!

Hence the "forces end users to do so". There are two very common ways people use branches: one is as a temporary place to do a quick bugfix, the other is as a long-lived place to do a major rewrite or refactoring. With respect to the history of the codebase, these have very different implications, but semantically are the same type of thing in git.

To pick on Subversion: when you had a long-lived branch in SVN, sooner or later you'd merge it back into the mainline... and then what happens? You want someone to be able to look at the repository and see that something major happened here and easily watch the progress, but you also want a way to say "this is done and merged". This required inventing a convention to indicate that -- in SVN, typically the finished branches would go in an "attic" directory.

In git you face the same problem: making a temporary branch, doing the work, merging and then deleting the branch is what you're supposed to do in git. But for those long-lived major branches, you need to invent a convention (commonly, tagging the merge point) to indicate that they're done.

I mentioned Mercurial because it has two different concepts for these things: the ephemeral deleted-once-it's-done line is a bookmark (which is pretty much exactly equivalent to a git branch, in that it's a named head that moves as you commit), and the long-lived major branch is... a branch. Which has additional semantics to indicate things like being finished.

This means that in Mercurial you don't have to invent and re-invent ad-hoc conventions to handle common development patterns, while in git you do.

Can't gitk do this?

Every time I say I want to see two branches side-by-side without invoking the VCS, someone says "well, here's a tool that invokes the VCS to do that!" Which shows a lack of reading comprehension.

Some folks need to branch differently than others.

Sure, but why isn't there a clearly-documented "most projects will get along fine with this" workflow? Or, rather, why are there dozens of them? We've had VCS tools for long enough that the best practices for common cases are out there.

The github workflow might be a little tricky, but as has been pointed out there are other workflows possible in git.

Oh, there are. But git + GitHub has been relentlessly hyped as an Oatmeal-ish fantasy of unicorns farting rainbows onto a field of lollipops, so that's how people actually end up using it, and so it's valid to mention that it's a more complex workflow for contributors since it is a very common case and becoming more common.

Re:What I Hate About Git by chris_wot on Monday August 06, 2012 @05:39AM (#4344546)
Every time I say I want to see two branches side-by-side without invoking the VCS, someone says "well, here's a tool that invokes the VCS to do that!" Which shows a lack of reading comprehension.

I'm guessing you check out a branch to a particular directory, and another branch to a different directory, then do a compare?

You could create a directory, stash you uncommitted files, then checkout the branch ad do a recursive copy to the directory you want to do the compare in. Then rinse and repeat for the next branch. After this checkout the original branch you were working in and retrieve the stash.

You could easily script this.

Re:What I Hate About Git by ubernostrum on Monday August 06, 2012 @11:52AM (#4345649)
I'm not necessarily asking for solutions at this point; I'm asking why the "solutions" involve jumping through so many hoops to work around the VCS in order to do something incredibly common.
Re:What I Hate About Git by pydave on Sunday August 19, 2012 @08:32PM (#4405765)
Isn't this is the same as subversion:

svn co remote_repo_path/branches/bugfix bugfix git clone -b bugfix ./local_repo_path bugfix

It could be simpler if you removed the trailing target folder name (but git would name the checkout according to the repo name, instead of the branch name).

Re:What I Hate About Git by ovatsug25 on Saturday August 04, 2012 @11:10PM (#4340462)
Joel Spolsky had the same concerns about Git when he first started using it. He changed his mind and wrote a great post on why distributed version control is way better than SVN.

http://www.joelonsoftware.com/items/2010/03/17.html

He also happened to write a tutorial for mercurial that explains the same concepts. The tutorial is linked to at the very end of the article.

Re:What I Hate About Git by elviejo on Sunday August 05, 2012 @12:22AM (#4340575)
Hg Init: a Mercurial tutorial by Joel Spolsky http://hginit.com/

It's a pretty good tutorial. But to me the mere fact that there are so many posts on How-to use a tool that is basic in a programmers arsenal, tells me that DVCS are a solution that lacks usability.

Re:What I Hate About Git by sigkill on Sunday August 05, 2012 @01:16AM (#4340669)
Ah, so it's by Joel.

I tried Git but failed miserably with it. It could probably be attributed to the lack of quality tutorials at that time. I then thought, "Fuck it, let's try Mercurial" and stumbled upon hginit. That is one awesomely written tutorial. I use mercurial for my programming needs and find it totally intuitive to use.

I definitely found it easier than git, but that could be possibly chalked up to my bad introduction to git.

Re:What I Hate About Git by tedunangst on Sunday August 05, 2012 @03:47PM (#4342421)
Personally, I think anyone familiar with cvs or svn can pick up hg really easily. The commands and concepts in hg map onto equivalents in cvs very nicely. My mental model of hg is just cvs + cvsync. Done.

git does not work like that. It's like each command was cut in half and recombined differently, like interlaced video or something. It's all there, it's just harder to recognize.

Re:What I Hate About Git by 2muchcoffeeman on Sunday August 05, 2012 @07:23AM (#4341180)
I tried Hg first and failed. Then I tried git and for some reason worked it out. DVCS concepts are hard when you're used to SVN.
Re:What I Hate About Git by sigkill on Sunday August 05, 2012 @11:06AM (#4341611)
Hmm. I can't really comment on that since I've never used SVN. I was kind of lucky to jump directly into DVCS. The reason why I'm comfortable with Hg is because at the initial/first step the only commands I was told to remember (by hginit.com) were `hg commit` and `hg init`. Slowly, from there I took on a steady pace and grew comfortable with it. Currently on Windows I use tortoiseHg and bitbucket (I'm strictly a hobbyist coder only).

When I tried to learn Git (before Hg), I looked for tutorials but everything was all over the place and maybe they introduced too much too soon. Anyway, at the end of the day I find Hg good enough for my usage - init, commit, push, pull so far.

Re:What I Hate About Git by nitrogen on Sunday August 05, 2012 @12:59AM (#4340638)
We are talking about programming tools here, not tools for home kitchen chefs to track their recipes. A little intelligence and hard work on the part of the user is expected.
Re:What I Hate About Git by GrumpySimon on Sunday August 05, 2012 @04:24AM (#4340926)
No that's just programmer masochism. If a tool is easy to use, then I get whatever I needed it for done, and done quickly. I can then move on to doing more interesting things (e.g. programming) rather than wrestling with the tool.
Re:What I Hate About Git by SiVal on Sunday August 05, 2012 @04:55AM (#4340975)
We are talking about programming tools here. A little intelligence and hard work on the part of the DESIGNER of the tools is expected.
Re:What I Hate About Git by regularfry on Sunday August 05, 2012 @04:36AM (#4340946)
Intelligence can be expected. Hard work should be unnecessary.
Re:What I Hate About Git by chris_wot on Sunday August 05, 2012 @07:14AM (#4341158)
Interesting non sequitur.
Re:What I Hate About Git by regularfry on Sunday August 05, 2012 @07:30AM (#4341189)
Why do you say that?
Re:What I Hate About Git by chris_wot on Sunday August 05, 2012 @07:38AM (#4341206)
Because it does not follow that if you are intelligent then you will not have to do any hard work.

Edit: appear to have annoyed someone with that comment! But do go on - prove to me how high intelligence means that you don't need to do hard work, which is the proposition of the OP.

Re:What I Hate About Git by sirclueless on Sunday August 05, 2012 @09:32AM (#4341379)
What on earth are you talking about? Git currently requires intelligence and hard work to learn properly. Regularfry suggests that we shouldn't need hard work to use a version control system. This statement isn't a proposition on the human condition, and doesn't need any proof.
Re:What I Hate About Git by chris_wot on Sunday August 05, 2012 @03:38PM (#4342381)
Actually, I disagree. It took me no more than about half an hour to understand and use git properly. I don't particularly consider it to have been hard work.

As for it not being a proposition on the human condition - I mistook what he was saying, but then after it was clarified I understand what was meant. It was unclear to me what was being said - interestingly enough, that is the entire argument being expressed for the reason why git is "hard work".

Re:What I Hate About Git by andrewflnr on Sunday August 05, 2012 @11:14AM (#4341630)
I think his point was that software should be designed so that if someone is intelligent, they won't have to work hard (remember, "hard work should be unnecessary", em. mine). But he optimized for pithiness over clarity.
Re:What I Hate About Git by regularfry on Sunday August 05, 2012 @09:22AM (#4341364)
> Because it does not follow that if you are intelligent then you will not have to do any hard work.

I don't think anyone's said that, or tried to say it (least of all me), at any point.

Re:What I Hate About Git by chris_wot on Sunday August 05, 2012 @09:30AM (#4341376)
You seemed to. You said "intelligence can be expected. Hard work should be unnecessary". What did you actually mean? I apologise if I misunderstood what you were saying!
Re:What I Hate About Git by regularfry on Sunday August 05, 2012 @10:08AM (#4341456)
I'm saying that while it may be valid to assume intelligence on the part of your users, that doesn't make it valid to make them work hard. I'm not saying that intelligence gets you out of hard work, I'm saying that it shouldn't necessarily get you into it - and from where I'm sitting, git requires both where it should only require one.
Re:What I Hate About Git by chris_wot on Sunday August 05, 2012 @03:46PM (#4342413)
Ah. I'm following you finally. Yes, I agree that unnecessary hard work shouldn't be needed.
Re:What I Hate About Git by philwelch on Sunday August 05, 2012 @01:02AM (#4340645)
Really? How many how-tos are there on text editors, programming languages, build systems, deployment systems, unit testing frameworks, frameworks, APIs, libraries, debuggers...?
Re:What I Hate About Git by bermanoid on Sunday August 05, 2012 @01:29AM (#4340692)
I spend at least an order of magnitude, if not several, more time with each of those things than I do with a goddamn version control utility.

I put in effort where it's worth it. Version control doesn't even come close to hitting the top of that list.

Re:What I Hate About Git by philwelch on Sunday August 05, 2012 @01:42AM (#4340718)
You build and deploy ten times as often as you commit? Apparently you really don't think version control is worth it!
Re:What I Hate About Git by einhverfr on Sunday August 05, 2012 @04:59AM (#4340979)
He said he spends ten times more time on building than on managing revision control. That doesn't mean 10x more deployment or development.

On the other hand, I can tell you we have almost 10x more downloads than we have svn commits ;-)

Re:What I Hate About Git by chris_wot on Sunday August 05, 2012 @07:19AM (#4341170)
There is very little that is hard with managing your source code on your local workstation.

To commit any changes, you type in:

  git commit -a -m "thing that I changed"
To branch, it's:

  git checkout -b newbranch
To switch back to the master branch, you just type in:

  git commit -a -m "changes made on branch"
  git checkout master
To merge in that branch, should you so wish to do so, then you type in:

  git merge newbranch
What is exactly so hard about that?
Re:What I Hate About Git by einhverfr on Sunday August 05, 2012 @04:52AM (#4340970)
"Way better" at what?

The thing that people need to get through their head is that distributed version control is a whole different concept. There are some things it is great at. There are some things it sucks at. Centralized version control is great at some other things, and lousy at some other things too.

I am thinking for example that if you are going for a PA-DSS-certified application, git, particularly with the ability to rewrite history, is going to be a problem, but dvs generally will provide more problems in assuring the auditor that you can locate, trace, and take corrective action if someone introduces a security issue (perhaps intentionally) into your application. I don't see git really working in that environment.

On the other hand, if you have a lively project that everyone is experimenting with and you need to merge patches occasionally to create a stable release, yeah, it's much better.

Re:What I Hate About Git by Aga on Sunday August 05, 2012 @06:49AM (#4341128)
Why would dvcs cause problems for auditors?

For any given project, no matter how distributed the development, you will have a "blessed" repository, from which the official releases are made. The history of this "blessed" repository is made not rewritable, even if anyone can push new stuff to it. The config files and hooks can be made writable by only admins.

Or you use a maintainer model, where the "blessed" repository is not even pushable. A maintainer (or a group of them) chooses what he merges in.

Re:What I Hate About Git by pgeorgi on Monday August 06, 2012 @06:11AM (#4344606)
A post why DVCS are better than SVN doesn't state anything about the qualities of git (unless it's actually about git, of course).

I have concerns about git and used distributed version control years before git existed.

Re:What I Hate About Git by reinhardt on Sunday August 05, 2012 @04:38AM (#4340950)
I use mercurial all the time even when I am forced to interact with git projects (thanks hg-git!) and I have no problem with rewriting history. What I do have problem with is atrocious CLIs that require you to remember cryptic incantations to do the simplest things. Two anecdotes:

- Colleague #1 has become sort of comfortable with git but only after heavily customizing gitconfig and setting up a dozen or so aliases for the most common commands.

- Colleague #2 is a devops, lives and breathes inside the command line, and still uses a GUI instead of the cli for git.

Re:What I Hate About Git by pwang on Monday August 06, 2012 @02:49PM (#4346577)
So you have had good luck with hg-git, then? Does it play well with github?

I've read mixed reviews... I'm OK with git but am deeply displeased with how difficult the learning curve is for a casual user. I'd much rather that Mercurial won.

Re:What I Hate About Git by einhverfr on Sunday August 05, 2012 @04:45AM (#4340961)
Here's the thing though. I have been using SVN for years and am not learning Git. For a long time I figured I was just disoriented and eventually it would come. Now I am less convinced. The article really described my experience pretty well to the point where I am thinking the only sane way to use git is along with subversion.....

In essence, the more I learn, the less I like it, and the more convinced I am that it isn't what I need right now. Building accounting software there are certain things I need in a revision control system. These are:

1) revision control as audit trail. I need to know who committed a change and I need an audit trail on that. SVN isn't perfect here. I'd like to be able to audit changes to commit logs too, but that's pretty minor stuff.

2) collaboration among a smallish number of committers (right now maybe 4 active at any given point in time).

Folks have pushed git because it makes it easier for users to share modifications with eachother. That's fine, and it's a good point, but it isn't worth getting rid of a clear and reliable audit trail in order to achieve. To this end I suspect we are more likely to pursue a hybrid solution with all the complexity that provides (and indeed it is already partly implemented) than a pure git solution.

Allowing rewrite of commits is a problem not because developers might do it but rather because you can't show that developers didn't do it. If there is a question about whether a security issue was intentionally added to the code or not you need to have a clear audit trail. A basic principle of any audit trail is that your audit trails may not be overwritten.

Re:What I Hate About Git by rmc on Sunday August 05, 2012 @05:22AM (#4341020)
Git version numbers are actually SHA1 hashes that are based on all the files and the entire history of the project up to there. If you modify the history in any way, then that will be a new version number and you know something has changed.

You can optionally GPG sign a commit/tag which, again, will be invalid if any part of the history is changed.

Re:What I Hate About Git by mdwrigh2 on Sunday August 05, 2012 @04:54AM (#4340974)
Just require commits that are signed off with GPG keys. Then you have a clean, verifiable audit trail through git. Beyond that, you'll have the full development history on your machine, which they can't just arbitrarily change.
Re:What I Hate About Git by einhverfr on Sunday August 05, 2012 @05:02AM (#4340985)
Do you think that's more or less complex than just using svn-git to manage the authoritative audit-trail repository?
Re:What I Hate About Git by mdwrigh2 on Sunday August 05, 2012 @05:35AM (#4341039)
Less, managing two version control systems seems like insanity (speaking as one who's had to do it in the past). Having people sign their commits is dead simple in Git, and you could setup hooks to make sure every commit is signed before you accept it.

An alternative (or additional) solution is to setup a server like Shawn suggests in this e-mail: http://git.661346.n2.nabble.com/Implementing-commit-signing-...

Re:What I Hate About Git by lrem on Sunday August 05, 2012 @07:00AM (#4341141)
This actually is the usage scenario for which Fossil[1] was created (in fact DRH made it to be in accordance to some aviation industry norms, don't remember details). Furthermore, one of the ideas behind Fossil's design was to minimize the learning curve for someone who already knows SVN.

Disclosure: I occasionally committed something to Fossil.

[1]: http://fossil-scm.org/

Re:What I Hate About Git by einhverfr on Sunday August 05, 2012 @08:37PM (#4343209)
Fossil looks promising. Thanks. I have bookmarked it.

Of course there was a typo in my previous post. I am "now" learning git, not "not" learning git.

Re:What I Hate About Git by notJim on Saturday August 04, 2012 @09:46PM (#4340297)
I disagree with the very first thing you said. git has far more concepts that it just throws out at you than svn. I don't think it's fair to say they've equivalent. Even as a fairly long-time user who is quite comfortable with git, it is sometimes overwhelming. With svn, I basically had to know what a revision was, and maybe a branch, and that's about it. To use git effectively, I have to know about commits (and their graph-y nature), remotes, the concepts of pushing and pulling, rebasing vs merging, and if I'm reading the documentation, I am rapidly going to begin running into concepts like "refs". Of course the rabbit hole keeps going deeper, but a lot of that stuff you won't really need to know.

Personally I know what all these things are, and again I'm quite comfortable with them at this point, but there was absolutely a learning curve, and I'm reminded of it every time I start explaining something to a more novice coworker.

Also, for the record I like git a lot. But it's not immune from criticism.

Re:What I Hate About Git by icefox on Sunday August 05, 2012 @02:18AM (#4340780)
I would further argue that #10 is wrong. He compares commits to a project you own to contributing to a project you don't own. If you don't have commit access to a svn server you are for the most part out of luck. Emailing the patch to a mailinglist or some dude is about the best option and even then it has a good chance of either not making it in or taking a very long time. So meanwhile you want to keep your changes going, how do you do that? A bunch of patches you apply every time you svn update? Run your own svn server, import their code and apply patches on that? What about merge (hell) time? Perhaps you do want commit access to the svn server. Just first mail this form via the post office to me or maybe fax the form and then after that first contribute 100 perfect patches and maybe then we will give you commit access. Ugg. Comparing this with Git where making your own fork where you can potentially make contributions from is _easy_ and you can publish this repo in many places.
Re:What I Hate About Git by cacois on Saturday August 04, 2012 @09:43PM (#4340291)
Nothing against learning new things, but why defend user interfaces or workflows that are needlessly complex or unintuitive? DCVS is certainly a significant advance over centralized VCS, but that doesn't mean Git couldn't be made significantly more accessible. More readable documentation alone would have made learning git a great deal easier for me.
Re:What I Hate About Git by SiVal on Sunday August 05, 2012 @05:21AM (#4341014)
Number 1-5 are mostly "I don't want to learn new things", so I'll ignore them.

The whole post is about a system that is badly designed or implemented, making it unnecessarily complicated to learn and use. Not wanting to have to deal with unnecessary complications is not the same as not wanting to deal with necessary complications. People unfamiliar with good UX design can't tell the former from the latter.

Re:What I Hate About Git by xpaulbettsx on Sunday August 05, 2012 @08:23AM (#4341269)
If you find yourself confused and frustrated like the author, here's how to make git make sense:

1. Temporarily forget everything you know about every other system, and imagine they didn't exist, and that you have to solve this problem yourself. How might you do it?

2. Read Tom Preston-Werner's "The Git Parable" (http://tom.preston-werner.com/2009/05/19/the-git-parable.htm...).

Read it very carefully - the minute you start skimming, you'll start filling in gaps using your Subversion knowledge and be lost again. If you really want to understand, read this aloud.

Re:What I Hate About Git by borplk on Sunday August 05, 2012 @06:17AM (#4341086)
Couldn't disagree more. Git throws too many unnecessary things at a beginner to learn. Sure you could read every damn book about git and learn it. But why should you in the first place? I don't know what it is with this attitude amongst so many nerds that "oh it's hard? you're not smart enough, just go learn it" this is not the attitude that pushes us forward.
Re:What I Hate About Git by antihero on Sunday August 05, 2012 @09:10AM (#4341340)
This is absurd. It is a tool to aid the development of software. If you can learn a goddamn language, you can spare 20 minutes to figure out the extra couple of steps git can add.
Re:What I Hate About Git by sirclueless on Sunday August 05, 2012 @09:48AM (#4341411)
I can tell you it took me a lot longer than 20 minutes to master working with git. Sure, you can tell someone how to clone, branch, commit and push in 20 minutes, but that's not really understanding.

For example, last month I was at a meetup, and had to help someone who was contributing to an open-source project. She had been following the project's instructions on using git, but was stuck. It turned out that she had hit a snag in the middle of a multi-commit patch that was applied with "git am" and as a result, her repository was in an intermediate state and the usual commit, add, reset etc. commands weren't working. I helped her back out to a clean state, but it took me several minutes of scouring documentation to do it, and I consider myself proficient with git. If I hadn't been there, I expect she would have given up on the whole thing, and all because git has some bizarre interactive processes that leave your repository unusable while in progress.

I think it's undeniable that git is unfriendly and obtuse at times, and the people who think otherwise are just examining it too close. They have mastered it, they see all of the justifications for each quirk, and because of that they can't see the big picture, which is that it is extraordinarily difficult for a new programmer to pick it up and be proficient.

Re:What I Hate About Git by phillmv on Sunday August 05, 2012 @12:12PM (#4341787)
So what? A goddamn language is easy compared to git - they all mostly work in the same way.

I don't understand this attitude. Why can't our tools be so easy to use that you don't need to read the instruction manual?

Conceptually, there's nothing that difficult about using git. I have some files that I want to be versioned. Yet, the commands are inconsistent and any non trivial operation requires consultation of a variety of tutorials.

Why do we have to settle for this? Why can't the tool be internally consistent?

Re:What I Hate About Git by retrogradeorbit on Monday August 06, 2012 @02:20AM (#4344077)
20 minutes, hey? Not in my experience.
Re:What I Hate About Git by exDM69 on Monday August 06, 2012 @07:41AM (#4344770)
* "Unsafe version control"

* "Git history is a bunch of lies"

These come up time to time. If you need safe Git history, you're supposed to sign your commits with GPG. Git has built-in tools for that. Linux kernel and many other major projects use signed commits. In addition to keeping the repository safe from changes in the history, it will also protect you when your git server gets hacked (where Subversion will fail).

If I read one more blog post that brings this up, I will cry.

What comes to the squash/rebase/rewrite history part, it's a good idea to not commit any revisions that do not build and run to your master branch. If you push a revision that doesn't build, you'll have a harder time doing "git bisect" (you can skip broken builds, though). It's a good idea to squash and rebase before commit to master. Use git merge --no-ff if you want a merge commit in.

Re:What I Hate About Git by robomartin on Sunday August 05, 2012 @01:42PM (#4342026)
Git is alright. You can learn it just like anything else. Yeah, it could have been simpler. Agreed. It comes from Linus, who judging only from the talks I've seen online --don't know him personally, can be very opinionated and "asshole-ish" at times.

My pet peeve with Git is that it stopped once it supported Linux kernel-type projects. If you are working on anything other than that it is likely that you are going to run into all manner of non-text resource files and Git sucks at helping you maintain these. Case in point: Graphically intensive iOS apps.

Re:What I Hate About Git by RivieraKid on Sunday August 05, 2012 @07:52AM (#4341231)
The point of the article was, that git's UX sucks. People complaining is by definition bad UX. Experience, which people complain about, is not good.
Re:What I Hate About Git by wisty on Sunday August 05, 2012 @02:03AM (#4340764)
> Number 1-5 are mostly "I don't want to learn new things", so I'll ignore them.

Then I take it you'll agree C++ is better than C?

Re:What I Hate About Git by ansgri on Sunday August 05, 2012 @04:31AM (#4340940)
Good analogy to C++ vs C. C++ gives you a lot of power previously unavailable, as git does. And there seems to be no canonical ways to do anything neither in C++ nor in git. And that does confuse a lot!
Re:What I Hate About Git by klodolph on Sunday August 05, 2012 @06:25AM (#4341102)
Non-sequitur. My point is that if you assume C++ is just like C, you'll end up writing bad C++ code.
Re:What I Hate About Git by laughinghan on Saturday August 04, 2012 @10:09PM (#4340345)
I believe in the power of user interfaces, and I believe tools should be as easy to use as possible, and I dislike the "I don't like to learn new things" argument because actually, yes, your tools should make you learn as little as necessary to use them. But quotes like:

here’s a diagram illustrating the commands a typical developer on a traditional Subversion project needed to know about to get their work done. This is the bread and butter of VCS: checking out a repository, committing changes, and getting updates.

make clear that when this author says they're listing ten things git does wrong as a version control system, but what they're listing is ten ways git isn't Subversion, and I'm sorry, but maybe if instead of writing blog posts about how a tool's user interface wasn't like what you unfairly expected of it, you actually learned how to use the tool, you'd be using it right now to make something awesome.

What I'm saying is, I think I'd rephrase

Number 1-5 are mostly "I don't want to learn new things"

to

Number 1-5 are mostly "I'm going to blame my tool for me refusing to do the bare minimum to learn how to use it"

Re:What I Hate About Git by est on Sunday August 05, 2012 @11:39PM (#4343604)
> Number 1-5 are mostly "I don't want to learn new things"

More like overcomplicated things. Git can be made simpler.

Re:What I Hate About Git by batista on Sunday August 05, 2012 @08:53AM (#4341309)
>Number 1-5 are mostly "I don't want to learn new things", so I'll ignore them.

Ignore them at your own peril.

"Not wanting to learn new things" is very different from "Not wanting to learn needlessly complicated mess of new concepts because nobody bothered to clean up the conceptual spaghetti".

Which is the case here.