461
Linus Torvalds built Git in 10 days - and never imagined it would last 20 years (www.zdnet.com)
submitted 1 year ago by to c/programming@programming.dev
70 comments fedilink hide all child comments
you are viewing a single comment's thread
view the rest of the comments
[–] 12 points 1 year ago* (3 children)

It could've been mercurial, but I'm glad that didn't happen. Being shouted at in a mailing-list for fixing a bug doesn't sound like fun. Also, the amount of CPU resources that would be wasted running a VCS in python would be phenomenal. And have fun trying to develop a project using a separate python version than supported by your python VCS.

Anti Commercial-AI license

  • permalink
  • fedilink
  • source
  • hideshow 6 child comments
    •
  • [–] 2 points 1 year ago (4 children)

    Care to explain your comment for a layman?

    From my limited experience mercurial is way more intuitive than git. The big one is named branches are a thing instead of an abstraction.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 8 child comments
    •
  • [–] 9 points 1 year ago (2 children)

    What do you mean by "are a thing?" Git has branches.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 4 child comments
    •
  • [–] 7 points 1 year ago (1 child)

    Git branches are very different to Mercurial branches. In git they're similar to tags that move along with the head commit of that particular branch. In Mercurial every commit contains meta data indicating the branch it's on. It also has a query language that lets you do sone quite neat things with selecting groups of commits based on their metadata, which can be useful in code reviews and similar.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 3 points 1 year ago (2 children)

    That just sounds like an implementation detail.

    Can you provide an example of something that's possible in Mercurial, but not git?

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 4 child comments
    •
  • [–] 3 points 1 year ago (1 child)

    I've never used Mercurial, but a simple one based on the explanations and my experience with Git:

    Locating the branch a commit originated from. If a git branch has been merged into (or rebased on) main or another branch, there's no way to tell which commit came from which branch. But sometimes I'd really like that information to figure out what prompted a certain change. Without it, I need to use external tools like a ticketing system and hope the other developers added in the necessary information.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 2 points 1 year ago*

    That seems to be the opposite of useful if a commit is initially pushed to a development branch, which is relatively standard practice; now you're polluting the tree with data that's purposefully ephemeral, and even potentially leaking internal information.

    Also, I'd argue that such deep details do belong in another tool, rather than asking the source control tool perform triple duty by being a CR and issue tracker as well.

  • permalink
  • fedilink
  • source
  • parent
  • [–] 1 point 1 year ago

    Most of the time you're right, it's little more than a detail, but sometimes I miss the querying that it allowed. You could ask for things like a list of all branches that branched from a specific parent branch and modified a specific file, Which can be handy when you want to understand the impact a change might have before you make it and try merging.

    Having the branch name embedded in the commit means you can meaningfully ask this sort of question. In git's model you can't say a changeset is in a specific branch once there are child branches further downstream because the changeset is in all of those branches.

    Rather than come up with lots of examples for other queries (I know it wasn't the focus of your question, but I think it's really neat), I found this page which seems like a reasonable description.

  • permalink
  • fedilink
  • source
  • parent
  • [–] 3 points 1 year ago (1 child)

    No, git has labels on heads of branches. Once the head moves you loose the information. It also makes for a more messy history, which I believe created the whole "rebase everything" philosophy to cope.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 4 points 1 year ago (1 child)

    What information is "loosed" when another commit is made to the branch?

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 1 point 1 year ago* (1 child)

    If I hand you a commit, you cannot tell which ‘branch’ it is on without searching the git history and hoping that you only get one answer. That’s a bummer if, for instance, you’re a github action and only get handed the commit. If it’s on the master branch, I want to do different things than if it’s a dev branch.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 3 points 1 year ago (1 child)

    A commit all by itself doesn't mean as much without context.

    Why would I not want to be able to apply a commit to any arbitrary branch?

    Also, GitHub is not git - it's based on git. Any shortcomings it may have aren't necessarily due to a flaw in git.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 1 point 1 year ago* (1 child)

    A commit all by itself doesn’t mean as much without context.

    Luckily a commit points to its parent, which means the context is inherently present. What’s your point?

    Why would I not want to be able to apply a commit to any arbitrary branch?

    Nobody said that.

    Any shortcomings it may have aren’t necessarily due to a flaw in git.

    True enough.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 1 point 1 year ago (1 child)

    Your claim appears to be that Mercurial binds commits to branches, and I'm explaining how I fail to see the advantage.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 0 points 1 year ago (1 child)

    It makes the history clearer.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 2 points 1 year ago (1 child)

    How is a Mercurial commit tree clearer than a git commit tree?

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 0 points 1 year ago (1 child)

    Branches are distinct.

    Let's say you have a main and a dev branch, and you periodically merge dev into main. Because of fast forwarding (on by default) the main branch is completely gone from the history. If you then add bug fixes and project branches it becomes a tangled mess really quickly and it's nearly impossible to understand the structure by looking at the tree.

    On mercurial every branch is named and distinct forever. You don't have to try to understand what happened to the project since it's obvious by looking at the tree.

    Now there are ways to have a clean git history, but afaik you either need to make sure nobody ever messes it up or have everyone rebase everything and only keep the history of the main branch.

    When working in a hyper structured organization that may work, but for more casual developers (scientists, students) that aren't system experts and where you have messy history, mercurial default settings are less confusing, easier to learn and produce better results.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 3 points 1 year ago* (last edited 1 year ago)

    Mercurial is written in Python, Git in C.

    Given the number of git instances, had it been implemented in Python, more CPU cycles / electricity would have been used.

    Blah blah Mercurial is responsible for global warming. (I’m being sarcastic by the way - I love Mercurial).

  • permalink
  • fedilink
  • source
  • parent
  • [–] -1 points 1 year ago* (2 children)

    Python 10s of multiples more CPU cycles than git. It is an interpreted language: every instruction is read by another process, checked, and then run. Hit on the other hand is executed straight by the CPU. It has at least one layer of indirection less than python (the python interpreter may have multiple). That means it can be slower but it definitely uses more energy.

    Since git is so popular, if it were instead mercurial, the energy requirements would be much higher for version control. Whether that will be noticeable on a bill is debatable. I haven't run the numbers.

    Regarding the different python versions. As mentioned before, there is a python interpreter. That interpreter is versioned and so is the python language. Many things are backwards compatible meaning something written in a higher version of the python language can be interpreted by a lower version of the python interpreter. The reverse is also true, so python interpreter with a higher version can interpret a python file using a lower version of the language.

    Notice that I put "can" in bold. That's because newer versions can deprecate certain features or parts of the language. So, if you're writing a project in a different version of python, mercurial may or may not run depending on your version. Resolving that may not be as intuitive as one thinks.

    I think those were he points you were referring to when you asked your question?

    Anti Commercial-AI license

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 4 child comments
    •
  • [–] 1 point 1 year ago (1 child)

    I don't think it's hyperbole to say a significant percentage of Git activity happens on GitHub (and other "foundries") – which are themselves a far cry from efficient.

    My ultimate takeaway on the topic is that we're stuck with Git's very counterintuitive porcelain, and only satisfactory plumbing, regardless of performance/efficiency; but if Mercurial had won out, we'd still have its better interface (and IMO workflow), and any performance problems could've been addressed by a rewrite in C (or the Rust one that is so very slowly happening).

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 1 point 1 year ago (1 child)

    Imagine if their VCS operations were 10s of times less efficient 😉

    Anti Commercial-AI license

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 1 point 1 year ago* (last edited 1 year ago)

    Most of the VCS ops in Hg are actually written in C.

    GitHub is mostly written in Ruby, so that's not really a performance win.

    Like I said, we're stuck with Git's UX, but we were never stuck with Hg's performance.

  • permalink
  • fedilink
  • source
  • parent
  • [–] 1 point 1 year ago (1 child)

    Surely it could be rewritten in Fortran if performance is really a concern.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 1 point 1 year ago (1 child)

    Being shouted at in a mailing-list for fixing a bug doesn’t sound like fun.

    What's that a reference to?

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 6 points 1 year ago

    Some instances of one of the mercurial devs being a bully. It was a long time ago and I can't remember the alias of the dev, but I do remember they had merge or commit rights - whatever those are called in mercurial. It felt like they had their own Linus but different. Whether they are still active or whether they still are like that, I dunno. Certainly hope they changed.

    Dunno if the git mailing list was as toxic. Didn't investigate that.

    Anti Commercial-AI license

  • permalink
  • fedilink
  • source
  • parent