There was a time when Git wasn't a dominant presence in the software industry, hard as it may be to remember.

Back in 2010, Subversion ruled with more than 60% of the market for version-control systems—a key tool for collaborating on software development—and Git accounted for a mere 2.7%, according to Forrester. Today, according to data compiled by Redmonk analyst Stephen O'Grady, Git accounts for 28% of the market, with Subversion now only narrowly beating Git.

Given Git's clear superiority over centralized systems like Subversion, why has it taken so long for the market to embrace Git?

The Future Is Distributed

Version control systems (VCS) matter because they're the primary tools for developers to manage software projects and track changes, and developers are increasingly calling the shots in everything from enterprise computing to mobile applications. A VCS monitors access to source code, keeping track of all changes, as well as who made the change, why they made it, and what the changes were meant to accomplish. It's like a Google Doc for code, except far more powerful.

Within the VCS landscape, there are both centralized version control systems (CVCS) and distributed version control systems (DVCS). A CVCS forces developers to treat the central source tree as "The One True Source," keeping all development tightly tied to it. A DVCS is very different, allowing developers to fork the main source tree, run it offline onto one's personal machine, and then submit pull requests to merge changes back to the primary source tree. Ultimately, a DVCS is about communicating the changes made while a CVCS is more about control.

Developers, it turns out, love to be distributed. 

Using Ohloh survey data of more than 600,000 software projects, O'Grady plots a clear trend away from centralized version control systems toward distributed version control systems:

While there are other DCVS alternatives, Git looks like the clear winner:

Git has jumped 30% since 2010 while Subversion has declined 13% in the same period. That jump was accelerated in 2012 when developer darling Atlassian moved from Subversion to Git. Indeed, Subversion slid just 4.3% from 2010 to 2012, then fell off a cliff from 2012 to 2013, helped along by Atlassian's defection. 

Reasons For The Rise Of Git

Git hasn't grown so significantly because of superior marketing or better funding. While GitHub, the company and that provides a hosting service for Git repositories, raised $100 million in 2012, the money hasn't been used to buy Git's success. That success was already well underway when the funding came in. Indeed, the funding was a response to Git's rise, not the cause for it.

Git has boomed with developers simply because it's better for developers. As O'Grady notes, "The speed of distributed development, which can occur in parallel, is likely to greatly exceed that permitted by centralized alternatives, which operate on a serial model." Checking out a single version of a repository with Subversion is hugely inefficient, and takes about as much time as cloning an entire repository with Git.

Such a DCVS allows developers to not only work in parallel, but it encourages more granular updates to shared code because they can make individual changes without concern for upsetting the primary development line. Such forking, along with the super-easy "pull requests," whereby a developer requests his or her changes be automatically added back to the main source tree, make Git amazingly powerful for developers. 

Why Did Git Take So Long?

Forking and pull requests have helped Git's rise in popularity, but, as O'Grady suggests, it doesn't explain why it has taken so long to do so.

For that, O'Grady has a hunch:

DVCS...not only requires that developers learn an entirely new tool and syntax, but that they change the way they think. This philosophical difference in approach has caused even high profile developers to struggle with its implications, and thus be more slow to adopt and propagate the technologies. 

Despite the bother, the payoff from using a DVCS like Git is so big that, over time, developers have invested the time and resources to learn it. Technologies often take off when they're substantially easier or cheaper to master than older incumbents. Not so with Git. It's winning because of the increased developer productivity it enables, even if there's a learning curve first associated with grasping its essentials.

Check out the relative growth in jobs requiring Git versus Subversion:

 Or even the absolute number of jobs:

It's clear that now would be a good time to master Git. In fact, given how much Git has taken center stage among DVCS alternatives like Bazaar, the likelihood is that it is already the standard, meaning enterprises looking to embrace DVCS-based development will almost always be looking for Git experience. Different though it may be, it's a difference that will pay dividends for years.