Except, of course, for any information which is already publicly available: that I can bring to your attention. So I'll share some things with you, including links to where you can find the same information yourself.
The subject of the training is Visual Studio Team System (VSTS), a grand, sweeping effort to unify the tools that a team uses to develop software. VSTS lets project managers, software architects, software developers, testers, and others all work on their individual tasks with their individual tools; and then it ties together the work products of those tasks into a common repository, with common reporting and workflows and rules. It also allows the team to define work items, assign them to individuals, and track their progress. VSTS is only available in beta right now, but is scheduled for release next month. You can learn more about VSTS here.
VSTS builds upon Visual Studio 2005 (VS 2005), the latest version of Microsoft's popular developer tool suite; but it extends Visual Studio's capacities to support other team members besides developers. And in addition, it integrates with popular MS Office tools for project management, and it provides hooks for third parties to integrate into the VSTS environment.
The basic structure of VSTS is shown in this image, taken from this tutorial:

The left column shows the elements of VSTS for Software Architects:
- Application Designer. This tool allows an architect to define the components that will be deployed as part of a project, as well as the connections between them. It also allows the architect to generate the source code shells for these components.
- Logical Datacenter Designer. This tool allows an architect to define the logical servers and server zones where the parts of a project will be deployed, as well as the connections between them.
- Deployment Designer. This tool allows an architect to assign components (from the Application Designer) to servers and server zones (from the Logical Datacenter Designer) and to validate that no component connections violate the datacenter design constraints.
The center column shows the elements of VSTS for Software Developers (in addition to the basic code development capabilities of VS 2005):
- Dynamic Code Analyzer. This tool allows a developer to test the run-time behavior of a component, including whether it overruns its memory and how it manages resources such as handles and critical sections.
- Static Code Analyzer. This tool allows a developer to assess how well the source code for a component complies with coding standards and practices.
- Code Profiler. This tool allows a developer to determine how much time the program spends in particular areas, and is useful for identifying inefficient code and bottlenecks.
The right column shows the elements of VSTS for Testers:
- Load/Web Tester. This tool allows a tester to assess how well the system performs under various system loads, such as a particular number of concurrent users.
- Manual Testing. This tool allows a tester to design and implement manual tests, while still having the results incorporated into the work item tracking and reporting systems (described below).
- Test Case Management. This tool allows a tester to define and manage test cases: sets of data to be used in various tests, as well as the expected and actual result sets.
Across the right two columns are the elements that are common to Developers and Testers:
- Unit Testing. This tool allows low-level, pass-fail testing of the internal structure of the code.
- Code Coverage. This tool allows a tester or developer to identify parts of the code which haven't been exercised or tested yet (and where bugs may therefore be hiding).
And across all three columns are the elements that are common to all roles:
- Class Modeling. This tool allows a user to define code classes and the relations between them. This is not UML, but I'll forgive them.
- Visio and UML Modeling. This tool allows UML modeling as a communications tool (but I can suggest a better one).
- Team Explorer. This tool allows a user to explore the work items in the project.
- Visual Studio Professional. This is the VS 2005 shell that hosts the other tools.
All of these tools are built on top of the services in the Visual Studio Team Foundation:
- Build Manager. This service supports automated project builds.
- Change Management. This service supports archives of old versions of source files and other artifacts. It replaces the much-loathed Visual SourceSafe.
- Work Item Tracking. This service supports creation of work items (i.e., tasks to be performed in your development process), as well as assigning work items to workers and tracking work item progress.
- Reporting. This service supports flexible queries and reports based on work items.
- Project Site. This service creates and maintains a Microsoft SharePoint Web site that lets Web users view the reports and other status of the work items in the project.
- Integration Services. This service allows third party components to integrate into the VSTS environment.
- Project Management. This service allows integration with MS Project and Excel.
Whew! That's a lot of power in there; and I haven't even begun to discuss the real power in VSTS: process templates! Look for those in my next installment.



