git lfs was supposed to help but it only solves the storage side, not the permission side, and it's pretty slow compared to p4.
I doubt pijul will make a dent in solving AAA game devs vcs issues though
Data Version Control (dvc.org) is a far better model.
Pijul has the potential to do that, since patches provide a very easy interface for doing partial checkouts: - just pull patches related to a particular part of the repository. - don't pull patches related to artwork frequently.
Since Pijul patches always commute, this could work.
Additionally, I hear the new (unreleased) Pijul can split patches between a "transform part" (e.g. "I inserted 2Tb in file f, and deleted 1") and a "contents part" (e.g., "here, have your 2+1Tb: …").
Once you hit that all the theory and nicities went out of the window.
At the time it was probably CVS to darcs, then it became darcs -> hg, and giving in to the inevitable it became git.
That's kind of the point of Pijul
The momentum is clearly behind git, and has been for quite some time. None of the more recent contenders have ever become popular (bzr, fossil), though of course they have their advocates.
Having the code be reworked in-private, for a long time, too doesn't make it seem like it is ready to become usable in the short-term.
I’m old enough to remember the same thing with MS-DOS when GUIs first started to become mainstream.
Git is extremely flexible and allows you to implement almost any workflow you want. But its command line interface isn't intuitive and there are still enough opportunities to shoot yourself in the foot. It's still too easy to get yourself in a situation where you need the Git expert on your team to unwedge the repo.
Sure, I'm a Git user, but not because I wanted to be one; it's the de facto standard and there's a large ecosystem of support for it, starting with GitHub and GitLab.
I use Mercurial for personal projects because I don't want or need the cognitive overhead of Git when I'm doing something for myself.
Out of the box, Mercurial doesn't give you access to a foot-gun unless you really want it. But when you're starting out, you don't want to shoot your foot off before you know what you're doing.
I enjoy Mercurial’s concept of changeset evolution[2] and Phases[3] which helps avoid all of the coordination and potential drama of rebasing on top of changes that shouldn't have been changed, etc.
The Evolve plugin[4] allows for intelligent and sane history rewriting, using the underlying support for changeset evolution.
The Evolve plugin also provides support topic branches[5], reducing the overhead of managing them.
There's a great description of how this works in Mercurial on the Git Minutes podcast[6].
[1]: Stockholm syndrome is a condition in which hostages develop a psychological alliance with their captors during captivity. Emotional bonds may be formed between captors and captives, during intimate time together, but these are generally considered irrational in light of the danger or risk endured by the victims.
[2]: https://www.mercurial-scm.org/wiki/ChangesetEvolution
[3] https://www.mercurial-scm.org/wiki/Phases
[4]: https://www.mercurial-scm.org/doc/evolution/user-guide.html
[5]: https://www.mercurial-scm.org/doc/evolution/tutorials/topic-...
[6]: https://episodes.gitminutes.com/2013/05/gitminutes-07-martin...
And those experienced people likely want a foot-gun and probably use it every week. And their workflow has been evolving since VAX era, so by now is so weird, only something like git can handle them.
Imagine a conversation: "git is great! Remember how back in CVS days you had to generate patch(1) files if you wanted to save you work? well, in git it is much easier, you just need to ... Wait, what do you mean you don't know patch(1) is?" :)
What’s ironic is that many of Mercurial’s commands are the same as CVS and Subversion, which makes switching easier.
Git’s commands are often quite different.
I would argue that GitHub was the killer app for Git: it was so compelling that people were willing to put up with Git’s issues so they could use it.
People forget that Mercurial had the early lead in terms of mindshare; many companies adopted it because it was easier for their developers to learn and its syntax was familiar to anyone who used CVS or Subversion. (Linus’ disdain for Subversion is no secret; perhaps that was part of the reason he was okay with Git's syntax being somewhat backwards compatible).
At a certain scale, Git's issues can be too much of a liability, as described by Facebook: https://engineering.fb.com/core-data/scaling-mercurial-at-fa...
For example, look at Google's assessment of Git vs. Mercurial: https://web.archive.org/web/20130116105028/http://code.googl...
Here's the first advantage of Mercurial cited by Google:
Learning Curve. Git has a steeper learning curve than Mercurial due to a number of factors. Git has more commands and options, the volume of which can be intimidating to new users. Mercurial's documentation tends to be more complete and easier for novices to read. Mercurial's terminology and commands are also a closer to Subversion and CVS, making it familiar to people migrating from those systems.
Release processes benefit from incremental commit numbers. They are easy to reason about in release planning. They are useful for gating features. Example: Wait until api server deploys commit number N or higher before enabling app feature A. They provide an easy way to track the age of binaries running in production. Example: We can turn down API B once every deployed production binary is built from commit number N or newer, since that is when we deleted the API B client library.
Merging and rebasing is easier to understand with incremental commit numbers.
Git has no support for code reviews. For example, it provides no functions for distributing versions of uncommitted changesets, distributing comments on uncommitted changesets, or linking comments to particular versions of changesets. These are core parts of the software development process. Code review comments are crucial context for future readers to understand the code. They belong in the repository with the code.
Git's "stash" function is full of footguns and is therefore mostly unusable.
Git's nomenclature is inexact. A git "commit" is actually a set of changes to files. It would be better called a "change set", "change list", or even "diff".
Git's documentation needs work. It needs to explain common use cases. It needs to warn of more pitfalls. It needs more common use case examples. For example, https://git-scm.com/docs/git-revert has no example of specifying a particular commit or a set of commits. Another example, https://git-scm.com/docs/git-stash is missing a link to the article https://git-scm.com/book/en/v2/Git-Tools-Stashing-and-Cleani... and that article needs a big fat warning about the biggest footgun: using 'stash' and then 'reset' and accidentally erasing untracked files that you thought were stashed.
Git sees every source file as plain text, ignoring structure. For example, reformatting destroys blame info. Changeset metadata includes lines added/deleted/modified but treats whitespace changes the same as changes to comments, data, and logic.
Git provides no access control functions. Users must rely on third-party tools. Users need to apply ACLs to source, code reviews, and test output. This is complicated to set up with third-party tools.
I use git and I look forward to switching to a better tool in the future. Maybe Pijul will be it?