-4

I use Visual Studio 2013 Team Edition, and the current project I'm on is using traditional server-based TFS repositories for source control. I'm aware that git's GUI integration onto Windows has come on leaps and bounds recently, and I'm using TFS 2013 so there is official Visual Studio integration of git, but from a purely source control perspective, I'd like to know why I should use git instead of a traditional TFS setup, especially if the team is more used to traditional TFS. So, what are the advantages and disadvantages of git over a traditional TFS setup? Bear in mind that TFS has shelveset functionality, which I don't think SVN does.

Jez
  • 27,951
  • 32
  • 136
  • 233
  • 2
    This question is somewhat modeled on [this one](http://stackoverflow.com/questions/740053/why-should-i-use-git-instead-of-svn), which was considered on-topic. Therefore, anyone voting to close, please post a comment here saying why this should be closed, but not the question I just linked to. – Jez Dec 16 '14 at 23:25
  • 7
    But 2009 was a long time ago and community standards have changed. – mu is too short Dec 16 '14 at 23:30
  • Yeah, for the worse. It's ridiculous that this question is considered closeworthy as it could garner some useful information. Would it be acceptable on Programmers.SE? – Jez Dec 16 '14 at 23:31
  • 1
    @Jez This question is either *off-topic* or *primarily opinion-based* for Stack Overflow. It might be on topic on Programmers.SE, though. – jub0bs Dec 16 '14 at 23:36
  • 4
    Lots of useful information, discussion, and opinion but no authoritative answer. We can't tell you which system is better for you and your team, sorry. – mu is too short Dec 16 '14 at 23:37
  • 1
    So what? The information, discussion, and (informed) opinion is useful by itself. – Jez Dec 16 '14 at 23:37
  • "Many good questions generate some degree of opinion based on expert experience, but answers to this question will tend to be almost entirely based on opinions, rather than facts, references, or specific expertise." And this discussion in the comments is sort of off topic too, it would be more suited to meta. – mu is too short Dec 16 '14 at 23:39
  • Actually I just noticed there is now a [Software Recommendations](http://softwarerecs.stackexchange.com/) StackExchange site where I think this question would be on-topic. Are there any mods around who could please transition this question there? – Jez Dec 16 '14 at 23:41
  • @Jez AFAIK, there is no migration path to Software Recommendations yet. You might be better off deleting this question here and post an identical one there. – jub0bs Dec 16 '14 at 23:52
  • 2
    FWIW, I think this question is still on-topic for SO (and *not* on-topic for SRECS). It's not asking for a recommendation, it's an asking reasons why changing from TFS to Git might be worthwhile and what the drawbacks might be. That's a perfectly legitimate question, in my view. – Ben Collins Dec 16 '14 at 23:52
  • @BenCollins *Worthwile* screams *primarily opinion-based* to me, but hey, you're the mod. – jub0bs Dec 16 '14 at 23:54
  • 2
    @Jubobs - Ben is an SE employee not a moderator. – ChrisF Dec 16 '14 at 23:56
  • 1
    @Jubobs Not to worry - if I'm not convincing, then it will stay closed. I try to avoid doing things unilaterally (mostly because I'm not actually a mod) when it's not something blatant. It's just my own little opinion :-) – Ben Collins Dec 16 '14 at 23:58
  • What was true about TFS vs Git in 2009 is not true today. In 2012, TFS introduced local workspaces which eliminated a huge advantage of Git over TFS. In 2013, TFS became compatible with Git meaning you can use Git from within TFS which was not an option back then. People should still be able to ask questions that has been asked before if the old answers are no longer relevant to the latest release of the tool in question. – Aman Alshurafa Dec 17 '14 at 00:36
  • The question I linked to is only a year old and is relevant to *this version of TFS and VS*. I think that's a pretty good model for asking this sort of thing, @Aman. – Shog9 Dec 17 '14 at 01:38

1 Answers1

0

First of all, TFS, is catching up to git and as of last year, TFS has officially become compatible with git. Git is a totally different approach of version control. The repo is distributed rather than centralized like in TFS. This gave Git huge advantages such as:

1- Offline editing: In TFS, the code used to live in one place and one place only, the server. I read that a new model of TFS was introduced 2 years ago that allow local workspaces. I haven't tried it so I can speak about it. But as gar as the traditional TFS model go. It is VERY difficult to do offline editing with TFS. For an experienced team, this can be turned into an advantage. But for most developers, this is a pain.

2- Additional backup solution: Every developer who does a pull from the remote repo will have a full copy of the repo that you can use it to restore the repo if something wrong happen and the original backup solution is not useable or reachable in a timely manner. I am not saying you should use it as a backup solution but you use it as such if you need it.

3- Easier branches and merging: Again, TFS caught up to Git in this area as well. But this is 1 huge issue that caused people to leave TFS for Git.

4- Compatible with any tool: TFS is great with Visual Studio on Windows. Otherwise, it's a pain. Git does not have these kinds of limitations.

5- Community: There are many platforms and applications that support or are specifically made for git. I recently started developing on Mac. The gui Git application I used to use in Linux is not available on Mac. I still had so many options to choose from and I really appreciate that. The gui one is important for me during when I need to show progress or explain current work dynamics. My IDE has Git support and can use it to see and compare versions of files in a fast and convenient way. And the command line tool will always be there when I need to ssh to my machine or another machine remotely. Platforms such as GitHub and BitBucket, and many others make it easy for developers and businesses with limited resources to version control their projects. With TFS, your options are very limited.

However, as I mentioned. TFS, has improved dramatically. In the end, they are version control tools. So, if what you have is working for you, you don't need to switch. Git used to be less hassle and more productive than TFS. Now, this depends on the team.

My advice, if you want to switch start with a git repo using TFS 2013. You get the benefits of Git and will still be able to use TFS.

Aman Alshurafa
  • 210
  • 2
  • 10