Coming from the days of CVS and SVN, git was a freaking miracle in terms of performance, so I have to just put things into perspective here when the topmost issue of git is performance. It's just a testament how huge are the codebases we're dealing with (Windows over there, but also Android, and surely countless others), the staggering amount of code we're wrangling around these days and the level of collaboration is incredible and I'm quite sure we would not have been able to do that (or at least not that nimbly and with such confidence) were it not for tools like git (and hg). There's a sense of scale regarding that growth across multiple dimensions that just puts me in awe.
It's really hard to overstate how much of a sea change git was.
It's very rare that a new piece of software just completely supplants existing solutions as widely and quickly as git did in the version control space.
“Orders of magnitude” is probably out of line, and there’s always the case for “horses for courses” (or “tool for the job”, more broadly), but to say git is better than what appeared before (cvs, svn) could be interpreted as both true and useless. Pretty much any distributed source control management (DSCM) software is what modern development is using today, and better than the previous decades tools (cvs, svn). Git is but one example in the DSCM field. You mention it has a terrible UI, and I’m inclined to agree. The workflow might be described as terrible too, and maybe it’s a contributor to the UI. Git probably became what it is to a large extent because of the cult of personality of Linus, despite git itself. Sure it’s better than CVS, but in defence of GP post, it’s not unreasonable to push back because “good enough” (git) is standing in the way of “good” (fossil). That all said, cult or not, git has its network effect now, which is a powerful thing no matter what ones opinion of git is. I suspect we’re really probably remarkably in agreement wrt how fortunate we are in the code management field, and we should all be grateful, but that doesn’t preclude asking for more from our tools. We are privileged to be in a world where a fossil or mercurial, or bitkeeper user can “fall back” to git. We otherwise have an embarrassing amount of good choices for capable version control. Indeed, a good time to be alive.
That's nonsense. Git is the best version control history of all time. It has some regrettable UX difficulties, but as far as the system itself, there is no better decentralized development tool.
There's a reason git came into existence for linux kernel development. The linux kernel is a project so massive and so decentralized that it needed a fitting tool to be able to tame the chaos. And git did that perfectly.
Out of curiosity though, what to you is a better source control system?
Git seems to have it all. It's hard to imagine what anyone else can compete with, how they can differentiate. There's such a variety of ways to work & rework git repos, so much sheer capability available to use as you will that it's hard to imagine what more one could want.
Indeed it feels like most competitors are competing by offering less. This is our way! This is easier! But you're not going to win the alpha geeks over with that path. Better needs to be bigger, needs to enable more, and we're just not seeing those offerings materialize; it's unclear how you would be better or bigger.
Having the core abstractions that work & are flexible enables bountiful innovation & improvements. Git not only started with sufficiently malleable core ideas, but it's had endless features, optimization, and tuning baked in over the years. It's almost too much to comprehend. Shout out to Taylor Blau writing on the Github Blog: the man has been doing an amazing job covering what's happening in with the Highlights From Git series, since September 2018. It's really given me a sense of how much work keeps being poured into git, has given me a view of how incredibly expansive the git ecosystem is. https://github.blog/2018-09-10-highlights-from-git-2-19/https://github.blog/tag/git/
We say this now, ignoring the hot messes that were SourceSafe, Pervasive, CVS, and SVN. Git is light years more elegant that predecessors, and its holding power is evidence of that. We're able to criticize now because we've had the privilege of forgetting (or never having experienced) just how bad it used to be, and the sheer amount of time with one tool that's been a staple for far longer than previous tools lasted.
I dunno, git spawned a revolution in how we think of version control (even mercurial came out of the initial discussions of git); that's a pretty big deal.
Why is git so successful? It has good internals and has had those good internals for years and years, which covered up for its many flaws. Add on to that: network effect due to linux, github, and gitlab all using git.
Git is great, compared to most of the alternatives. But is it perfect? Of course not. Is it hugely flawed in parts? Of course it is. It has a UX designed by freaking engineers FFS, it's surprising it's as usable as it is.
The observation that git forces you to learn how its guts work so that when you inevitably end up in some scary situation with the potential of losing or screwing up revision history you know enough to work your way out of it is not a strong argument. It's similar to the lament about how older cars were so much easier to work on and that made them better. Better if you want to work on cars, perhaps, but a vehicle that requires constant maintenance is not superior to today's cars that can be run for 100k miles with minimal engine work and a single set of spark plugs, and are also safer, more efficient, and cleaner to boot. The same thing goes for VCSes, if you're regularly, or ever, getting into hairy revision history problems that's a sign of a weakness in your VCS and/or workflow.
Git is like linux in... 1996 maybe. The underlying technology is pretty awesome, but it leaves a lot to be desired in terms of usability. Git is enormously powerful, but it has some key weak spots that can lead to intense frustration, and it doesn't exactly guide users into using it in the best way possible.
Git is ... alright, but it doesn't deserve quite as much praise as it gets. I have well over a decade of experience using source control at a fairly high level, and I have experience with a wide variety of source control systems. Git is currently more or less the best thing that's out there in a lot of ways, but it still has a whole shit-ton of shortcomings.
Even when you use git according to the finest shade grown, hand picked, organic best practices available you are still going to routinely run into situations where dealing with git is just a straight up pain in the ass for no good reason. Every source control system has its weaknesses but in some ways git's are even more annoying because so much of the rest of it is engineered so well. It's like opening up the trunk on a maserati and finding a compartment that's lined with splintery unfinished recycled pallet wood and held together by chewing gum, it makes you wonder why it's there and why having some piece that is such a comparatively low quality continues to be tolerated year after year.
Again, overall I think git is pretty great, but the persistent lack of effort toward improving git's core weaknesses is incredibly frustrating.
The irony that Git was instrumental in the evolution to GUI-based computing, but didn't also make that same jump to lightspeed has always dumbfounded me.
Git, like God, is good :) But even, over time, God has evolved and gotten more accessible.
reply