Team Foundation Server (TFS) is a tool that – properly leveraged – can make a significant difference in how successful your projects are. It leverages a comprehensive repository for storing all project materials (source code, tests, project plans and other artifacts), and hosts a powerful business rules engine that audits all operations that take place with it. Consequently, it can yield an incredible amount of information about the status of your projects at any one time, notify you when something has – or hasn’t – taken place, and even enforce the rules of your process to ensure that everything is done according to plan. Coupled with the client-side front-end -- Visual Studio Team System (VSTS) -- you can leverage TFS to accomplish -- in a comprehensive and integrated fashion -- what a dozen other disparate tools will only do individually.

Our VSTS-TFS 2008 BootCamp is designed to address Team development with VSTS-TFS so that once the course is complete, your team will be ready to start using TFS right away.

The course focuses on every perspective of TFS:

• TFS Architecture, Internals and Customization, APIs
• VSTS roles (Developer, Database Developer, Tester and Architect)
• Configuration Management (source control, branching, merging)
• Test-Driven Development (TDD)
• Installation, setup, and configuring TFS

Unfortunately, TFS can be daunting to install, learn and master. Our VSTS-TFS BootCamp will educate your team on every aspect of TFS, so that they can immediately run – not walk – with it after only 5-days of training.

If you opt to have us give the course on-site, we can include details on how to successfully install and maintain TFS above and beyond the information provided by Microsoft, including mentoring you through the setup/install process.

Here's what previous students of our courses have said.

Request an On-Site presentation of this Class

Attendees should be familiar with basic concepts in software development methodologies, including:

• Roles in the Software Development Process. Attendees should understand basic roles such as Architect, Developer, Tester, and Project Manager.
• Configuration Management (a.k.a. Source Control). Attendees should understand the purpose and practice of configuration management as a way of preserving and reviewing project history. 
• Reading code and making simple modifications by following instructions (which we'll walk you through).
• Basic features of Visual Studio 2005: toolbars, tool windows, projects, solutions, properties, and the built-in help system (position cursor, press <F1>).

This course addresses every aspect of TFS, and consequently includes material for Architects, Developers, Testers and Database developers.

In the course you'll learn:

• TFS Architecture
• Features of the 5 Visual Studio Team System Roles
• What Test-Driven Development is and why you should use it
• How to write unit tests in VSTS
• How to write data-driven unit tests
• How to write ordered, generic and web unit tests
• How to perform ASP.NET load testing
• How to unit test non-public code
• When to deposit unit test code in ASP.NET’s App_Code folder
• How to create database unit tests with T-SQL
• How to create database unit tests with Managed Code
• What code coverage is and how to use it in VSTS
• What Code Profiling is and how to leverage it
• Instrumentation vs. Sampling in Profiling
• Designing classes for testability
• Testing user interfaces
• Using mock objects (NMock) to test complex scenarios
• Using Static Code Analysis to enforce code quality control on your project
• Writing your own custom Static Code Analysis rules
• How to use and leverage Application Modeling
• How to model a Distributed System with the Architect Role
• How to model a Logical Datacenter with the Architect Roles
• How to design classes with VSTS
• How to manage Database schemas the with Database Professional Role
• How to edit stored procedures with Database Professional Role
• Generating database test data with Database Professional Role
• How to compare database schemas and data
• How to refactor database objects
• TFS installation, setup and security configuration
• TFS hardware requirements
• Working with TFS using Team Explorer
• Understand what is a work item is
• Understand what is a process template is
• How to work with Areas and Iterations
• How to create and configure Team Projects
• How to manage one solution per Team Project vs many
• Managing work items with Excel
• Managing work items with Microsoft Project
• Creating and maintaining a TFS-synchronized project plan with Microsoft Project
• How to create Work Item Queries
• How to link work items
• How to customize process templates and work items
• The process guidance portal site
• The differences between Agile, CMMI and SCRUM team projects
• How to create automated Team Builds
• How to creating and run Team Builds
• How to configure MSBuild Scripts
• How to customize MSBuild Scripts
• How to create a custom MSBuild Task
• How to configure a build server
• How to create a scheduled build
• Run unit tests as part of a team build
• Run Static Code Analysis as part of a team build
• Set up a Continuous Integration environment with TFS
• Team Foundation Server Source Control
• How to create workspaces and customize them
• How to create changesets in TFS Source Control
• Check-ins and check-outs
• How to use Shelving and create shelvesets in TFS Source Control
• How to use branching and merging in TFS Source Control
• How to work with shared checkout
• Source control configuration and check-in policies
• How to enforce code quality and coding standards with TFS Source Control
• How to link check-ins to unit tests
• Create code check-in comments
• Learn to link check-ins to work items
• Learn to set source control permissions
• Migrate your existing Visual SourceSafe repository to TFS source control
• Access TFS source control from the command-line interface
• Set up the Team Foundation Server Proxy
• Use TFS Proxy to enable source control caching
• View TFS Proxy cache statistics
• Create Team Project reports in SQL Server Reporting Services
• Design an ad hoc report using Report Designer
• How to edit the built in Reporting Services reports
• How to view the hidden SQL Server Reporting Services reports
• How to use the TFS SharePoint portal to view team project data
• What team project alerts are and how to customize them
• How to delete a team project!
• How to extending and customize the behavior of VSTS and TFS
• How to write a custom check-in policy
• How to write a custom Static Code Analysis rule
• How to create a custom MSBuild task
• What TFS events are and when to use them
• How to write a custom TFS Event Handler
• The TFS API and how to invoke it directly
• TFS Web Services and how to use them

and more.

It’s easy to assume that VSTS is a new version of something that came before: Visual Studio 2005, Visual Studio 2003, etc. The similarity in names makes that a natural assumption. But VSTS is something more: it’s a whole new product for process support; and part of how it supports your process is by integrating with and extending existing products. It provides new features in those existing products; but those new features are the spoonful of sugar that makes the medicine go down. Process improvement is the medicine, the real value in VSTS. So to answer the question of what VSTS is, we have to look at it from several angles, based on different roles users will play as they work with it.

An Architect’s view of Visual Studio Team System
For software architects, VSTS is all about modeling. Modeling, modeling, and more modeling. Besides the Class Modeler, there are four new modelers in Visual Studio Team Edition for Software Architects: the Application Designer, the System Designer, the Logical Datacenter Designer, and the Deployment Designer.

A Developer’s view of Visual Studio Team System
For software developers, VSTS adds four powerful code analysis tools, plus a testing tool: the Static Code Analyzer, the Dynamic Code Analyzer, the Code Profiler, the Code Coverage tester, and the Unit Testing tool.

A Tester’s view of Visual Studio Team System
Software testers will share some new features with the developers: Visual Studio Team Edition for Testers includes the Code Coverage and Unit Testing tools. After all, testing at that low-level code view is a shared concern for developers and testers. But beyond that, the tester edition adds three new tools: the Load Testing tool, the Manual Testing tool, and the  Test Case Management tool.

A Project Manager’s view of Visual Studio Team System
For Project Managers, VSTS is primarily a process management and communications tool; but in particular, it provides integrated work item list management in both Excel and Project. The techniques are a little different in the two tools, of course, but the core feature is the same.

A Team’s view of Visual Studio Team System
VSTS defines the “atoms” that make up a software development process, and then provides tools for managing and using those atoms. The atoms are roles, workflows, work items, work item state transition rules, artifacts, artifact check-in rules, and guidance pages. A role simply defines a role that one or more individuals fulfill as part of the process. A workflow is all about work items and work item states and how they change. A work item is a task, a job that some team member must do as part of a workflow. Work items are grouped into categories that describe common rules for similar work items; and those common rules are mostly defined by States. Every category of work items defines one or more states, as well as transitions between states, rules that restrict those transitions, and actions that trigger the transitions. An artifact in VSTS is any persistent piece of information generated as part of processing a work item; and a check-in rule defines conditions that must be satisfied before you can check in an artifact for the project. And finally, guidance pages are HTML pages that act as a tutorial and guide in applying the process.