Custom methods won’t have the benefit of being dealt with as if they shared specific semantics, such as being treated as safe methods or idempotent, but ultimately that’s just an expected trait that anyone can work with.

In the end, specifying a new standard HTTP method like QUERY extends some very specific assurances regarding semantics, such as whether frameworks should enforce CRSF tokens based on whether a QUERY has the semantics of a safe method or not.

However, we’re still implementing IPv6, so how long until we could actually use this?

We can already use custom verbs as we please: we only need to have clients and servers agree on a contract.

What we don’t have is the benefit of high-level “batteries included” web frameworks doing the work for us.

Erm yeah because the whole point of monorepos is that you don’t use submodules. What?

Not true. The whole point of monorepos is that you track everything in a single repo. There is absolutely no requirement or constraint to avoid using specific features of specific VCSs or even package managers.

Neither does Git though.

Doesn’t it, though? I mean, you can update a submodule’s history directly from the consumer package. That’s the whole point of submodules. Otherwise you would be better off by just wget something into your project.

I don’t see why using submodules as a package manager should excuse their endless bugs.

I don’t know what are these “endless bugs” you’re talking about. Submodules might have a UX that’s rough on the edges, but there are really no moving parts in them as they basically amount to cloning a repo and checking out a specific commit.

Do you actually have any specific, tangible issue with submodules? Even in the cases you’re clearly and grossly misusing them

It’s interesting that the internet is packed with search hits of complains that Cloudflare’s DNS is slowing everything but Cloudflare representatives are quick to post followups pointing the finger everywhere else.

Aside from the obvious UX disaster, Git has some big issues:

I find this blend of claims amusing. I’ve been using Git for years on end, with Git LFS and rebase-heavy user flows, and for some odd reason I never managed to stumble upon these so-called “disasters”. Odd.

What I do stumble upon are mild annoyances, such as having to deal with conflicts when reordering commits, or the occasional submodule hiccup because it was misused as a replacement for a package manager when it really shouldn’t, but I would not call any of these “disasters”. The only gripe I have with Git is the lack of a command to split a past commit into two consecutive commits (a reverse of a squash commit), specially when I accidentally bundled changes to multiple files that shouldn’t have been bundled. It’s nothing an interactive rebase doesn’t solve, but it’s multiple steps that could be one.

Can you point out what is the most disastrous disaster you can possibly conceive about Git? Just to have a clear idea where that hyperbole lies.

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.

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?

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.

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.

deleted by creator

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.

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.

https://git-scm.com/docs/git-gui/

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.

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.

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”.

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.

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?

Here’s the sauce

I don’t buy it. Unauthorized access attempts are a constant on the internet in general, and in AWS endpoints in particular. When anyone exposes an endpoint, it’s a matter of minutes until it starts to get prodded by security scanners. I worked on a project where it’s endpoints were routinely targeted by random people running FLOSS security scanners resulting in thousands of requests that were blocked either by rate-limiting or bad/lack of credentials. I don’t believe that a single invoice of $1k would trigger such a sudden and massive change of heart, when accidental costs in AWS easily reach orders of magnitude above that price tag.