As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 10 years ago.
we are on the research level of choosing a full ALM system for our company.
we consider both TFS 2012 and JIRA for use in product, project managment, QA, support and developemnt teams departments.
the things to support are bug tracking, workflows, project graphs (such as bugs count, burn down and so on).
any recommendations? pricing?
as far as i can see TFS is better for R&D teams using visual studio and less for eclipse.
Here are TFS advantages:
TFS is an application life-cycle management (ALM) solution, but Jira is simply an issue tracker. Many features of TFS, e.g. source control and automatic builds are not supported in jira and you should use other solutions, e.g. Subversion or Bamboo to this aim.
All TFS components, i.e. source control, issue tracker, build automation are fully integrated. Such level of integration cannot be attained on other solutions.
It is fully integrated with Visual Studio.
Here are Jira (and other Atlasian Solutions) advantages:
It has been used in MANY open source projects, e.g. JBoss, Spring, etc.
For launching TFS, you need a high end server, MS SQL, etc. But Jira could be installed on an ordinary PC on open DBMSes, e.g. my SQL.
If you are using Java technologies, many Java IDEs, e.g. IntelliJ, Eclipse and Netbeans fully support Jira. I have not seen such a nice support for TFS.
There are lots of plug-ins available for Jira. You can take a look at them here.
If your team is small, Jira costs only $10. It is really cheap.
Atlasian solutions have better support for java technologies (Ant, Maven, junit, etc.)
I have worked with JIRA / Subversion and now with TFS 2010, and I think JIRA / Subversion are much better tools.
I like the idea of having source control, workitem control, build control, test control in one integrated package, but somehow TFS is just a below average implementation of everything (Except Gated Checkin because that is cool).
TFS version control uses binding just like VSS, so doing multiple checkouts of the same requires extra effort. The ability to Suspend/Resume work using TFS shelveset, is the official workaround for being able to do concurrent work.
TFS sometimes goes haywire with its SQL table locks, so it has be restarted. Also the SQL indexes randomly gets broken, so suddenly showing folder history takes minutes. TFS in VS2010 needs to be online all the time to do any source editing, though this has been fixed in VS2012. But the VS2012/VS2013 GUI is so tightly integrated with TFS, so if the TFS-server has issues, then everything becomes sluggish in VS. This is really visible with the new VS2015 CodeLens, where all TFS WorkItem Lookup should be disabled, or else VS2015 will get stuck more often than usual.
Visual Studio will one or two times during a work week fail to get latest source (sometimes silently). If you attempt to get latest again, then it will say you already have latest. When you perform a build, then it will ofcourse fail. The workaround is to perform a get specific version with forced overwrite.
To create a wiki for documentation, then one have SharePoint, and version 2010 is a really crappy wiki tool.
For some really strange reason Microsoft System Center (really expensive) is completely detached from the TFS solution, and lingers around like an old lady. Making it super difficult to synchronize incidents with TFS-workitems, and get TFS-builds deployed using System Center. VS2013 Update 4 now includes the almost free InCycles Release Management, that should make the continuous integration work better (IIS applications can use Web Deploy).
If you work with advanced stuff like release-branching, then you will be surprised how difficult it is to generate a release notes document (read requires unsupported 3rd party tools). There is no automatic association of Work Items when merging to release-branch. And if you suddenly want to release a new build, then no help around for creating a release-report that lists the changes/workitems that has been included since last released build.
The integration of JIRA/Subversion in Visual Studio (VisualSVN) is so much better (ankhsvn is an alternative opensource version of VisualSVN). Still don't understand why Tfs-annotate cannot jump to next previous version like Svn-blame can.
I have no idea about the difficulty of setting up TFS 2010/2012, but JIRA / Subversion / CruiseControl.NET was very easy and cheap (Guess one would now use Git and Jenkins that also supports Gated Checkin).
VS2012 also includes a redesign of the entire user interface, which includes a new "improved" TFS Team Explorer that is really a pain to work with as a developer (Compared to VS2010). Microsoft has declared that Team Explorer has been fixed in VS2013, but it is not true. It is mouse-click hell to perform checkin and associate tfs-workitems.
Visual Studio 2012 now includes a virtual kanban board, but I would be surprised that this feature is not added to JIRA.
Became very suprised when the Visual Studio Team announced that they will implement GIT support in Visual Studio 2012. Guess it is easier than trying to rewrite TFS into a distributed version control system. Hope the new GIT integration will come up to the standards of VisaulSVN.
We use JIRA and GreenHopper for all our development tasking, bug tracking, and product management needs. We have a team of 46 developers, testers, and management. It integrates fully with Eclipse. I highly recommend it.
The tasks and workflows are fully customizable, you can add fields, add automation (like assigning tasks to team members when the task changes state), support drag-and-drop attachments, and more.
The pricing on JIRA just dropped to a significantly for managed hosting.
Well this is basically about the tend in the market, IF you people working on open source technologies specially java , mostly professionals of java are familiar with JIRA, JIRA has almost all type of plugin for project management, SDLC, Code Review and Bug tracking. But if your people working on the .net or microsoft technologies than they are comfortable with TFS.
In general, if your project is built in Java (Or other Open Source), go with JIRA. If it's built on .NET technologies, go with TFS.
Theoretically you could use either one with Java or .NET, but the integration won't be as tight and you will have to use plugins to get everything working.
JIRA / Subversion / Bamboo are much more configurable and integrate with other open source tool with hooks and triggers. TFS does not allow integration with anything. It's not extendable. You can't improve it with modules or plug-ins or extensions. In my opinion, TSF is quite unexciting and dull, that is if you think of source control and change management as a necessary evil then TFS is for you but if you are in Configuration Management or a Build / Release Engineer, JIRA is the way to go.
Related
I assumed this would be easy, but I'm not finding anything on it...
I have a project in TFS 2010, which needs to be moved to a new TFS 2015 server. Apparently the project cannot simply be moved normally because it's using a different project template which is not compatible and causes errors when trying to migrate (so I'm told - I don't have any more details on this).
I'm looking for a way to bring over the changesets, keeping history, to the new server. I assumed there was some kind of "dump" where you could export the TFS changesets, then import them into the new server into an empty project - but I'm not finding that option.
TFS Integration is deprecated and apparently doesn't work for TFS2015, with no alternative listed.
I'm open to other creative options like temporarily exporting to a different version control system - for example, I've looked at SVNBridge, but I can't even get that working, let alone figure out if it would help here.
Is there a way to migrate all changesets for a given project and keep history, without migrating the entire project?
There is no default way to migrate changesets in TFS, you would need 3rd party tool, like OpsHub (some features are not free), to migrate the most commonly requested data. Check: http://www.opshub.com/products/opshub-visual-studio-migration-utility/
Or you may consider doing a upgrade from TFS 2010 to TFS 2015, which is a full data transfer. To understand factors that affect your upgrade's compexity, check the requirements and review the upgrade process.
Learn if a dry run makes sense for you, and weigh the benefits and the costs to perform a pre-production upgrade.
When you're ready to upgrade, minimize downtime with the TfsPreUpgrade tool - especially for very large TFS collection databases (> 1 TB). Follow these steps for how to upgrade TFS.
I want to do daily migration of TFS changes to a ClearCase system. I was going to try out TFS Integration tools but I can't get any of the toolset pieces to work. What are the requirements to run this app? I have VS 2010, TFS 2010 and Sharepoint 2010 installed. The assemblies it's trying to load don't seem to be present in VS2010 and I don't if it requires VS 2008 or not. Anyone ever had this running? I'm migrating from TFS to CC. Not the other way around.
Update:
I've been using this tool to sync TFS 2010 changes back into a UCM ClearCase implementation at the client. It has been going poorly. The tool should be clearly marked as Beta or even Alpha. A peek into the code reveal around 100 TODO's and "This needs to be fixed". I have spent a good deal of time trying to iron out some of the issues and have made progress. My suggestion is before using this tool on mission critical projects, spend at least 3-4 weeks evaluating it in your environment. When it works, it works pretty well with moving changes.
I don't know much about how to access TFS2010 elements, besides "check an individual project for pre & postbuild steps either by loading the project in visual studio or manually reading the project file".
If you need Sharepoint assembly, this technote describes the requirements.
And I don't think an automatic import utility exists (from TFS2010 to ClearCase 7.1.x), as this technote mentions:
Change request (RFE) RATLC01005874 had been submitted requesting a conversion utility to export source code from Microsoft Team Foundation Version Control (TFVC) to ClearCase;
however, the decision was made by Product Management to exclude the requested feature from future upgrades and releases due to the significant architectural changes required to implement the solution.
The right approach is to manage to list the content of relevant labels for a given scope, and make a clearfsimport into a ClearCase view, with a full label applied right after it.
You don't need TFS (server), VS or SharePoint installed. You will need a SQL server for the core platform. Then you will need the various assemblies for TFS, which you can get by installing the Team Explorer component (it's on the TFS install media).
We decided to go with the TFS Integration Platform. It allows us to sync TFS work items back into ClearCase when ever we want. It provides the level of integration we needed to keep the traceability. The TFS to CC integration is bleeding edge, but it works enough for what we need. (Syncing work items and user check ins.)
We are a mostly MS shop at work doing .NET LOB development. We also use MS Dynamics for our CRM app... all the devs are currently using VS/SQL Server 2008. We also use VSS, but everyone hates it at work and that is quickly on its way out.
We are begining our initiative for TDD implementation across the team (~dozen ppl). I've gotten TeamCity setup and have my first automated builds running succesfully using the 2008 sln builder and also using SVN that a co-worker had setup who is doing the source control analysis. When demoing to managament, I think they started to buy into my snake oil and threw out the suggestions of looking into TFS.
This threw a wrench in what I had planned for our TDD architecture; In a good way though, because I had always assumed that TFS was just too expensive and not worth it for our team (and i've seen the same in other shops i've worked at / know of). I do feel like MS is years behind in the TDD/CI area and that the third party products were probably much better and more mature... I still need to do a lot of research, but I figured I'd come here to see if anyone has actually used both systems.
I realize the TFS encompasses a lot more then just a build server... but I didn't want to make this too broad of a question at least on purpose. What are the practical pros/cons of using TFS/TFB instead of TeamCity - e.g. which benefits would we lose/gain? Has anyone here actually used both systems (TFS for TDD/CI and TeamCity/SVN) and can speak from practical standpoint?
I've done some searching on this topic, and one post I found here on SO mentioned that the cons of TFB was it only supported MSBuild. I was planning on using FinalBuilder with TeamCity; and it appears it also supports TFS as well...
Thanks for any advice
EDIT: Has anyone used TFS as their Build/CI server and can tell of success/failure stories?
We are a small development shop, and decided that Team Foundation Server carries too much overhead for us. We used to write custom MSBuild scripts to run from the command line, but after we discovered TeamCity, we moved our entire build process over to it.
We've found TeamCity to be easy to use and configure, and JetBrains provides excellent support and documentation. They are also on a much faster release and update cycle than Microsoft.
Their support for SVN source control is excellent, and we like the fact that they support both MSTest and NUnit for unit testing.
We also liked the fact that the TeamCity Professional edition was free, so we could evaluate it to see if it worked for us. We haven't hit the number of project configurations (20) that would require us to upgrade to the Enterprise edition.
This question has a lot of good answers about TeamCity. It does not compare to TFS but it might shed some light on TeamCity for you.
I have used both, and I have had success with both, but TeamCity was so much easier. TeamCity was a breeze to set up and configure. TFS was not. TeamCity is rock solid, it's easy to maintain and it just plain works. The developers at JetBrains have done a great job responding to the community. They get a release out every 6 to 8 months that adds real value. TFS is on a 2 year or more cycle.
TeamCity gives you more choice in how you build and what source control you use. It's not all in one, but that's sometimes a good thing. It's got a good set of extension points as well. We have also been really happy with the agent model it has.
I've gone through 3 absolutely painles upgrades in TeamCity. The one TFS upgrade we did took our build and source control down for 3 days. I'm the admin for TeamCity on our project and it takes up a couple of hours a month. TFS took a couple of days a week.
TeamCity + SVN + VisualSVN has been the smoothest environment I have ever worked in. TFS was generally smooth on the day to day, but only if someone was there keeping it running.
Hope that helps
The benefits of TFS are one integrated environment that is supported by Microsoft. I personally do not like TFS for source control and have had a number of issues with it. It is clunky, however it had the benefit of having VS integration (which is also available in VisualSVN, but is not as robust).
Personally, I think you would be much better off using SVN/TeamCity. It is just easier to work with and behaves more as you would expect. As with most open source software, both are constantly evolving and will always have the latest and greatest feature before Microsoft. The integration between the 2 is really good and I have found no fatal flaws in the system. I constantly push to go this route in my current company (we use TFS), as I believe it is a much better workflow. As an added benefit, it is significantly cheaper than going the TFS route.
I have also used FinalBuilder with TFS - my question there is what are you really buying with FinalBuilder that you can't do with NANT/MSBuild? The answer at my shop is unfortunately very little IMO.
First off, see this post:
SVN vs. Team Foundation Server
As to your question about which environment better fosters TDD and such, my two cents is that the build management system matters much less than what's in the build file itself. Your Ant or MSBuild file should have the targets that do your testing. With MSBuild or Ant, you don't have to use MS's test suite. You can still use nUnit or whatever else you want. That means it doesn't matter if TFS is calling your MSBuild file, or if CruiseControl is, or if TeamCity is. The smarts are all in the build file and the tools you integrate with it.
My personal choice is not to get locked down into TFS's way of doing things, since you have a lot more freedom for a lot less cost with the wealth open-source testing tools that are out there. TFS is about to receive a major upgrade, as well. If you are going to go with TFS, my advice is to at least wait until 2010 is released. Concentrate on making your MSBuild files as good as they can be right now.
That being said, I must admit that TFS has one of the nicest build systems out there (2005 was terrible, 2008 was nice). Being able to easily customize notifications and the release process all inside .NET code was pretty cool -- you had a lot more central control over build and release policy than we did with CruiseControl.NET.
So I've used TFS and SVN/CCNet. I can't speak much to TeamCity. But IMO a build management system should be fairly agnostic to what is being built and how it's being built. For us, the extra control in the release management process that TFS brought us just wasn't enough of a bonus for us to justify the greatly increased administrative effort of a fully integrated TFS solution. Nor was it enough to justify the extra per-license cost of TFS, which can be significant.
The old TFS Build was XAML based and very cumbersome and and not nice to work with. That said, the new TFS 2015 build system is leaps and bounds better, and is script based with lots of web hooks and 3rd party integrations; very similar to Team City. Also, TFS now supports Git, so you are no longer confined to using Team Foundation Version Control (TFVC). Also, with TFS you can use your own on-prem installation, or can take advantage of a hosted solution through visualstudio.com. TFS is great because it's one completely integrated environment (work items, planning, builds, tests, deployments), whereas Team City is just a build solution. When this question was originally asked in 2010 I would've recommended Team City hands down. Now though, the 2 are very competitive. I would say that it would maybe boil down to if you want an all-in-one solution, then go with TFS, but if you are looking for purely just a build system, then Team City.
Comparing TeamCity to Visual Studio Team Services (the latest cloud-based offering from Microsoft):
Both work great for implementing a continuous integration process
TeamCity is more mature and everything just works.
Visual Studio Team Services by contrast is constantly evolving to catch up with TeamCity and some things just don't work well (e.g. try triggering builds based on paths that have changes from Git - the documentation is weak and the feature itself just doesn't work (as of August 2016))
Visual Studio Team Services makes it easy to have only cloud-based agents running your build (the downside however is that each has to do a clean pull of your repository for each build which may add a minute or more to the build). Both can also support local build agents which do not need to wipe the working directory for each fresh build.
But in either case I would highly recommend you also look at CakeBuild which moves most of the configuration information about how to do a build out of the CI system and into C# code that is in your Git repository along with all your other source code. With CakeBuild you can run the same build locally as you will run in the CI system and if you need to go back a month to build a specific version you have the source code and the build script to do it.
With CakeBuild in place you are now free to easily switch between TeamCity and Visual Studio Team Services.
The only downside to CakeBuild is that all your build steps are bundled into a single task in the CI system which makes reporting slightly less nice and may involve some extra work to get the test results out into a format that the CI reporting system can use.
MS is years behind in the TDD/CI area
Being one who has TDD'd for 4 years now you are correct. MS is still not even promoting it nor do they offer tools that work well with the TDD flow.
Don't get stuck dealing with Visual Studio for any kind of automation, source control, or agile workflow period (stop using TFS please!!). That stuff even though they say is "new" is monolithic and always comes with weird issues and bloat. It is always painful.
I've used Team City and it's simply amazing, things work, it's designed for usability, and it's simply designed well and compatible with most all test tools, etc. Fine use Visual Studio for code, nothing else. Look for external and open source tools to help build a better CI. The "you can do everything right in VS" sell is not selling, and it's not working. People nowdays are used to and always combining different tools from the outside to get things done. Relying on all MS toolsets is just not the way to go IMO for .NET. MS likes to sell "hey you can just do everything right here". But you end up with nothing but pain when you go that route and drink their koolade (TFS, MS Fakes, etc.).
If you plan on doing TDD, you definitely don't want to be using all MS tools. You'll either be pushed down "their way" of doing things which is often proprietary and/or bloated when you try to TDD with their tools or be totally restrictive. For TDD you need to be able to have some flexibility and choices when you decide to layer in different test frameworks, assertion libraries, etc.
Add Octopus on top of Team City, and it's stellar...you will simply fall in love with it as developer or for anyone doing DevOps.
Stop trying to rely on Microsofts continued failure at agile tool offerings
Start looking outside the box and try new things is what I keep repeating to the .NET world, me being a .NET developer in the past and who has tried new things outside the MS world.
Currently our build solution is set up using TFS + MS Build scripts.
TFS is also being used as a CI server.
I've seen several posts on this site telling people about other CI solutions.
Are there any compelling options to move to another Solution for our build system?
Or in other words what are we missing out on by using TFS?
EDIT
We are using TFS for source control / issue tracking and I think this is a good solution, im just wondering about the other options for build server / CI server integrating with TFS.
The main problem with TFS is that if you have a server crash, restoring your source code is non-trivial. This is unbelievably bad since the most important aspect of any source control system must be to be fail-resistent, at least if you perform all backups as you should.
IMHO the greatest benefit of TFS is that everything is integrated in the IDE: work items, bug tracking, CI, Code analysis, ...
I have used TFS in the past but my current company use SubVersion/Team City/FogBugz to implement the same functionality provided in the TFS solution.
I would say that from a technical implementation perspective, you can gain additional features from a non-TFS system that TFS would be a nightmare to configure.
However, that said, one of the biggest reasons for not going for TFS is the cost of running such a system. The big advantage of TFS is the integration of everything which makes people use it more as the more you put in, the more you get out. The worst case scenario is a system that people can’t be bothered using which adds no value to the company’s development.
In my opinion, if you are already on TFS and can afford to stick with do, do just that!
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
Questions asking us to recommend or find a tool, library or favorite off-site resource are off-topic for Stack Overflow as they tend to attract opinionated answers and spam. Instead, describe the problem and what has been done so far to solve it.
Closed 9 years ago.
Improve this question
I'm interested in knowing what high quality and useful add-ons or utilities are available for TFS. They can be commercial or open source. Of particular interest are any tools allowing visualisation of branches and tracking changesets as they are merged across branches (yes I know that the next version of TFS will be better in this area). A lot of the lists of TFS add-ins I found via google are quite dated and link to non-existent / abandoned projects.
I'll start the ball rolling with two we've found very useful:
TFS Branch History is an add-in for Visual Studio allows you to view the history of an item going back before the last branch
TFS Power Tools is a collection of TFS utilities from Microsoft including a command line tool that provides several useful features
TFS Power Tools - collection of MS utilities has grown too large and too powerful to summarize here. Don't leave home without it!
MSSCCI plugin (2005 link) - lets TFS work in a wide variety of IDEs that support the older MSSCCI [aka SourceSafe] standard, such as VB6, FoxPro, PowerBuilder, SQL Management Studio, etc
TeamPrise ($$) - suite of TFS clients for Eclipse, Mac, Linux, mainframes (!), just about everything else that MS doesn't support natively
TFS Sidekicks - suite of utilities was one of the very first 3rd party tools and continues to add features. Now supports UI queries on history, status, workspace, labels, shelvesets, permissions, team builds, and more -- much of it now integrated directly into VS.
TFS Administration Tool - easily synchronize permissions between core TFS services, Sharepoint, and SQL Reporting Services
Migration & Synchronization Toolkit - framework for migrating from other ALM systems to TFS, including support for ongoing 2-way synchronization
SvnBridge - lets you use a SVN client against a TFS server, to appease the folks who just don't get it ;-)
KDiff3 - best merge tool anywhere. See below for more options & instructions.
TFS Code Review Workflow - just what it sounds like; uses shelvesets + work items + a checkin policy to formalize the code review process
Conchango SCRUM template & task board - probably the most popular 3rd party Process Template, plus a ($$) dashboard product
Source Server for TFS - get full source code indexing from your symbol server; now baked into the main WinDBG download, this link goes to a setup guide
TeamLook ($$) - deep integration between Outlook and TFS work item tracking. Think JIRA on steroids, if you've ever used that product.
TFS Work Item Manager and Dashboard - very slick WPF replacement for the work item features of Team Explorer, plus a dashboard that comes with lots of reports aimed at replacing the canned ones on the stock Team Project Portal. Still in beta but demos look promising
Reporting Services Sample Pack - large collection of reports to run against the stock process template, or use as an example for writing custom ones
Performance Report Pack - another report package, this time aimed at studying TFS performance
MSBuild Extension Pack - make customizing your Team Builds somewhat less frustrating
MSBuild Community Tasks - ditto
MSBuild SideKick ($$) - IDE and debugger for Team Build scripts
Even more complete (but old) list: http://blogs.msdn.com/davidmcg/archive/2007/03/09/team-foundation-server-tools.aspx
List of merge tools + settings: http://blogs.msdn.com/jmanning/articles/535573.aspx
Some frequently requested checkin policies:
"Custom Path", "Changeset Comments", "Forbidden Patterns", and "Work Item Query" policies are all part of the official Power Tools now
Keyword expansion
Branch/Merge only
Source Analysis
Build Status
Time That Task
Team Foundation Sidekicks have been invaluable in keeping builds and merges in check.
I created a tool that makes creating links between lots of work items easy. It also allows moving workitems between projects.
It can be found here: WI Assitant
TeamSolutions besides TeamLook which was mentioned before also offer another two great add-ins:
TeamSpec ($$) - Word addin for TFS
Requirements management
TeamBox (free) - automatic work
item creation from POP3 account
Time-tracking tools for TFS
1) http://www.teamexpand.com/ - the reasonably priced tool with many features
2) http://www.imaginet.com/notion-timesheet - I tried this tools few years ago. yet the latest update was in 2011, not sure what is on with the tool at the moment
3) http://telerik.com - the tool is good yet the pricing is way too expensive
4) and there are few opensource tools. http://tfstimesheet.codeplex.com , http://tfstimesheets.codeplex.com Just to name a few
I have found a TFS client "TFS Work Item manager" with cool features (for example: tree view, links to assigned work items) to sort and filter items and very helpfull visualisations (very good taskboard, dashboard).
You can use Team Search to do a full text search of your work items (it's not free though):
http://teamsearchapp.com