it's just backup of current state with irrelevant commit message. Everything is described at the end of the work in PR's description and squash merged.
Unfortunately a good chunk of the industry doesn't have the discipline to do this.
If you have ever worked in a project where there was discipline around committing, you know there is lots of value in doing so (rebasing becomes easier, you unlock the power of bisect, log is actually useful).
Also doing PR code review is soo much nicer if each commit is logically self contained with a nice commit message.
I think they just want to replace some of the words with alternatives that they prefer. Because at some point someone is going to winge that update should be syncronise and not pull, and save should be push and therefore git is the worst.
Git is distributed, and that means you can't get away from push, pull and fetch, however you name them.
If want you want is a way to avoid making "New New Presentation FINAL 2", then pretty much all features of most source control systems are superfluous.
To me that doesn't mean Git needs fixing, it means it's definitely not the right tool for your job.
Git definitely has some warts but you are right. It is an industry tool for expert, professional use. Some complexity is inherent to the problem of version control.
Learning how to use your tools is part of ANY trade.
If you were talking about things like Kubernetes, LLVM, Ghidra then I'd agree.
But no git. This is not some expert tool.
This tool's purpose is literally to manage your characters' history, that's it.
Git could be used by any other profession that deals with letters - article writers, book writers, etc, etc.
Yes, but you seem to heavily underestimate the complexity of the problem and the volume of the use cases that git solves.
The fact that git is used by experts and professionals is not an excuse for poor UX. The experts and professionals are almost never Git experts or professionals. I use my car every day, that doesn’t make me a mechanic. Having to understand the inner workings of a tool is an indication of poor design, not a gatekeep we should seek to maintain.
One is: how do you effectively manage changes to a codebase over time? Git has a model that, for day-to-day use, has primitives like "commit", "branch", and "tag". You also have to understand the difference between your working copy, what is staged for commit, and any other commit in history. These, in combination with the operations you can do with them is actually somewhat complex. This is the thing I am saying people need to learn. And people quite often complain about it.
The other is the organization of git's porcelain layer, the arguments and flags each subcommand takes, and how stuff is presented back to the user. I think git stands to make significant improvement here. Be that as it may, the tool exists as it is. So your options are to use a different VCS entirely, use a different frontend, or learn how to use git as-is.
If you choose to use git but deliberately avoid learning e.g. what a rebase is and why it's useful, you are choosing to be an ineffective developer. Could it be better in some ways? Yes, but it isn't.
I don't think the car analogy is particularly compelling. The "primitives" of a car are already much simpler than git's. The fundamental primitives of a car are "go faster" and "go slower", along with some supporting things like managing your headlights, windshield defrosting, wipers, and horn.
While additional tools are being added to cars to make them safer (e.g. a backup cam or collision detection), the complexity of those tools is increasing rapidly which makes them more prone to failure. And a driver is absolutely not excused from causing an accident just because one of these safety tools failed. You still have to know how to safely operate your vehicle in a variety of conditions.
Speaking of your analogy, the role that most software developers fullfil is not an engineer wondering about the oscilloscope, but rather the construction worker installing electrical fixtures wondering why the cable clamp has such a weird interface. Both the oscilloscope engineer in an office and the worker doing the field work would benefit from having a simple and reliable tool fit for purpose of cable clamping.
There is certainly a need for competent and "proper" software engineering that require special tools and detailed training, but I would argue it's niche and filled by people who build the tools themselves.
IMO the largest share of developers today are doing brick-laying work (which of course takes skill, I am not underestimating it) and would benefit a lot from having simpler tools - they don't need to know how to use an oscilloscope at all.
They're doing brick-laying work until they aren't. Most problems are easy to solve and don't require very much fussing over. The expertise comes in knowing which problems are worth fussing over and which aren't.
Technology is becoming ever more present in our lives, not less.
Reducing software engineering to a low-skill trade when there is, in fact, mountains of complexity is surefire way for software to be a heap of shit. And in a lot of ways it already is.
I fully agree with this observation, but the reality is that this is where things are going.
Software quality is simply not that relevant today for the majority of software. As long as the billing works fine, the management is happy to see your website barely working - screw the quality if the money is coming in anyway.
Such software costs much less and can be built by bricklayers.
You can have both - powerful and user friendly.
This idea that engineer's tools must be a mess that is fine as long as enables to do something is idiotic.
The same argument was repeated whenever C or C++ vs Rust discussions were happening
"Just learn C and memory management (and all the quirks)"
"Just use this new language constructs and you're fine..."
and in reality we ended with a lot of CVEs - 70% in both Chrome and Windows were related to mem. issues.
There's absolutely no reason why git's CLI cannot be better than it currently is. Once again - there is no reason.
Proof? There are CLI wrappers or even GUIs like GitHub Desktop that make whole experience way better.