Git is incredibly popular and supported nearly everywhere. With it practically being the default version control system, it begs the question, what are your alternatives? Are they worth considering, and how are they different?

Note that this article discusses alternatives to

        git
    

 as source control software. If you're simply looking for alternatives to a hosted service like Github, you can read our guide to hosted Git solutions instead.

The Downsides of Git

To better understand the limitations of Git, we should first start with what it does right.

Git uses a distributed source control model; each user's local repository isn't really connected to any central server. That user can go offline, make a bunch of changes, and nobody else will see those changes until they are pushed to the remote. This works extremely well for open source software development; Git is much faster for most actions, since individual users can all clone a repository and make their own small changes without having to worry about what other people are doing.

These changes can be integrated into the master repository using pull requests (the user making the change requests for the master repository to pull commits from their private version of the repo), and updates pushed from authenticated users, providing all merge conflicts are properly solved.

This model makes a ton of sense for this distributed development environment, but the problem with Git comes when you try to adapt it for use in a corporate environment, where you'll often have many people working on the same bits of code, and proper coordination is key.

Don't get us wrong here---it's still fantastic, especially when paired with external issue tracking software and CI/CD pipelines, something which services like GitLab and BitBucket do quite well. But Git wasn't exactly built to be corporate source control, where you're almost always going to have a central server acting as the master repository. It requires very proper usage (and often external tools) to be effective for agile teams pushing a lot of code changes.

With Git, each client stores a full copy of the project's changelog. Every time you make a commit in Git, it stores the changes that commit made locally on your system. This makes working with Git very fast, since you only have to query a hard drive and not a central server. It also allows you to work offline much more easily. But with large projects with a long change history, this can also lead to the

        .git
    

 folder taking up an unreasonable amount of space.

Also, if you have multiple projects, you probably don't want the source code for everything visible to each developer. In Git, this problem is usually solved by having separate repositories for each project, which works pretty well, but isn't ideal if you need to integrate them together into one cohesive piece. With centralized version control, you can give access to only specific folders.

So, while Git probably isn't the wrong choice for your business, especially if implemented properly, there are other source control options built specifically for corporate workflows, and it may be worthwhile to look at the competition.

The Primary Alternative: Centralized Version Control

The most common difference between Git and the alternatives is the break from decentralized version control in favor of a central, authoritative server. Apache Subversion and Team Foundation Version Control are major version control systems that follows this format.

For comparison, in a DVC system, each user has a local repository that they commit their own changes to. When they're ready to send updates to the master server, it's possible for other users to have different versions of the the same file that you're working on. This is known as a merge conflict, and it's a very common (though easily resolvable) issue with Git.

In centralized version control (CVC) like Apache Subversion, there is a single server repository, and many clients connected directly to it. If you make a change to a file, that file is updated on other users machines whenever they update. Commits are made directly to the master server.

To prevent merge conflicts, most CVC systems use locks. If User A wishes to work on a file, and doesn't want anyone else messing with it, they can lock the file until they're done, preventing other users from doing the same. This isn't required in Subversion, and merge conflicts can still happen, but they're less of an accident.

The problem is mostly mitigated with branching and local copies, which allow multiple users to work on their own versions for extended periods of time before merging changes.

Another great feature of centralized version control is permission management; rather than giving out access to the whole repository, CVC makes it easy to section off access to specific folders. Team Foundation Version Control works in much the same way as Subversion, allowing granular permission delegation down to the file level.

All of these features make centralized version control a viable alternative to DVC. After all, Google hosts all of their code in one massive, centralized system, much bigger than any distributed system could handle. Granted, the Windows codebase is a 300 GB Git repo, but that's using Git's Virtual File System plugin, which allows users to only download the files they need, and nothing more.

One downside of Subversion though is that it often has a lot of copying and downloading to do, which can make it much slower than Git's local-only model.

Other Alternatives

While we've focused on centralized version control systems that can replace Git, there are other distributed version control systems you can use, most notably Mercurial.

Mercurial is a bit easier to use than Git, and they're both about the same performance-wise, but overall they're very similar. Really, there isn't much reason to choose Mercurial over Git, other than personal preference, which probably shouldn't be dictating corporate decisions.

Mercurial used to be an option in BitBucket, but they dropped support for it recently, the primary reason being that Git is just way more popular and widely supported. It's practically the default version control system, and unless an alternative is radically changing the model (like CVC), it's not worth considering.