Everything you want to know about Visual Studio ALM and Farming
Brian Harry is a Microsoft Technical Fellow working as the Product Unit Manager for Team Foundation Server. Learn more about Brian.
More videos »
Today at the ALM Summit I made a bunch of announcements. A couple of them warrant a bit of extra comment
Today, I made 2 announcements involving TFS, VS and Git.
That’s right, TFS & VS support a full fidelity implementation of Git. Although this comes as kind of an abrupt announcement, it’s been a long time in the making. We started talking about having DVCS support for TFS a year or more ago. I even mentioned at the end of this post over a year ago that DVCS was in our future. After a few months of investigation (in the middle of working on TFS 2012), we concluded that adding Git support was the right approach. As I write this, I’m wondering what the reaction among our customers will be but I can say the reaction inside my own team when we first proposed this was quite mixed. There were certainly plenty of people who wanted to “build a better DVCS system” or integrate DVCS workflows into the existing implementation. There were others who were concerned about open source and lack of “control” issues. But, the more we looked at it, the more it looked like the right thing to do.
This post is going to be a bit of a weird post. I’m going to structure it as a bit of a Q&A to address many of the questions that came up for us and I’m guess some that will come up for readers. I suspect this post is going to be the beginning of a conversation. I’m going to be doing a Reddit Ask Me Anything session on Friday if you want to come along and chat about it.
Centralized version control is going to be around for a long time. It’s a model that still works for a very large number of customers and we’re very happy with the solution we have. However, DVCS, starting with roots in the OSS community, has grown steadily in popularity. Some of its benefits fit well with the trends we see in software development: loosely coupled systems, distributed teams, lots of component reuse, incorporation of OSS, etc. Our customers need DVCS workflows integrated with their full ALM process – in fact, it’s one of our top UserVoice requests. I like to say our goal is to have the best available centralized version control solution and the best available distributed version control solution.
When we made the decision that we were going to take the DVCS plunge, we looked at many options. Should we build something? Buy something? Adopt OSS? We looked at Git, Mercurial and others. It didn’t take long to realize that Git was quickly taking over the DVCS space and, in fact, is virtually synonymous with DVCS. We thought hard about building something. Git hasn’t been as friendly for Windows developers as on other platforms. By building on Git, we can take all the time we might spend just “catching up” and spend that effort on something where we can add more distinctive value. Choosing Git just made sense.
Not for a second. We still believe that TFVC is the best centralized version control system available. If you haven’t taken a look at version control in TFS 2012 yet you should. We improved it significantly with local workspaces for better offline and lower overhead, a better merging experience, and we’ve been doing a lot of work in the web experiences for version control over the past few months (that affect both TFVC and Git projects). There is still a very important role for centralized version control to play and we plan to continue to carry it forward. Rather than dilute both into a single solution we’re giving you the choice of which workflow is best for your circumstances. However, circumstances change and you are going to want to be able to move code from one workflow to the other and we’re going to help there. Last summer we released a tool called Git-TF which allows you to hook Git up to TFVC and exchange code and we’ll be doing more to improve this area.
Absolutely not. Speaking for my little world, we’ve been engaged with the OSS developer community for years. In my own area, we dabbled (and in some cases made missteps) as we’ve learned our way. OSS became a major part of my world a few years ago when we acquired Teamprise (now known as Team Explorer Everywhere or TEE). TEE is an Eclipse plug-in that gave us a lot more experience in the OSS world. Eclipse is, of course, OSS but so are large chunks of our plug-in implementation. Our engagement with OSS has gradually increased over the years both as we created our own OSS projects (like Git-TF) and engaged in existing ones with small contributions.
All that said, this is a pretty big milestone for us. This is certainly the first time that my team has engaged so deeply in an existing OSS project. Our Git implementation is based on LibGit2 and related projects. We started contributing to LibGit2 a few months ago and have been very active. If you are curious, checkout contributions by Ed Thomson (ethomson), Philip Kelly (phkelley), Jameson Miller (jamill), Congyi Wu (congyiwu) and Martin Woodward (martinwoodward) on the LibGit2 GitHub project. The GitHub team also relies heavily on LibGIt2 and are major contributors. Before we even started coding we spoke with the folks there to make sure they were open to our participation. We have been open with them about our plans and agreed that it made sense for us to work together to bring Git forward – particularly with respect to making it great for Windows and VS. I have to say that the welcome by the entire LibGit2 community has been phenomenal. They have been incredibly helpful as we’ve begun to contribute to LibGit2 and we wouldn’t be in the position we are today without them.
Absolutely not! Both client and server are standard implementations of Git. Our client will work with pretty much any Git repository – local, enterprise, Codeplex, GitHub, BitBucket, …. And TFS will work with pretty much any Git client – existing Git command lines, XCode, Eclipse’s Git support, …. This was a core principle from day 1. This is not about lock in – it’s about providing a good and interoperable Git capability.
We like to think so. While both client and server are completely standard implementations, we are doing a lot of work to make our implementation as good as it can possibly be. First of all, we are doing deep integration with our ALM tools. Our intent is to provide the same level of integration as we have with TFVC – work item association, change tracking, build automation, My work, Code review, testing, … TFS will give you the best all-up ALM solution with Git as the source control system. We are also working to make sure that our Git server is enterprise class – a common concern with Git historically. We are doing work on auditing, access control, high availability, online backup, etc. All the things that an enterprise is going to be particularly concerned about. And we are working hard to deliver an excellent Git experience in VS. Git can be, um, esoteric. We’ve been working to codify the standard “best practices” for Git in the community to make Git approachable and easy to use by everyone while not sacrificing the power.
“This” has many piece so let’s talk about each one in turn:
It’s been no small feat getting here – the team has put in a lot of long hours over the past few months. And this is just the beginning of the journey. We’re nowhere near done with our Git solution. We are currently lacking major features – like pull requests – but they are coming. You should continue to see improvements on a regular basis for the foreseeable future.
As always I’m happy to answer questions and enjoy feedback.