TFS vs SVN

I am about to start a project (.NET) and need to decide between TFS and SVN.

I am more used to SVN(with tortoise client), CVS and VSS. Does TFS have all features available in SVN

Have any of you switched from SVN to TFS and found it worthwhile?
Also it looks like we may need Visual Studio if we need to work with TFS.

[Edit]
Money is not a consideration since we already have the licenses for TFS in place. And I am more interested in the Source Control features of TFS vs SVN, of course other features list is also welcome.

"One can not compare between TFS and SVN"

SVN: is Source Code Versioning System
TFS: is full fledged Software Development Management system which contains, Version control, Release management, Requirements tracking, Document publishing and other things.

Both have nice to use IDE integration add-ins(e.g. AnkhSVN, Collabnet's add-in) available for VS2005, so that is not the point to consider.

Criteria to consider for choice:

• If you have a no or small budget project choose SVN
  
• If you are only looking for version control system choose SVN, if you are looking for complete development management choose TFS
  
• If you have patience to juggle with different integration tools (CruiseControl.Net, NUnit, NCover, FIT) to achieve proper development environment choose SVN, or if you are looking for out of the box implementation of all these for you then choose TFS

Having used TFS 18 months back I found it buggy, slow, annoying, very limited search criteria and it had the feel of a product rushed out by a team of un-interested, under paid, over worked techs being forced to use Sharepoint and other MS technologies because that's what marketing wanted. Seriously it was a dog, I would have rather used SourceSafe!

SVN on the other hand is bit techie, IDE integration is a pain, and it can occasionally get confused, but the user base is massive and most issue can get resolved with a quick SO quesition.

Have you considered Vault? Works well, and isn't too pricey.

I would only recommend TFS if you were using the 2013 version and using the Git based repository. I've encountered too many issues with the previous versions to consider them stable.

• It's impossible to send multiple files to your diff tool at once. This is ridiculously useful when you want to review your changes before a merge and isn't available.
• Inconsistent availability of functionality. Some functionality is available from only within the IDE while other pieces are only available from Windows Explorer, while still others are only available from the command line.
• Adding files to version control is not available from the IDE and only available from Windows Explorer integration.
• Accessing shelf sets is only available from within the IDE and not available through Windows Explorer integration.
• Lack of a single unified installer. It's not enough just to install TFS, you also have to install team tools and power tools to get basic functionality.
• Shelf set functionality does not merge. What could have been a cool way of doing private branches, essentially guarantees your code will go out of date and stop working.
• You have to manually unlock text files before you edit them if you need to use an editor other than Visual Studio.
• Sometimes Visual Studio forgets to unlock files that it itself is managing and throws an error.
• The check in and shelving UIs base available files for commit on what has already been added to TFS and not what is actually present within the file system. This makes it extremely easy to miss files. (This is actually a problem with the way Visual Studio handles project files, but that in itself is another rant).
• It is unnecessarily difficult to use non Microsoft tools for editing your source due to the previously mentioned issues.
• TFS configuration is committed with your source. This means that if you change your TFS server the configuration for all your history is now incorrect. There is a default configuration you can use which overrides this behavior but it is not obvious.
• No support for ignore filters at anything but the base level.
• Inability to handle paths of greater than 249 characters.
• Files that have been unlocked, but not edited show show up as changed, even though they haven't been. Differentiating between changed and unlocked would make it a lot easier for diffs, or better yet doing away with the entire broken unlocking system entirely.
• Windows Explorer icon overlays don't clearly show whether a file has been edited. All file in TFS have a green corner while modified files add a pencil to the bottom of the icon. Switching to red corner for modified would be a lot easier to see or using the tortoise system of icons.
• Older versions of Visual Studio have problems integrating within newer versions of TFS. This means we now have an IDE version dependency in source control.
• Includes the user solution files by default when they aren't needed. Of course I'll admit this one might be a matter of preference.
• Bad caching makes it possible that differences between your local copy and the server aren't accurately reflected. It's extremely frustrating to Get Latest and find that you don't actually have latest.

It's been 1.5 years now that I'm using SVN for various projects. Setups I've used so far:

• AnkhSVN client for Visual Studio. It integrates nicely as Source Control provider since version 2.
• Servers either CollabNet Subversion on windows or Apache 2.2 with SSL + SVN through DAV on linux.

Haven't had any problems with any of these setups and I definetly recommend using SVN as it's free and easy to start using. Also many project management / bug tracking packages integrate with SVN (like trac for instance).

I'd pick SVN. I've worked with SVN from a developer standpoint before and I currently work with TFS, and let me tell you that TFS is painful. While TFS is feature full and is more than just version control, its version control is sloppy at best. Merging is horrendous and many of us now turn to manual merging or merge tools because we can't rely on TFS. Files go missing, aren't downloaded to the local system sometimes, and there are just oddities in its behavior that make you want to bang your head against a desk.

That being said, if you want TFS in all its glory, are willing to work with its pain points, it is a great tool to setup automated builds, and releases.

Check out this article before you decide: A Comparison of TFS vs Subversion for Open Source Projects

I've used both - but actually, I've switched my main projects from TFS into SVN. I find the offline and anonymous access very valuable in my projects.

In general, I think they are comparable. I would just pick the one you know the best, and you are the happiest maintaining. I don't find the specific features in one dramatically outweight the features in the other system.

If you're familiar with svn I'd stick with it. Tfs isn't free and isn't simple. It does far more than just source control. If you're a .net shop like us and you're deciding what product to use for the whole dev cycle it's a contender, but for simple source control it's overkill.

Well, to me, the choice is obviously TFS :

• SVN integration into Visual Studio is incomplete to say the least (a lot of features aren't available from the IDE), and a bit buggy (AnkhSVN certainly is), while TFS one is perfect (which makes sense...). I've had my whole workspace corrupted several times using SVN (during one month), never using TFS (aprox 2 years)

• While Source-Control related features of both systems are probably quite equivalent, they are accessible directly from the IDE with TFS, while you have to rely on TortoiseSVN or other external tools if you use SVN. Almost all TFS tasks are accessible in a few clicks on the solution explorer tab.

• Merging is a lot easier with TFS, even for complex merges (for example, SVN will add <<<<<<'s and >>>>>>>>>'s to your .csproj files, so you'll need to manually edit them to open them again from VS.)

While I think those reasons are more than enough to prefer TFS over SVN, I mus add that :

• TFS is more than just a source-control tool (think work items, project portal, etc.)

I've used it on a medium-sized project (12 coders, 3 testers, 3 business analysts) in the past, and we've been able to successfully centralize all the tasks in TFS (bug reports, project documentation, build process, etc.)

I'm not saying it's not possible to do the same using SVN and other third-party tools, but it's definitely nice to have all things nicely integrated in one product.

---

To stay fair, here are the two obvious drawbacks of TFS :

• Its price

• Installing TFS is quite a pain, while SVN installation is a matter of minutes.

Installing TFS 2008 over SqlServer 2008 is quite complicated, you cannot install TFS on a PDC, etc. To me, it's definetely the worst installation experience I've ever had with a Microsoft product.

That being said, once installed, TFS is very easy to use (especially for coders not familiar with source control systems)

---

In my current project, I started with SVN, and quickly switched to TFS. I'm happy I did.

The main reason why I've decided to switch is clearly the overall buggy behaviour of SVN (I was using VisualSVN as a server and AnkhSVN as a client). At least once a week, I found myself spending hours on cryptical AnkhSVN error messages.

To date, I haven't found a single reason to regret the switch to TFS.

I'd say TFS is more than just source control. If you can afford it, I would definitely advise to use it. When you start using Team Builds for example, or using stuff like Work Items, then you'll see that TFS can really manage your whole development life cycle, providing a rich environment in which reporting, ease of use, slick VS integration and solid source control are all rolled in to one.

It does require some iron on the server side. I do not find it to be slow however, it works nicely over VPN and supports offline work.

A major con is the install process (on the server side) which is tedious, non-flexible and in my mind (I come from a field in which packaging up apps and deployment are very important) a bad example of how SQL Server, Reporting Services, Sharepoint and webservices could be installed.

TFS can import from SVN, however SVN cannot import from TFS. So if you don’t find a good reason otherwise use SVN, as it is easier to change your mind later.

One of the best things about SVN is that every source code control system I know of can import from it, so choosing SVN us a very low risk option.

In my experience SVN overall is far quicker and more painless. I've used it with XCOPY deployment scripts that allow you to work and deploy far faster overall in comparison to TFS.

I don't have experience with TFS, but IDE integration is something you should think about. TFS obviously integrates very well with Visual Studio. AnkhSVN, the only usable free plugin for VS, is often problematic, even in the new versions. I haven't tried VisualSVN, though.

Consider that TFS 2010 can be installed also on Windows Vista / 7 client OSs and that it supports an express, three clicks, installation.

Pros:

• Integration with Visual Studio. A real plus if you're leveraging a full Microsoft tech. stack for development.
• Automated builds (though achievable via other products) is really nicely done. Continuous Integration and Gated check-in builds are fantastic IMO.

Cons:

• Windows Workflow Foundation. For some reason, Windows Workflow Foundation was chosen as the method to customize many aspects of TFS. In short, you need a book on Windows Workflow to understand it, and I simply don't have the time. Very disappointing IMO.
• Project Management. The concept of work items is simple enough I guess, but there's a lot of oddities with it that just leave me flummoxed. It's just way too complicated IMO. Coming from a Trac + SVN background, I much prefer Trac here. Again, just my opinion.

Failing to understand what the tools are capable of, their limitations, will mean you end up with a tool that doesn't work for what you want. Understand your requirements, and read the product manuals a bit - plenty of information available to determine suitability.

While I agree completely with the proponents for SVN, as it is a glorious tool (I've used it many times in university) , I've found TFS to generally be more cooperative in OOTB situations when you are using the SP1 Version with Studio 2010.

As well, there are some nice little plugins that make TFS a little more palatable for those of us who are used to, and generally prefer a SVN-type solution as well, and many of them have excellent support:

TeamReview for Code Reviewing is one example: http://teamreview.codeplex.com/ MS Pathways for multi-platform use of TFS: http://www.microsoft.com/pathways/teamprise/FAQ.htm

This SO Question is a great resources for TFS addons: https://stackoverflow.com/questions/1525928/what-add-ons-utilities-are-available-for-tfs

A Word to the wise, as mentioned above, TFS can be a pain to be installed, so caution should be exercised. Following the route below, I've encountered minimal problems:

Studio 2008 -> Patching -> Studio 2010 -> Patching -> .NET -> SQL Server 2008RD/2012 -> Patching -> TFS -> Patching