Team Foundation Server
|Written in||C++ and C#|
|Operating system||Microsoft Windows|
Team Foundation Server (commonly abbreviated to TFS) is a Microsoft product which provides source code management (either via Team Foundation Version Control or Git), reporting, requirements management, project management (for both agile software development and waterfall teams), automated builds, lab management, testing and release management capabilities. It covers the entire Application Lifecycle Management. TFS can be used as a back end to numerous integrated development environments but is designed to provide the most benefit by serving as the back end to Microsoft Visual Studio or Eclipse (on Windows and non-Windows platforms).
- 1 On-Premises vs. On-Line
- 2 Architecture
- 3 Work Items
- 4 Source Control
- 5 Reporting
- 6 Team Build
- 7 Testing
- 8 Lab Management
- 9 Release Management
- 10 See also
- 11 References
- 12 External links
On-Premises vs. On-Line
Team Foundation Server is available in two different forms, On-Premises and On-Line (a service hosted by Microsoft (http://www.visualstudio.com/products/visual-studio-online-overview-vs)). The latter one is called Visual Studio Online (see next).
Team Foundation Server (On-Premises)
There are two basic installations available (and variations of each) which are the Basic Configuration and the Advanced Configuration. Basic Configuration allows TFS to run on a workstation or server, includes basic Windows SharePoint Service (if desired), can run on SQL Server Express or a full version of SQL Server and provides work item tracking, test case management, manual and automated testing, automated builds and source code management. This installation is appropriate for smaller teams and requires little to no overhead for the maintenance of TFS. The advanced installation option allows for all features of TFS. In this configuration TFS can be distributed across multiple servers for redundancy, plugged into Microsoft SharePoint 2010 or 2013, SQL Server Reporting Services and SQL Server Analysis Services. Other capabilities such as Lab Management and Release Management can be added to either type of installation.
- See also: Visual Studio Online
Team Foundation Service is a subset of a larger suite, that is called Visual Studio Online. The cloud service offers the most recent features compared to the On Premises version of TFS (and uses the same code with minor modifications) backed by Microsoft’s cloud platform, Windows Azure. For Visual Studio Online, there is no setup required, simply log in using Microsoft Account (previously called Windows Live Account) and develop. The main differences at this point between the cloud and on premises versions of TFS involve customization and extensibility. For example, in the on premises version, organizations can customize the process templates (see below for an explanation of process templates) but in the cloud they cannot. Or Lab Management can be plugged into the on premises version but there is no lab management for the cloud. Last, two components are not present on the Cloud-based version: SQL Reporting / BI and the Sharepoint.
On the other hand, the cloud does have some capabilities, simply because of the nature of the cloud that the on premises version does not have. These include an automatically scalable build farm (on premises teams have to configure many build servers whereas in the cloud the build servers are simply available) and virtually infinitely scalable load testing (again, the on premises TFS requires that each and every machine is configured for scalability testing). And finally, new features come to the cloud every three weeks because of the rapid development cycle and these features take longer to migrate to the on premises version as updates (approximately every 3 months).
Team Foundation Server is built on a Multitier architecture, scalable architecture. The primary structure consists of an application tier responsible for processing logic and which maintains the web application portal (referred to as Team Web Access or TWA). TFS is built using Windows Communication Foundation web services and are available to be consumed by any client (although it is recommended to use the client object model). The data tier and application tier can exist on the same machine. To support scalability, the application tier can be load balanced and the data tier can be clustered and if using Microsoft SQL Server 2012, AlwaysOn SQL Server Failover Clusters and Availability Groups are supported which allows for geographic replication of data. The primary container is not TFS, rather it is the Project Collection. A Project Collection is a physical database that contains a group of Team Projects. The Project Collection is another scalability mechanism in that each collection can be placed on different SQL Servers or SQL Server instances. On top of the Project Collection databases, there is exactly one configuration database per TFS instance which stores meta-data regarding the project collection databases. Data from the collection databases is aggregated into the Warehouse database which de-normalizes the data in preparation for the data being loaded into an Analysis Services cube. The warehouse and the cube allow complex trend reporting and data analysis.
TFS can also integrate with an existing SharePoint farm built out to any scale as well as the built in Windows SharePoint Services. SQL Server Reporting Services are supported for more advanced reporting against the data warehouse or the Analysis Services data cube. These installations can be on the same system or on different systems. Build servers, lab management servers, release management servers and proxy servers (to reduce some of the load on the application tier), test machines and load test machines can also be added to the infrastructure. To support teams requiring enterprise project scheduling, TFS also integrates with Microsoft Project Server which allows enterprise level portfolio management, resource management and project tracking.
Microsoft provides two stand-alone re-distributable API's for connecting to TFS. One is a native Java SDK, the other is a .NET SDK. These API's allow for client connectivity to TFS. Because TFS is written on a service oriented architecture, it can communicate with virtually any tool that can call a web service. Another mechanism is being able to subscribe to system alerts (things like a work item was changed or a build completed) - there are approximately 20 pre-configured alerts and teams can then add as many other configurations as needed. When used in an extensibility scenario, these alerts can be sent to a web service of your choosing and then actions can be taken to alter or update the work items (such as implementing advanced business rules or generating work items programmatically based on a given scenario).
The data warehouse can also be extended through the creation of custom data warehouse adapters. With the introduction of TFS 2012, custom add-ins can also be created for Team Web Access which are called Web access extensions.
In addition to supporting Visual Studio 2010, 2012 and 2013 (and Microsoft Test Manager 2012 and 2013) natively and Eclipse, older versions of Visual Studio and other environments can be plugged into TFS using the Microsoft Source Code Control Integration Provider (MSSCCI Provider – pronounced “Miss-Key”). These tools provide full access to the features in TFS.
Microsoft Excel and Microsoft Project are also supported to help manage work items (more on this below) which allows for bulk update, bulk entry and bulk export of work items. Microsoft Project can be used to schedule work when conforming to a waterfall software development methodology. Both Excel and Project support bi-directional updates of data. This allows, for example, project managers to put a schedule in Project, have that work imported into TFS where developers update the work and then the schedule can be updated without the project manager having to perform extra work. For additional information on clients, see “Git” below.
With Team Foundation Server 2012, Microsoft PowerPoint was also integrated with TFS to enable rapid storyboard development to help with the requirements management process. The integration provides extensible storyboard shapes that can be used to build any type of interface mockup that can then be animated with PowerPoint’s built in functionality. These storyboards can then be linked to work items. In an effort to handle the growing geographic dispersion of teams and to involve stakeholders earlier and more often in the process, Microsoft added the Feedback Client. This tool allows users to exercise an application, annotate what they are seeing with audio and video, capture screens and provide contextual feedback to the development team. This provides specific feedback on the functionality of an application from a users’ perspective without requiring meetings and demo sessions. TFS also provides for command line tools for both Unix and Windows environments. The Power Tools for TFS include a Windows Shell integration which allows users to check files in and out, add files and perform other basic tasks by right-clicking on a file or folder.
At the heart of TFS is the “work item”. A Work Item represents a thing – it can be a work that needs to be accomplished, a risk to track, a test case, a bug or virtually anything else a user can imagine. Work Items are defined through the XML documents and are highly extensible. Work items are combined into a Process Template which contains these and other pieces of information to provide a development framework. TFS includes Process Templates for the Microsoft Solutions Framework for Agile and CMMI and Scrum. Teams can choose to use a built-in template or one of the many templates available for use created by third parties. Process templates can be customized using the Process Template Editor which is part of the Power Tools.
Work Items can be linked to each other using different relationships to create a hierarchical tree of work items or a flat relationship between work items. Work items can also be linked to external artifacts such as web pages, documents on a file share or documents stored in another repository such as SharePoint. Work items can also be linked to source code, build results, test results and specific versions of items in source control. The flexibility in the work item system allows TFS to play many roles from requirements management to bug tracking, risk and issue tracking as well as recording the results of reviews. The extensible linking capabilities ensure that traceability from requirements to source code to test cases and results can be accomplished and reported on for auditing purposes as well as historical understanding of changes.
Team Foundation Server supports two different types of source control - its original source control engine called Team Foundation Version Control (TFVC) and with the release of TFS 2013, it supports Git as a core source control repository.
Team Foundation Version Control
TFVC is a centralized version control system allowing teams to store any type of artifact within its repository. TFVC supports two different types of workspaces when working with client tools - Server Workspaces and Local Workspaces. Server workspaces allow developers to lock files for check-out and provide notification to other developers that files are being edited. A frequent complaint for this model is that files on the development machine are marked as read-only. It also requires developers to "go offline" when the server can't be contacted. Local workspaces were designed to avoid these problems. In a local workspace scenario files are not read-only and they do not have to be checked out before working on them. As long as the files are on the developers local machine, it doesn't matter if the server is connected or not. Conflicts are dealt with at check-in time.
To improve performance for remote clients, TFS includes the ability to install Proxy Servers. Proxy servers allow source control contents to be cached at a site closer to the developers to avoid long network trips and the associated latency. Check-ins are still performed directly against the TFS application tier so the Proxy Server is most beneficial in read scenarios.
As part of the source control engine, TFS supports a number of features to help developers ensure the code that is checked in follows configurable rules. This rule engine is called a Check-in Policy. There are several out of the box policies such as the Changeset Comments Policy which will not allow a check-in unless the developer enters a check-in comment. These policies are extensible and can be used to examine all aspects of the code being checked in, the comments and the related work items. TFS also supports a Code Analysis feature that when used independently is known as FxCop. The inclusion in TFS means that the analysis can run against code checked into the server and during automated builds.
With the release of TFS 2013, Microsoft added native support for Git. This is not a Microsoft specific implementation but a standard implementation based on the libgit2 library. This is the same library that powers the popular GitHub and the code is freely available from GitHub. Because Microsoft took the approach of using a standard library, that means that any Git client can now be used with TFS natively (in other words, developers can use their favorite tools and never install the standard TFS clients). This allows tools on any platform and any IDE which support Git to connect to TFS. For example, both Xcode and Android Studio support Git plug-ins. In addition, if developers do not want to use Microsoft's Team Explorer Everywhere plug-in for Eclipse, they can choose to use eGit to connect to TFS. This makes TFS a ubiquitous source control system regardless of the client platform in use.
Using Git does not preclude the benefit of using TFS work item or build system. When checking code in with Git, referencing the work item ID in the check-in comment will associate the check-in with the given work item. Likewise, Team Build will also build Git projects.
One of the major reasons to use TFS as a Git repository is that it is backed by SQL Server and is afforded the same protection as Team Foundation Version Control. This gives developers some choices when choosing the type of project and work style that works best for them.
At this time source code cannot be moved from a TFVC repository to a Git repository. However, using the Git-TF tool, a Git repo can be moved to a TFVC repository.
Reporting has been a core component of TFS since its initial release in 2005. The reporting infrastructure consists of a data warehouse (Tfs_Warehouse) which is a relational database and a SQL Server Analysis Services data cube. Both of these sources are available for reporting through SQL Server Reporting Services when this option is installed. Since these are standard database and cube structures, any tool which can point to these data sources can report from them. This includes tools such as Cognos, Tableau, Excel and other reporting tools. Included with each out of the box process template is a set of reports for reporting services which cover Build information, Test results and progress, project management, agile reports (Backlog Overview, Release Burndown, Sprint Burndown and Velocity), bug and issue data. New reports can be created using Report Builder for SSRS and any of the existing reports can be modified.
More specialized reporting is available for load test results. This data is available directly within Visual Studio and can be exported to Excel for detailed analysis.
TFS 2013 introduced a new feature called "light-weight reporting" which provides for the ability to create real-time reports based on query results and which do not rely on the warehouse or cube. TFS 2012 (and continuing into 2013) offers real-time burndown, velocity and CFD diagrams directly within Team Web Access.
Team Build is a build server application included with Team Foundation Server. Two components make up Team Build - MSBuild which is a declarative XML language similar to Apache Ant and Windows Workflow Foundation. WF was added to the build process starting with TFS 2010, prior to that only MSBuild was available. The build capabilities have continued to evolve with each subsequent release of TFS. In TFS 2010 and 2012, the WF templates ([XAML|Extensible Application Markup Language]) files were stored in source control and could be edited and versioned directly from source control. In TFS 2013, these files were removed to eliminate clutter and streamline the build process. The WF templates can still be downloaded, edited and stored in source control if desired and TFS 2013 does not break existing TFS 2010 or 2012 build process templates. With the support of Git in TFS 2013, Team Build has been enhanced to allow automated building of Git projects as well as TFVC projects.
Windows Workflow controls the overall flow of the build process and TFS includes many pre-built workflow activities for managing common tasks that are performed during a build. MSBuild is the markup language that is found in the .proj (csproj for C# projects and vbproj for Visual Basic projects) files. The build system is extensible with users being able to create their own workflow activities, the ability to inject MSBuild into the process and to execute external processes. The workflow nature of the build allows for unlimited flexibility but it may take some work to achieve that flexibility. Shared and open source projects have been started to build community backed activities to enhance the capabilities of Team Build.
The build process can be configured for various types of builds including scheduled builds, Continuous integration, Gated check-in and Rolling builds. Gated check-ins are unique to TFS and eliminate the shortcoming of a CI build. In a CI build, if the build breaks the entire team is blocked from doing a get latest and re-compiling. A Gated check-in build on the other hand will shelve code that a developer checks in, perform a get latest on the server code and perform a build. If the build succeeds, the code is checked in on behalf of the developer who submitted the code. If the build fails, the developer is notified and can fix the code before trying another check-in.
Builds have retention policies with them so that they do not accumulate when not needed (or builds can be directed not to produce any saved output) or build output can be locked and saved forever. New with TFS 2013 is the ability to check in the build results into source control. This was a necessary enhancement to support automated builds on the TFS service where there is no drop location to place the builds. In the on-premises version build output can be configured to end up in any accessible shared folder location.
The build process in TFS is also part of the traceability mechanism in that build brings together many of the artifacts that are created and stored in TFS. Assuming developers associate source code with work items on check-in, Team Build has the ability to report on the changes in each build - both source code changes and work item changes as well as test results (this includes [unit testing] results as well as automated functional testing (CodedUI) results). As bugs and PBI's are resolved and integrated into builds, the work items which track these artifacts are automatically updated to indicate in which build they were successfully integrated. Combined with the testing tools, testers then get an integrated view of what code was changed in each build, but also which bugs, PBI's and other work changed from build to build. This gives testers the ability to target their testing activities in a more focused manner.
Testing is accomplished through Microsoft Test Manager (MTM) and uses the work items of Test Cases and Bugs to track things. MTM is hierarchically organized around test plans, which contain test suites, which contain test cases, which contain test steps. Test cases can be manually executed step by step, but also recorded during manual execution to run in an automated fashion later. Several reports are available such as "Test Case by Status". Performance testing is done within Visual Studio Ultimate.
Microsoft has started moving the testing capabilities to the web. In TFS 2012 testers can create and execute test cases via the web. In TFS 2013 Microsoft added the ability to create test suites and plans via the web, bulk entry and edit of test cases, and the ability to copy and paste test cases in bulk (from Excel for example) into TFS through the web.
Lab Management is a capability which allows TFS to control and monitor virtual or physical environments for testing purposes. It provides an integrated functional testing environment which can be used in combination with Team Build to build the application, deploy it to a test environment, execute unit and functional tests and then, if a test fails, the environment can be snapshot (if it is a virtual environment) and a bug can be automatically created with the details of the failure and links to the snapshot. It can also be used to create standard test environments that can be replicated for use by multiple testers and developers.
This capability is made possible through the integration of Microsoft System Center Virtual Machine Manager (SCVMM). SCVMM maintains the stored or templated environments which can be deployed and controlled through Microsoft Test Manager. Manual tests can also be executed through the associated lab environments but those tests are not recorded unless MTM is installed in the virtual environment. VMWare virtual machines are also supported but these are treated as physical machines at this point in time.
In mid-2013 Microsoft purchased a product called InRelease from InCycle Software. InRelease was fully incorporated into Team Foundation Server 2013. This capability complemented the automated build and testing processes by allowing a true Continuous Deployment solution. The tools were re-branded "Release Management" for TFS 2013. The Release Management capabilities give teams the ability to perform a controlled, workflow (provided by Windows Workflow Foundation) driven release to Dev, Test and Production environments and provides dashboards for monitoring the progress of one or more releases.
- List of revision control software
- Comparison of revision control software
- Comparison of issue tracking systems
- Microsoft Visual SourceSafe
- SVNBridge a Windows client or server side extension to TFS that allows access to TFS revision controlled items from Subversion client applications.
- "Application Lifecycle Management with Visual Studio and Team Foundation Server". Microsoft. 2013. Retrieved 2013-10-15.
- "Adopting Team Explorer Everywhere". Microsoft. 2012. Retrieved 2013-10-15.
- "Visual Studio Online is the home for projects in the cloud".
- "New Release 'Cadence' Begins with Visual Studio 2012 Update 2". 1105 Media. 2013. Retrieved 2013-10-15.
- "Availability Enhancements (Database Engine)". Microsoft. 2012. Retrieved 2013-10-17.
- "Team Foundation Server Architecture". Microsoft. 2012. Retrieved 2013-10-17.
- "Set alerts, get notified when changes occur". Microsoft. 2013. Retrieved 2013-10-17.
- "How to create an adapter". Microsoft. 2008. Retrieved 2013-10-17.
- "Microsoft Visual Studio Team Foundation Server 2012 MSSCCI Provider". Microsoft. 2012. Retrieved 2013-10-17.
- "Request and review feedback". Microsoft. 2012. Retrieved 2013-10-17.
- "How to customize TFS 2010 work items and workflows". Ted Gustaf. 2010. Retrieved 2013-10-17.
- "Microsoft Visual Studio Team Foundation Server 2013 Power Tools". Microsoft. 2013. Retrieved 2013-10-17.
- "Server workspaces vs. local workspaces". Phil Kelley. 2013. Retrieved 2013-10-17.
- "How to: Install Team Foundation Proxy and set up a remote site". Microsoft. 2013. Retrieved 2013-10-17.
- "GitHub libgit2/libgit2". GitHub. 2013. Retrieved 2013-10-31.
- "EGit". Eclipse. 2013. Retrieved 2013-10-31.
- "Git-TF". Codeplex. 2013. Retrieved 2013-10-31.
- "Components of the TFS data warehouse". Microsoft. 2013. Retrieved 2013-10-17.
- "Perspectives and measure groups provided in the Analysis Services cube for Team System". Microsoft. 2013. Retrieved 2013-10-17.
- "Team Foundation Build Activities". Microsoft. 2013. Retrieved 2013-10-17.
- "Community TFS Build Extensions". Codeplex. 2013. Retrieved 2013-10-17.
- "Microsoft acquires InRelease, adding continuous deployment to Visual Studio, Team Foundation Server". The Next Web. 2013. Retrieved 2013-11-15.
- Team Foundation Server: At Work
- Visual Studio 2005 Team System: Enterprise-Class Source Control
- Using Source Code Control in Team Foundation
- Team Foundation Server Fundamentals: A Look at the Capabilities and Architecture
- Visual Studio Team System 2008 Web Access
- Visual Studio Application Lifecycle Management