A brighter TFS future?

I saw an interesting quote in Brian Harry’s (the PM of TFS) post on TFS 11 enhancements. He mentions that the next TFS version will support Subversion-style “Modify-merge-commit” workflows, which is a definitely a step in the right direction. However, one quote popped out at me (emphasis mine):

I’m certain that about this time, I bunch of people are asking “but, did you implement DVCS”.  The answer is no, not yet.  You still can’t checkin while you are offline.  And you can’t do history or branch merges, etc.  Certain operations do still require you to be online.  You won’t get big long hangs – but rather nice error messages that tell you you need to be online.  DVCS is definitely in our future and this is a step in that direction but there’s another step yet to take.

Having worked with both centralized and distributed source control systems, DVCS is very plainly a better model of working. Good to know it’s at least on their radar, DVCS will open up a lot of branching scenarios that are just too painful in centralized models. Folks here at Headspring use SVN, Git, Mercurial and TFS, and it would be nice if at least 3 of those 4 supported a DVCS model.

About Jimmy Bogard

I'm a technical architect with Headspring in Austin, TX. I focus on DDD, distributed systems, and any other acronym-centric design/architecture/methodology. I created AutoMapper and am a co-author of the ASP.NET MVC in Action books.
This entry was posted in TFS. Bookmark the permalink. Follow any comments here with the RSS feed for this post.
  • “We’re working on it.”  Fantastic.  

    I mean, I feel bad for the little guy like Microsoft who don’t have the resources to get their product to market with the features everyone wants…oh wait, nevermind.

  • Good share,you article very great, very usefull for us…thank you http://www.easyate.com/

  • - 2012  NUnit support
    - 2014 Mercurial as SCM

    Maybe we can really use TFS in 2015 :-P

  • Chris Bristol

    As cool as this sounds on the surface, I don’t know that its enough to make me think the cost of TFS is worth it. For me, TFS’s vertical integration makes it far too costly to consider as a viable CI solution. At my last job, we chose TFS for source control, and it eventually became a major limiting factor in what we could do. We wanted to go to .Net 4.0 and VS2010, but since we would have to do a fair amount of work to get that working with TFS2008 and the corresponding MSBuild, we decided it would be better to wait for TFS2010. Unfortunately, going to TFS2010 seemed to require moving to SQL Server 2008, and that meant testing all the other apps that were running on that SQL server, which happened to be the only production one that company had. So the cost of moving forward was huge. We were stuck because of our CI system.

    Compare that with our previous setup using SourceSafe, Nant, CruiseControl, and BugTracker. SourceSafe sucked, but it was at least self-contained. Nant is free and works great. It did require some customization work for .Net 4, but its reasonable. Its been a while since I used CruiseControl, but I remember liking it a lot. BugTracker was also free, and did most of what we needed to do with the exception of non-bug work item type management. Sure, it was four distinct apps, but each one could be changed out on a whim. We were free to move around as necessary.

    The only features TFS provided to us were non-bug work item tracking and work item integration with the build.  For me, TFS was definitely a no win, at least in that environment. Unless you are a company with enough resources to dedicate a server  (probably at least 2, SQL and application) to your CI system, I think you are better off sticking with tools that are dedicated to doing one job well.

    • Alexander M. Batishchev

      Virtualization is the key to your last inquire.

  •  Coming from someone who has worked with both TFS and free/OSS alternatives I would need to find a compelling reason to use TFS over a stack such as git/teamcity because so far I have found powershell scripts much simpler and equally effective.

  • Pingback: Mercurial, Git, and Elephant’s Graveyard System « Claudio Lassala's Blog()