Microsoft announced Wednesday that it is adding git support to TFS and Visual Studio, putting the distributed version control system on an equal footing with its current centralized system. In so doing it makes Visual Studio and TFS much better choices for distributed development teams and open source developers. Many of them were put off from even looking at TFS for one reason in particular: centralized version control. With git support, that could start to change.

Microsoft TFS is an all-encompassing application lifecycle management platform. Both the on-premises Team Foundation Server and the cloud-hosted Team Foundation Service provide version control, bug tracking, software building, testing, and more, all in one integrated platform. But a lot of people aren't interested in TFS at all, because of that version control component. It's a centralized version control system, so there's a single source code repository that every developer uses, and that repository tracks all the branches and modifications that everyone uses.

That model still has its adherents, and especially for corporate users, it works well. But there's competition from distributed version control systems (DVCS), which have become extremely popular. In these systems, developers have their own repositories with their own branches and modifications. These repositories are published, and patches can be moved between repositories. In particular, this model has thrived in open source projects and in any situation where developers or developer teams work in multiple locations.

The lack of DVCS support in TFS is a major stumbling block for these developers. Version control isn't the only thing that TFS does, but it's fundamental to the product and how it's used, and since it hasn't supported DVCS, the other features it does offer are largely irrelevant to any potential users.

With today's announcement, that all changes. Microsoft is developing DVCS support for TFS and Visual Studio, with the first preview version of that support available today.

git a load of this

And not just any DVCS. Microsoft is supporting git, the DVCS system initially developed by Linus Torvalds so that he could better manage development of the Linux kernel. git is arguably the most popular, most widely used of all the DVCS systems. It has found particular prominence with the success of GitHub, a project hosting service that's a kind of modern-day SourceForge without the same stench of decay.

Both Server and Service will host git repositories, and a plugin for Visual Studio will provide full support for source control operations such as merging changes between branches. Though designed "together," the Visual Studio's git support is just plain old git, and as such it will work with GitHub, BitBucket, or any other git repository.

Underpinning Microsoft's git support is a project called libgit2. This is GitHub's own git implementation. It's licensed under the GPL, albeit with an exception to allow unmodified versions to be used by closed source software. Since September last year, Microsoft has made a number of contributions to libgit2 in order to improve its functionality and reliability on Windows. Many of these contributions have been integrated into libgit2.

Future versions of Visual Studio will incorporate this git support in-box (not that anyone buys boxed copies these days), likewise TFServer. Today, TFService can host git repositories, and there is a "community preview" of the Visual Studio git support available to download. This preview needs, in turn, a preview of Visual Studio 2012 Update 2.

The DVCS model is very different from the centralized model, and Microsoft is not trying to marry the two together. When using TFS with git, it will use git-style terminology (commit changes to the repository, push changes between repositories, and so on); with its centralized repository, it will continue to use existing TFS terminology (check in changes). Migration from centralized repositories to git is possible with the Git-TF tool Microsoft released last week.

TFS's git support will, however, include the same kind of TFS integration as the centralized repository. As a basic example, commit messages will be able to link directly to their corresponding issues in the issue tracker. In the future, the full range of TFS functionality, such as automated builds, will work with git repositories; presently, only manual builds are supported.

It's still a bit surprising to hear about Microsoft embracing an open source project in this way. While users of competing DVCS platforms such as Mercurial might be a little disappointed, Redmond is delivering what a lot of developers actually want: git support. Microsoft is embracing a market-leading open source project and striving to provide first class support—and providing numerous contributions to the community in the process. This is a pragmatic decision, and as an occasional GitHub user myself, it's an enormously welcome decision.