What are the differences between TFS, SVN and GIT?

Question

I use Microsoft Visual SourceSafe for version control. I would like to change this approach and use newer software for this work. What are the differences between these three applications? Which one is better?

Are these solutions integrated with visual studio?

Solution 1

TFS is an Application Life-cycle Management solution, SVN and Git are source control only.

TFS does source control as well as issue tracking, document management, reporting, continuous integration, virtual labs for testing etc.

TFS's Source Control & SVN are centralized source control, Git is distributed.

There have been many discussion on Stackoverflow about TFS vs SVN.

TFS is the most tightly integrated into Visual Studio.

SVN has a few third party options for integrating into Visual Studio and they are quite nice, but not as tightly integrated as TFS.

Git has GitExtensions which allows for a low level of integration within Visual Studio.

Solution 2

Better is a big discussion, but along the same lines you have to factor in cost.

SVN is free, where as TFS isn't. However; if you have your Visual Studio through an MSDN subscription and this is of high enough level, then you will get TFS2010 for free through your MSDN subscription downloads when released. This may be a factor which tips the balance.

As for the integration with Visual Studio, you can't beat Team Explorer for TFS. However, I have used Anhk with SVN and that works well too. I think the rest of this has been said :-)

Hope this helps.

Solution 3

The question is rather old, however in case someone stumbles on it: since January 2013, git has been integrated into TFS (announcement: http://www.visualstudio.com/en-us/news/2013-jan-30-vso#git support). What it means is that the team can now use git as the source control tool (instead of, but not alongside, the "built-in" TFS version control system) while still using the rest of TFS for activities such as continuous integration, issues tracking, and so on.

Original discussion on MSDN: http://blogs.msdn.com/b/visualstudioalm/archive/2013/01/30/getting-started-with-git-in-visual-studio-and-team-foundation-service.aspx

StackOverflow has a large set of relevant discussions (https://stackoverflow.com/search?q=tfs+git), cannot point to anything specific.

Solution 4

I can only speak to Visual Studio integration for SVN. I've used both VisualSVN and AnkhSVN. They both have pretty tight integration and allow you to perform various operations from the Solution Explorer menu the way you would have normally done it with VSS. Version 2+ of Ankh (one I currently use) has been very stable for me and worlds better than the older versions.

This looks like a fairly detailed discussion of using Git with Visual Studio.

Solution 5

This is in addition to the other answers, not a full answer as Michael Shimmins satisfied most of what I would say

TFS (especially 2010) is incredibly approachable for implementing source control techniques that you would have been terribly hard-pressed to execute with VSS. Branching and merging is much easier with TFS than SVN to start and follow over time. I would say the same thing about Git from an user interaction perspective, but those tools are getting better slowly.

Git is a great tool if you spend the ramp up time and the techniques that community take as standard practice are well worth the effort in any version control system. You're still going to run into conflicts with SLN and CSProj/VBProj files in teams of > 2. This is a result of the way those files are structured and managed.

View more solutions

Comments

[Roman]

Can you qualify better? Particular features? General usability (I assume under windows for you)? VS integration?

[masoud ramezani]

I mean general usability and integration with VS.

[Brian Rasmussen]

All of them are a lot better than VSS if you ask me.

[Ryan]

One more to consider is Mercurial (Hg). Now that Google Code and CodePlex support it, it is a pretty good option as well. Take a look at tekpub.com/codeplex -- The video also will give you a feel for distributed version control systems like Git and Mercurial.

[jussij]

TFS does integrate with the IDE. But if you use a MS-SCCI plug-in like Agent SVN you can also integrate Subversion with Agent SVN in a similar way to TFS.

[Vedran]

Visual Source Safe is anything but safe... It loses changesets on a whim and it's slow as a snail - using it should be a criminal offense.

[kprobst]

I've tried all of those and eventually always end up going back to the command line. The GUI tools invariably feel like half-finished hack jobs.

[Roman]

@kprobst: Most of my interaction with Ankh is in the form of Get Latest and Commit, so I haven't felt the limitations.

[Joachim Sauer]

+1 for stating the facts without opinon.

[tina Miller]

Also: TFS costs money up front. Git makes branching and merging easier, safer and 'cheaper'.

[Dan Abramov]

TFS kills me each time I have to work offline.

[Michael Shimmins]

Yeah - I tried to keep personal opinion out of my answer but unless something drastic changes in an upcoming release I can't see myself ever using TFS again. It killed so much productivity the one time we tried to adopt it at our company, and in previous companies that were using it already it was always a headache.

[Paul]

@Michael Out of curiosity, what do you use now? I've used TFS in the past and liked it quite a bit. I have used SVN and not had any trouble with it but I haven't used it extensively. Basically, I think the main reason I like TFS is that the only alternative I've used very extensively is SourceSafe. At my job we are currently using VSS and moving to TFS later this year. I don't think much can stop that transition from happening at this point, but I am interested in the alternatives. Thanks!

[Michael Shimmins]

Hi Paul - we're currently using Mercurial. Previously it was Git, we moved to Mercurial after BitBucket was acquired by Atlassian. They're similar but after using both I'm happier with Mercurial. Others on the team have said they prefer Git. I might be happier with Mercurial because I come from an SVN background at previous jobs. I've used TFS before (indeed we trialled it at my company before starting with Git) and pretty much swear to never go back to it so long as I have the final say ;)

[Michael Shimmins]

To be fair - if TFS 2012 were to come with a distributed source control tool that didn't suck I would look at it, but for now I'm very much a convert of the DCVS camp.

[heisenberg]

I wouldn't call Ankh a half-finished hack job, its fine.

[Michael Shimmins]

Seven years later, I'm happy to report that TFS has indeed come a long way, and at my next startup we're seriously evaluating using VSTS as the replacement for GitHub+Jira+Some Build Tool. How things change.