As part of my role in working with partners in the Visual Studio Industry Partner (VSIP) Program I have spent a lot of time documenting the new features and extensibility point of Visual Studio 2010 and Visual Studio Team System 2010.  I have been sharing this information with VSIP partners under NDA a long time in advance of Beta availability. We did this to ensure that partners get as much time as possible to upgrade their products which are integrated with Visual Studio to ensure that they are ready to release their Visual Studio extensions simultaneously with our release of VS2010.

 But now that VS 2010 Beta 1 has been released, the wraps are off and I can share this information publicly.

I will do this in two Blog posts.

Yesterday I covered  new features and extensibility points of Visual Studio 2010.

Today  I will follow this up soon with a similar blog post on Visual Studio Team System 2010.

So, below is a high level description of some of the new features and extensibility points in the new Visual Studio Team System (VSTS) 2010 and Team Foundation Server (TFS)

This is not a complete list but focuses on those new features most likely to impact VSIP and other partners who develop solutions that integrate with VS.

For more detailed information please download the VS 2010 builds and VS2010 SDK as they become available and use the VS 2010 product documentation. Also search and the Microsoft Blogs at  for more information You can find instructions for downloading the feedback and sharing your feed back here.  The best way to get prepared for VS2010 is to get VS2008 deployed today.  You can find everything you need on our home page here.


Disclaimer: This document is based on current thinking only.  All information is subject to change.  The purpose of this document is to provide early insight to  partners about the architecture,  implementation considerations, opportunities and other plans around VS 2010

Microsoft Visual Studio Team System New Features, Extensibility Points and Partner Opportunities


Microsoft Visual Studio Team System 2010 & Team Foundation Server Products

Microsoft Visual Studio Team System 2010 Blogs

·        Jeff Beehler

·        Charles Sterling

Microsoft Visual Studio Team System 2010 is comprised of the following tools and applications:

·        Microsoft Visual Studio Team Suite 2010, includes:

o   Microsoft Visual Studio Team Architecture 2010

o   Microsoft Visual Studio Team Development 2010

o   Microsoft Visual Studio Team Test 2010 (includes Microsoft Test and Lab Manager)

·        Microsoft Visual Studio Team Architecture 2010

·        Microsoft Visual Studio Team Development 2010

·        Microsoft Visual Studio Team Test 2010  (includes Microsoft Test and Lab Manager)

·        Microsoft Visual Studio Team Test 2010 Essentials  (includes Microsoft Test and Lab Manager)

·        Microsoft Visual Studio Team Lab Management 2010

·        Microsoft Visual Studio Team Foundation Server 2010


Note that the components of  Visual Studio Team Suite 2010 can also be purchased separately.


Microsoft Visual Studio Team Foundation Server 2010

VSTS 2010 Team Foundation Server Blogs

·        Brian Harry

·        Buck Hodges


Work Items

Visual Studio Team System 2010 introduces many new Team Foundation Server Work Item features.  Most notably Work Item Linking and Hierarchy has been introduced. Thus Work Items can have parents and children, and Work Item Links can have types (eg A Bug can be Linked to a Test by a “Tested By” link type). 

This structure provides better support and reporting around work breakdown and roll up etc. and many other benefits. Users can view and modify dependent and nested, hierarchical relationships within a graphical view. Drag and drop can now be used for rearranging work item dependencies.   Traceability queries provide a rich query language in the query builder which allows you to query across work items and relationships. New Query folders make it easier to organize your queries particularly in projects with a large number of queries. Work Item usability has also been enhanced with new support for Rich Text, a new links “control”  provides powerful control of links and link types,  HTML “controls” can also now be used inside a Work Item.  

Integration with Microsoft Excel has been improved as well with full hierarchy and round-tripping support.   Users can plan iterations, view the backlog, capacity, and velocity of individuals and teams using agile workbooks that integrate predefined work item queries with Office Excel workbooks.

It is now possible to maintain summary, subordinate, and dependent task relationships in Office Project for work items that are stored in Team Foundation Server.

Users can now roundtrip Predecessor-successor relationships from Office Project and Team Foundation Server .  The format and formulas that have been added to Office Excel worksheets that are connected to work items that are stored in Team Foundation Server can now be maintained during updates.

The Undo function in Office Project for files that contain work items that are stored in Team Foundation Server will now work correctly.

Many of these new features will require work from existing partners to achieve compatibility and relevance with VSTS 2010.  These features also open up new opportunities particularly for more granular and  meaningful work item replication, work item breakdown etc.  With these changes the TFS Work Item store  also becomes a more practical “master” store for work item information, reducing the need for replication in some scenarios. For partners these enhancements represent a wide array of opportunities to expand functionality into work item break down, time tracking, and end to end work item scenarios.

Partners most affected by these changes include requirements companies, process methodology companies, and any other companies with products what interact with TFS Work Items.


Microsoft Solutions Framework (MSF) for Agile Software Development v5.0

The latest version of MSF for Agile Software Development has undertaken a significant shift to better align with how Agile teams actually work. There have been changes to the terminology, such as the use of User Stories, Story Points, Velocity as well as changes to the artifacts, such as a new set of Work Item Types, Link Types, Reports, Dashboards, and Workbooks.

Two of the biggest enhancements to the Process Template are the addition of the Dashboard Pages and the Agile Planning Workbooks. The Dashboard Pages provide visibility into the projects progress by surfacing the projects metrics. The Product Quality dashboard, for example, shows if the bug count is growing or shrinking, as well as the rate at which bugs are being fixed, created, and closed.  My Dashboard, as another example, can be customized to highlight information that users are individually interested in.

The Agile Planning Excel Workbooks allow users to easily manage their Product backlogs and Iteration backlogs. The Product backlog Workbook helps users map out future iterations and which user stories fall into those iterations. The Iteration backlog workbook helps users plan for their current iteration.

The changes to the Agile Process Template:

·        New Dashboards

·        For Microsoft Office SharePoint Server (MOSS) installations the following dashboards have beed added: “Work Progress Dashboard”, “Product Quality Dashboard”, “Test Progress Dashboard”, “Build Quality Dashboard”, and the “My Dashboard”.

·        For Windows SharePoint Server (WSS) installations there are only two new Dashboards, the Project Dashboard and the My Dashboard.

·        New Agile Planning Excel Workbooks have been added. These are the Product backlog and the Iteration backlog.

·        Work Item Type have ad several changes. The scenario work item type is now a user story work item type. The User story work item type has an estimation field called story points. The risk work item type has been removed. The quality of services requirement type has been removed. The criteria work item type has been removed. And finally a test case work item type for integration with Visual Studio Team Test 2010 Essentials has been introduced.

·        Link Types is a new feature in VSTS 2010 in this process template the following Link Types have been Implemented: The VSTS 2010 link types have been implemented for test case management;  Tasks are mapped back to User Stories, and Tasks are broken down into tree hierarchies.

·        New Reports

·        Bug Status - Helps you track the team's progress toward resolving bugs.

·        Bug Trends - Helps you track the rate at which the team is discovering and resolving bugs.

·        Build Success Over Time -Helps you track changes in the quality of the code that the team has checked in.

·        Build Summary - Helps you determine the status of each build.

·        Burndown and Velocity - Helps you track the team's progress toward completing the work for an Iteration.

·        Reactivations - Helps you track how effectively the team is resolving bugs.

·        Remaining Work - Helps you track the team's progress.

·        Status on All Iterations - Helps you track the team's performance over successive iterations.

·        Stories Overview - Helps you track how far each user story has been implemented.

·        Stories Progress - Helps you track recent progress for each user story.

·        Test Case Readiness - Helps you track how many test cases are ready to be run.

·        Test Plan Progress - Helps you track the progress of your test plans.

There are several partner opportunities related to Microsoft Solutions Framework (MSF) for Agile Software Development v5.0 as follows:

·        Providing support for macro level reporting across multiple agile teams.

·        Providing a visual scrum task board to capture and formalize day to day sprint lifecycle task management.

·        Providing the ability to assign work in the workbook according to disciplines and skill sets.

·        Provide guidance and tools to enable customers to upgrade their existing team projects to take advantage of new features.


TFS Reporting  / Office SharePoint Dashboard

Visual Studio Team System (VSTS) Team Foundation Server (TFS) 2010 introduces new reporting tools to view and track progress and report on your entire portfolio:

Customizable, role-based, out-of-the-box dashboards. These out-of-the-box dashboards can help quickly find important information about your assignments, status of your project, software quality, test progress, and build quality. These dashboards are defined for MSF For Agile Software Development V5.0 and use features available with SharePoint products and technologies.

New and Improved Reports. Many new out-of-the-box reports help you view and track progress. Some of the reports provided include bug status and bug trends, build quality indicators and build summary, burndown and velocity, reactivations, remaining work, stories overview and progress, and test case readiness and test plan progress. These reports are defined for the MSF for Agile Software Development v5.0.

Warehouse Database Views.  New views for the warehouse database make it much easier to create T-SQL queries for your reports .  Unlike the tables on which they are based, these views are designed to be used in reports, and they are less likely to change in new releases.

Generated Excel Reports from Work Item Queries: This feature analyzes the query and creates reports in Office Excel that are connected to the SQL Server Analysis Services database. This allows you to quickly create simple visual reports based on a work item query.

TFS 2010 Reporting is extensible in the following ways

·        Reports – adding new reports

§  SQL Server Reporting Services (SSRS)  reports / Excel reports against the TFS cube

§  SSRS reports against the new views on the relational warehouse

·        Dashboards – adding new dashboards

 TFS 2010 Reporting   introduces some breaking changes as follows:

·        TFS Warehouse schema

§  There are some breaking schema changes in the Relational Warehouse and Analysis Services database

§  At a high level:

·        Work item related date, person, Area, and Iteration dimensions are no longer top-level dimensions, they are dimension attributes on the work item dimension

·        Dimensions and attribute naming conventions changed

·        Team Project is now a hierarchy to support ETM infrastructure

·        Team Test Schema changed to reflect the new Team Test architecture

·        Business Keys have a changed format

·        Warehouse extensibility

§  TFS 2008 custom warehouse adapters will not work in TFS 2010 Beta 1




There are several partner opportunities related to this feature are

·        Dashboards – building new SharePoint controls that talk to TFS and could be integrated into the dashboards.

·        Reports – partners could build a new reporting solutions that talks to the TFS cube.


Team System Web Access

Team System Web Access is automatically installed and configured when you install Team Foundation Server. VSTS 2010 brings better Integration of Team System Web Access with Team Foundation Server. You can now create and update work items; create relationships among work items; view files, changeset and shelvesets in version control, , queue new builds and view build status; and accomplish most tasks supported by Team Explorer using Team System Web Access.

This feature is extensible in the following ways

·        Build Web versions of your work item custom controls


There are several partner opportunities related to this feature are

·        Redirect users to friendly Web Access URLs from your application to open work items, view source control files, and build results


TFS Administration

Visual Studio Team System 2010 Team Foundation Server (TFS)  introduces a new Setup architecture providing a much easier and flexible setup experience. You can configure TFS components by using a new Wizard based Configuration Tool. You can also choose whether to install SharePoint Products and Technologies or the reporting feature. Team System Web Access is automatically installed and configured when you install Team Foundation Server.

The Visual Studio Team Explorer client application now installs by default with each product in Visual Studio Team System.

TFS 2010 also delivers a new the new Team Foundation Administration Console. Using this you can reconfigure and review the status of the TFS servers that host the application services, proxy services, build services, and lab services. In addition, you can review the status of the configuration and collection databases, add or remove SharePoint Web applications for hosting team project portals, and manage team project collections.

SharePoint Web Applications have been enhanced so  you can use more than one SharePoint Web application for hosting the Web sites used as team project portals.

Projects can now be grouped into “Project Collections”. This is of greatest use for group projects that have similar needs or objectives, or that share common user groups, server resources, and maintenance schedule.

TFS Administrators can now add servers to existing deployments.  You can use more than one server that is running SQL Server for hosting the databases for your deployment. If you have hardware or software based load balancing installed and configured in your deployment, you can add more application-tier servers to transparently balance the load between servers in large-scale deployments.

TFS 2010 also brings improved integration with Windows Server Active Directory Services (ADS).  Work item fields that store person’s names can now be automatically updated based on ADS data.  You can update the name of a team member in Active Directory, and the change is automatically and updated in the corresponding work item fields at the next synchronization. Automatic propagation of name changes is made to work items, work item histories, queries, and alert notifications.

TFS 2010 also includes support for some hosting scenarios. Changes made in support of this include introduction of a Multi-tenancy security model and tools to facilitate data portability such as tools to roll up customer/project group/project data and move or manage separately from other data.


TFS Synchronization & Migration

Significant progress is being made in the area of TFS Synchronization & Migration with other ALM systems.   Highlights of the efforts are detailed below.


The re-architected TFS Migration and Synchronization Toolkit is the new migration tooling platform that will be available to partners interested in building integration solutions beyond those listed below.  The current version of the TFS Migration and Synchronization Toolkit  currently plays that role, and it has been successfully used to create several TFS migration tooling solutions.  Based on feedback from partners, MVPs and others in the community, this new toolkit has goals to reduce the cost of building a migration solution and improve the robustness, reliability and performance of solutions built on this migration tooling platform.


Significant investments have been made to the TFS migration tooling platform in an effort to make it less expensive for partners build new solutions and to improve all aspects of quality.  The TFS Migration Toolkit is currently under development with an initial release to CodePlex planned for later this year, and early previews available now.  The new migration tooling foundation will support one way migration and bidirectional sync solutions with all shipping TFS versions as one endpoint (TFS 2005, 2008 and 2010). 


Partners wishing to utilize this toolkit will supply an adapter written against the APIs of a target system to gather information from that system (i.e. the last set of changed synchronized from that system). The migration toolkit framework services will manage various migration and synchronization workflows. 


There are also plans to ship an extensible TFS Migration Shell  that allows partners to produce branded solutions that can take advantage of UI extensibility to offer target-system specific configuration editing and runtime management of the migration and synchronization process.  The new platform will ship with a full SDK that includes reference documentation for the public APIs, guidance material for developers and a set of sample adapters.  Willy-Peter Schaub is leading partner outreach efforts for the new migration tooling platform.


TFS Synchronization & Migration solutions from Microsoft:

·        HP Quality Center (QC).  This migration solution offers bi-directional synchronization of “defects” from QC to work items in TFS.  There is no test case or test plan integration at this time. We currently have a prerelease of the TFS to QC Connector tool available for public download on Connect (see: for more info on the prerelease).  The final release of the connector is planned for the first half of 2009.

·        IBM ClearCase (CC).  This migration tool supports multiple modes of migration, including bi-directional synchronization.  The publicly released version of the tool supports TFS 2005 SP1 and CC 5.0 and 6.0.  An updated release is planned for the first half of 2009, which will include official support for CC 7.0, TFS 2008 SP1, and an improved crash recovery mechanism.  Future releases that support TFS 2010 will be released closer to the RTM release of TFS 2010.

·        IBM ClearQuest (CQ).  This migration tool has been largely unchanged since the 2008 release, and it supports only one way migration.

·        Microsoft Visual Source Safe (VSS).   An updated version of the VSS Converter tool was released with TFS 2008 SP1, and it has continued to be improved for the 2010 release.  This tool only supports one way migration.


The Team Foundation Server Migration and Integration Solutions page offers a snapshot of the general migration tools partner ecosystem for TFS.  We are interested in expanding the number of partners featured on that site and the number of solutions available to customers.



Team Build 

Visual Studio Team System 2010 Team Build introduces several features aimed at improving build workflow, protecting the quality of your code, and helping you identify issues before code gets checked in.

VSTS 2010  moves from MB Build to Windows Workflow (WWF) as the primary tool for orchestrating  all the tasks related to a build. WF workflows are persisted in the XAML format. Two build process templates are included: (a) the default build process uses WF activities to drive the end-to-end build process and uses MSBuild only for the core compile/link step, and (b) the upgrade build process uses a much simpler workflow and relies primarily on an MSBuild script to drive the end-to-end build process. The integration with WF provides several benefits, including the ability to run builds across multiple machines, the WF graphical workflow designer and compatibility with a growing pool of WF activities, training and expertise.

The TFS 2010 WWF Build process exposes a number of parameters that can be used to customize builds without needing to alter the WF XAML. It is expected that many customizations will be achievable without modifying the WWF XAML. This approach facilitates reuse of the build process template by many build definitions, making it easier to address new build requirements because you only need to change one process template and it ripples through to all of the associated build definitions. In TFS 2005 & 2008 the build scripts were normally copied  and edited, creating an explosion of different build scripts thus making reuse less effective.

VSTS 2010 also introduces “Gated Checkin.” This feature enables you validate checkins on a separate build machines before the check-in completes, or worse, enters production. For large teams, it provides many of the benefits of continuous integration with far less risk. Continuous integration finds integration issues quickly by constantly building checkins and notifying you of breaks.  The downside is that the "current" code is broken until someone fixes it.  Gated checkin does the same thing but before the check in is committed, thus preventing the current code from getting broken.

For frequent and/or long-running builds, VSTS 2010 makes it easy to load balance them across multiple build machines. A single Build Controller manages a pool of Build Agents which may be running on the same machine or across different machines. The build process templates included with VSTS 2010 includes an Agent Scope Activity that runs on the Build Controller and reserves a Build Agent from the pool to run part of the build process. Build process templates can be customized to include multiple Agent Scope Activities that distribute the work of a build across multiple machines. For modern, multi-core machines, it's easy to configure multiple agents and even have them build in working directories on different local hard disks.

The default build process template also includes integrated support for publishing symbols and indexing sources, making it easier to debug your team builds. More granular retention policies let you decide if and when those symbols (and other build-related artifacts) should be cleaned up.

For partners using team build there is work to be done to both use and to be compatible with these new features.

·        This feature is extensible in the following ways

o   Creation of Workflow Activities

o   Creation of MSBuild Tasks

o   Creation of custom build process templates (WF XAML).

o   Visual Studio plug-ins and external tools that leverage the Team Build public API.

o   […. What else ???]

·        There are several partner opportunities related to this feature are

o   Delivery of scale out solutions using the new Build Infrastructure

o   Cross platform solutions based on this new infrastructure

o   Planning and configuration of build, test and deployment infrastructure


Source Code Version Control

Visual Studio Team System 2010 Team Foundation Server Source Control introduces “Branches” as First Class Citizens.

TFS now provides an actionable diagram of your Branch Hierarchy.  The TFS Source Control Explorer shows Folders and Branches differently using different Icons. Branches also have special properties. Visual Studio Team System 2010 also introduces new tools to Visualize branch relationships and new features to allow you to track changes across branches and view the history of merges and track related work items. Graphical color coded timeline and branch hierarchy views are also provided with the color indicating which branches contain a particular change.

 TFS also now provides an actionable diagram of Merges.  You can start from a file, changeset, branch, or work item, and quickly retrieve a diagram that displays each merge of a changeset. You can see both where and when the merge occurred. You can also use the diagram to perform common tasks. For example, you can merge a changeset by dragging the changeset to a branch where the changeset is required. You can also drill into the details of a changeset/merge.

All of these features are provided to help developers understand how they got a particular change or what the implications of a change are, or might be.  Annotations are also supported so notes can be added and shared to branches. 

Rollback has also been introduced as a first class feature so now users can back out changes when problems occur.

A new Conflict Resolution window enables you to more quickly and easily resolve file conflicts.

A new “Label” window provides you with tools that make it easier to apply, edit, remove, and manage your labels.

For more information and detail about any  low-level breaking changes see Matt Mitrik’s blog at .

Partners providing software that integrates with TFS Source Code control may want to expose some of these features in their UI.  Build vendors may want to provide more options based on these features.

This feature is extensible in the following ways

·        Client-side check-in policies


Microsoft Visual Studio Team Architecture 2010


VSTS 2010 Architecture Blogs

·        Cameron Skinner

·        Peter Provost


Team Arch / UML

VSTS 2010 Architecture is a completely new release which leaves behind the Distributed System Designers of VSTS 2005 and 2008 (Class Designer, Logical Datacenter Designer, Application Designer, System Designer, Deployment Designer) and the System Definition Model (SDM ) used by them.

VSTS 2010 Architecture integrates the worlds of “Model Centric” development with the world of “Code Centric”  development to deliver a flexible solution that can help manage complexity with visual models by helping developers and architects understand, manipulate and evolve applications. This includes new or legacy applications in a variety of languages.

VSTS 2010 Architecture uses the Unified Modeling Language (UML) at the logical layer and Domain Specific Languages (DSLs) at the physical layer (In fact UML is implemented as a DSL and persists UML diagrams to disk as  DSL XML files in the VS Project System).  This provides first class modeling support for .NET and the tight binding to code allows advanced features such as re-factoring of code using the visual model. 

Associated with this Microsoft has joined the Object Management Group (OMG) and Steve Cook has been representing Microsoft at a number of OMG meetings.  The following UML diagram types will be supported in VSTS 2010 Architecture

·        Logical Class Diagram

·        Use Case Diagram

·        Sequence Diagram

·        Component Diagram

·        Activity Diagram

VSTS 2010 Architecture also includes other tools that are not related to UML. These are

·        Architecture Explorer 

·        DGML Viewer and Editor

·        Layer Designer

·        .NET Sequence Designer

These tools are distinct from the UML tools.

VSTS 2010 Architecture is integrated across the Application Life Cycle by way of Work Item Integration As you create models of your system, you can easily create and link TFS work items with the elements in your models. For example, as you identify areas of system functionality (use cases), you can create corresponding work items which remain associated with these use cases. The same is true of other model elements such as components, classes, etc.


Architecture Explorer and Directed Graphs: You visualize code and other other information in your software system that by using Architecture Explorer. For example, you can browse your Visual Studio solution, assembly files, or saved queries. You can then visualize the relationships in your code as nodes and links on a directed graph which uses the Directed Graph Markup Language ( DGML ).

The “Architecture Explorer” has been designed to, as simply an closely as possible,  allow developers  to graphically explore existing code assets and associated relationships and dependencies.  Using a browser developers can display lists of assets with flexible browsing of those assets (it is not a traditional explorer or tree view).  It is based on Directed Graph Markup Language ( DGML ) and uses DGML to persist Models to disk in the VS Project System.  The Architecture Explorer can be  used to drive the creation of a visual models of the assets browsed  to gain a better understanding of them. Then the visual model can be used to refactor and re-architect the structure of the application as part of and upgrade, modernization or migration project .  The Architecture Explorer uses a provider model to learn about the structure of programs for which providers are available. The provider can also keep Architecture Explorer in Sync with source code changes .  VS2010 will include Architecture Explorer Providers for C#, & VB .    Beyond VSTS 2010 it is planned to make this provider model public so that third party languages could be explored directly with Architecture Explorer.  Architecture Explorer also uses DGML to persist it’s state.

VSIP language partners are encouraged to support DGML  in VS2010 so that their language source files can be visualized using the “Architecture Explorer”  and other VSTS Architecture tools. This would most likely be done by a language vendor creating a DGML file in the project system that describes the relationships between all the elements in that projects code.  Beyond VS2010 we hope to work with Language vendors to also support a provider model when it is available and deliver providers for their languages.

The DGML Viewer and Editor provides a general purpose way to view and edit objects and the links between them which can be persisted using the XML based DGML file format. VS 2010 will ship DGML providers for Managed Assemblies (regardless of language) and Solution/Project structure (regardless of language) in addition to C# and VB language DGML providers.

Code-Based Sequence Diagrams: You can see the behavior of method calls in .NET code represented as a series of lifelines and messages. The Sequence Designer features include the ability to reverse engineer code into a .NET specific  sequence diagram.  . This visualization  enhances your ability to understand and document your existing system.  

Layer Diagrams: You can visualize the logical architecture of your system by organizing the physical artifacts in your Visual Studio solution into logical layers and describing their intended dependencies. You can then validate your code to help it remain consistent with the intended design. You can also include validation or enforcement  during check-in and build operations so that you can find dependency conflicts early and regularly.  As you work, you can then validate during each build and/or check-in that the code in your solution is actually complying with your intended layering scheme.

Unified Modeling Language (UML) Diagrams: UML diagrams help you model user requirements and describe the functionality of your system. Team System 2010 Architecture supports these types of UML diagrams: Activity, Component, Class, Sequence, and Use Case.

 Customizable Model Elements: You can use profiles and stereotypes to change the properties of your model elements. Team System Architecture includes several predefined profiles as well as the capability to define your own.

Integration of Model Elements with Work Items in Team Foundation Server:  You can create and link work items with model elements to organize the tasks for updating your system. This mapping creates a strong relationship between the parts of your system under development and the requirements they must meet.

.Net Class Diagram:  Finally VSTS 2010 Architecture includes the .Net Class Diagram which is based on the same .Net Class Diagram in Visual Studio 2008 Professional.


Extensibility:  In the VSTS 2010 Beta 2 timeframe we are adding extensibility features to VSTS 2010 Architecture in the way of pluggable menu item commands, drag drop handlers, validators and transformations exploiting the new Managed Extensibility Framework (MEF) and  the new “model bus”. The former is part of .Net 4.0, and the latter is part of DSL Tools.This will give partners the ability to generate code and models from both the UML designers and the DSL designers (Layer,  Class, Activity, Component,  Sequence and Use Case diagrams). , as well as support interaction between different designers.  Model Bus extensibility is described in the DSL Tools section. See .Net 4.0 documentation for details on Managed Extensibility Framework (MEF).   

Opportunities:  In summary the main opportunities and extensibility points related to VSTS Architecture are the ability to add pluggable menu items, drag-drop handlers, validators, code generators, and model transforms using a flexible model bus and adapter infrastructure and the ability to create a DGML file representing some asset. Most commonly this will be a Non Microsoft Language. The “Architecture Explorer”, or the “DGML Editor” could then be used to open study the structure of that code.


DSL Tools

The Domain Specific Language (DSL)Tools enable architects and developers to rapidly create and distribute their own custom model editors with a forms-based or graphical (using boxes and lines) user experience.The editors (sometimes called designers)  are hosted in Visual Studio. T4 technology (Text Templating Text Transformation) can be used to generate textual artefacts (for example C# source code or XAML) from models. .

Visual Studio 2010 ships with the DSL Tools and T4 runtime in the box in every SKU since it is used by other tools in Visual Studio, such as theLinq to SQL designer. . A DSL Tools authoring experience is shipped separately and depends on and exploits features in the Visual Studio SDK. This is a slight departure from Visual Studio 2008 where DSL Tools authoring shipped inside the VS SDK. Shipping separately gives us more flexibility on when we ship, in particular allows us to make more frequent improvements. We intend to make DSL Tools authoring available from the Visual Studio Gallery (

 In Visual Studio 2010, the F5 experience is improved, and deployment of a DSL considerably simplified, exploiting the extension manager in the Visual Studio platform and the new facilities in the Visual Studio SDK top create a VSIX package which is a simple zip archive that unpacks itself into the User’s extensions folder.

Visual Studio 2010 Beta1 also brings 11 new DSL features:

·        Different models can now interact with each other, (and with Team Architect UML designers, which have been built using DSL Tools), using the ModelBus, which was the number one requested feature by DSL Tools customers. A DSL author can choose to generate a ModelBus adapter, that will expose his model to other models or tools.

·        Databinding support has been added, allowing Windows.Forms and WPF form designers to be created by binding a standard winform or WPF-based UI directly to DSL models. This enables developers to quickly create designers such as the ResX or .settings designers in Visual Studio.


·        It is now possible to have completely or partially read only models, which can be used for instance by reviewing and commenting tools.


·        A number of UI enhancements have been added, including :


o   moveable labels for connectors,

o   sticky toolbox (when the user double-clicks on an item in the toolbox,it’s not necessary to return to the toolbox for repeated applications of the tool),

o   quick navigation and editing of compartments with the keyboard

o   Copy and paste of diagram elements to images (in Bitmap and .wmf/emf)

o   Copy and paste of model elements in or between diagrams

·        The notion of DslLibrary has been introduced. This enables factorizing and componentizing DSLs (for instance having several domain models have the same base-domain class)

·        The DSLs can now be extended by third parties after they have been deployed.

There are plans to make the DslDesigner itself extensable, thus letting the third parties to customize and extend the DSL authoring experience.

A migration tool is included to help DSL authors to migrate there existing DSLs from Visual Studio 2008 and the associated VS SDK.


Microsoft Visual Studio Team Development 2010


Microsoft Visual Studio Team System 2010 Development  Blogs

·        John Cunningham

·        Chris Schmich / Profiler


Code Analysis

VSTS 2010 features the following new  Code Analysis highlights:

·        Rule sets - code analysis can now be configured much more quickly and easily with sets of rules that are targeted at specific scenarios or areas of emphasis

·        Enhanced policy support - enforce your rule set with the code analysis check-in policy

·        8 New Data Flow rules - find hard-to-detect flaws with these advanced dataflow rules for managed code; including certain SQL injection vulnerabilities


Configuring code analysis in Visual Studio 2008 and earlier versions required evaluating each individual rule to determine whether it was important enough to turn on and fix for your project. This might be a very time-consuming process that made it difficult to make sure that the most important problems were identified and fixed. With rule sets, code analysis can now be configured much more quickly and easily with sets of rules that are targeted at specific scenarios or areas of emphasis.

Using the tool you can select which rule set(s) by simply selecting or deselecting the appropriate box.  Each rule set has a brief description of the types of rules within the rule set.  Further, you can open up each individual rule set and see the specific rules that make up the rules sets.  You can also turn on or off individual rules within a rule set.  Finally, you can adjust the type of action a rule will trigger.  In the past, code analysis rules have been limited to build Warnings, but now you can elevate code analysis rules to build Errors.

Customers and Partners are able to define and add their own Code Analysis rule sets.


Code Metrics

Visual Studion 2008 introduced  a new feature to allows users to generate code metrics for projects and solutions and displays the results in the Code Metrics Results tool window.  In VS 2008 this feature calculates five different metrics; Maintainability Index, Cyclomatic Complexity, Depth of Inheritance, Class Coupling, and Lines of Code. All metrics are averaged at the type, namespace, and assembly levels with the exception of Class Coupling. The Class Coupling metric displays the total number of distinct types referenced at the method and type levels rather than the total number of type references.

There are no modifications to Code Metrics in VSTS 2010


Test impact analysis (Codename: Aftershock)

As developers make changes to the code, it is critical for them to effectively test their changes, not only to prove the new code functions as expected, but also to ensure there is no unexpected downstream effect. Test impact analysis and test prioritization identify the tests that must be run to validate the code changes. This helps developers quickly check-in code with confidence by running only the necessary tests, and reduces the churn created by unexpected failures.

Test Impact Analysis works in conjunction with the Source Code Control features of Team Foundation Server to analyze changes to Source Code and to analyze VSTS Tests and by comparison determine which tests are impacted and need to be re-run as a result of changes to code. In this way just the impacted tests can be re-run in an automated way greatly enhancing efficiency and project velocity.  You can see a list of both manual and unit tests that are affected by your target code changes using Test Impact Analysis. As you run those tests, the test list adjusts to show only the remaining tests. Additional code changes adjust the list of unit tests, as do tests that are running on the server.

You can also predict many potential check-in problems that would otherwise have gone into your build and remained undetected.

The developer can toggle between an Impacted Tests view and a Code Changes view.

·        The Impacted Tests view provides a list of tests that need to be run and which code changes are covered by each of the tests.

·        The Code Changes view provides a list of code changes and which tests must be run in order to validate each of them.

These two views provide a easy way to discover what tests must be run in order to validate the changes to the code base without having to run all of the tests. This ensures that all changes are tested effectively.

Test impact analysis uses the CLR Profiling API to create a mapping of test cases to methods executed.  Also, it uses a combination of source changes and build outputs to build a mapping of methods changed in a given build and by extension across builds.  With this information, it  identifies test cases that are suspect (i.e. the code executed in running the test has changed) for a given build being moved to test.  So when a developer makes a code change, you can see how many tests that really affects (we all know - seemingly minor changes can have unexpected side effects). 

For many test organizations, this will mean a deterministic way to identify the minimum subset of tests which should be re-executed prior to final sign off. In fact at Microsoft, many products have a large number of automated test cases (between the millions of different configurations of different OS/browsers/languages/etc.).  Aftershock is being used by Microsoft to limit the number of regression tests that we have to run. 

There are no extensibility features planned around Test Impact Analysis,

For more information see


Historical Debugger (Codename was Proteus)

The new  Historical Debugger allows you to debug at specific points in time with.  It increases debugging productivity by reducing the time required to reproduce and diagnose an error in your code. Using this feature, developers, users or testers  can capture and record application execution and then developers can play back that recording in Visual Studio to diagnose application errors.

Unlike the standard debugger, which shows the state of the system at a point in time, Visual Studio Historical Debugger captures and records what the application does while it is running on your server. When an error occurs, you can view the state of the system at any time from the start up to the point of the error.   In this way many problems can be resolved without the burden and overhead of needing to “repro” (reproduce) the problem.   Additionally, because testers can record a historical debugging session using a  “virtualized” environment managed by VSTS 2010 Lab Management. Then developers and easily access and re-run the test in the same environment  where a bug occurred, thus Team System Development reduces the chance of not being able to reproduce a bug. 

A collection plan specifies the “what” and “how” of instrumentation. In addition to this developers can insert extra instrumentation and hidden trace points into the user’s code and into the .Net framework using ICorProfiling APIs. During execution a logger records data into a portable log file.  Visual Studio then provides a highly functional user experience, integrated with the VS Debugger IDE for the visualization and analysis of the data in the log file.

The historical debugger Dynamically instruments code at the function level to collect parameters and records explicit instrumentation points (System.Diagnostics.Trace, ETW, BID, etc.). Developers or testers can also configure an application to record test-specific activity, including test, test expectations, and test failure reasons. It imposes low overhead: 5-10% overhead for the default collection setup. It can be configured to record on remote machine and there are defaults plans out of the box  for each application type (WinForms, ASP.NET web app, WCF service, etc.) however these collection plans are customizable. Developers can replay the execution history in the debugger using familiar debugger views. The replay environment is tightly integrated with the Visual Studio source code window for navigation/viewing.  This feature is only available for managed applications (32 and 64 bit) and leverages the existing profiler infrastructure.

This feature will be available in Microsoft Visual Studio Team System 2010 Development (and Suite ) only.

There are several possible opportunities for partners in relation to this feature. Partners can customize collections plans to tailor collection for particular application types. You can automate the historical debuggers functionality through the Visual Studio DTE object or  integrate Command Line Tools into your application. Partners might, for example, want to incorporate the collection runtime into an application.   or they may want  to  insert markers into the log file to highlight important events or milestones.  Partners can also get “unstructured” access to the data in the log file to add analysis and other functionality not provided by Microsoft. Note however that the SDK will not be available until Beta 2.

It is currently planned that Historical Debugger will provide extensibility to allow third party language vendors at some time after the release of VS2010.


Visual Studio Profiler

Performance Profiler helps users Analyze Application Performance. The Visual Studio 2010 profiler  has been enhanced with “Rules and Guidance” to provide guided resolutions of common performance problems.  The new profiler also works under virtualization. We have also improved profiling of multi-threaded applications and make Jscript profiling a first class citizen. “Just my Code” profiling has been introduced to exclude framework code (which you can not change anyway) making it easier to see and deal with performance problems. We have reduced the instrumentation overhead and VSP file size. Some specific new features in this version include:

·        Profile client-side JScript performance in Web applications

·        Focus on your own code in profiler data views and reports by using the default Just My Code filter

·        Profile thread and process concurrency behavior by using new profiling modes that provide resource contention and thread interaction data for multi-processor computers and multi-threaded applications.

·        Understand and manipulate your profiling data more easily by using new graphical features in enhanced Summary views and the new Function Details views

·        Understand the impact of ADO.NET function calls by including tier interaction data in your profiling sessions

·        Profile on 64-bit computers and virtual machines

·        Choose the .NET Framework runtime to profile in side-by-side scenarios

·        Quickly isolate performance issues by using the profiler performance rules and your own custom rules


Existing  Profiler and Code Coverage  extensibility points that remain unchanged focus on the command line utilities. This means that someone could use the command line utilities to configure how the profiler behaves as follows


·         VSInstr to instrument binaries (for trace only)

·         VSPerfCmd to start sessions

·         VSPerfReport to see data

Code Coverage

·         VSInstr to instrument binaries

·         VSPerfCmd to start sessions


Remotely debug MPI  Applications

This feature exists in the current VS2008 product and only minor improvement haaebeen made in this release with not new extension points.  Remotely debug Message Passing Interface (MPI) Applications that are Running on a Windows HPC Cluster: You can use the MPI Cluster Debugger to simplify debugging multiple cooperating processes that are running on a remote cluster. By using the MPI Cluster Debugger, you can easily deploy required files to the cluster nodes, launch the remote debugger on each cluster node, and clean up after the debugging session has ended.


VSTS  Data

The features that formerly released as Visual Studio Team System 2008 Database Edition (VSTS Data) are now included as part of Visual Studio Team System 2010 Development.  With these tools, you can apply the same life-cycle tools to your database code that you apply to your application code. This includes offline development of database schema , use of Source Code Control to persist versioned database schema information along with other application assets, and participation in Agile or other process methodologies and use of the associated work items.

The tool set also provides a SQL database deployment environment  with a lot more commonality and many of the benefits  of other  traditional code development tools.

VSTS Data supports incremental database deployment. This means that database updates can be deployed to databases whose schemas are at different versions and VSTS Data will take care of applying just the changes needed to get them to the latest version. This also means that DBA can move to  Declarative Database Development  and  just update schema declarations (eg a table declaration) and let the product handle the complexities of creating the “Alter” scripts as required to deploy the change to various servers some of which be running different versions of the target database thus requiring different Alter Scripts per target server. VS Data also provides tools for Schema comparison, refactoring and supports versioning of Database Schema.

All of this is available in VSTS Data 2008 SP1. The VSTS 2008 Database Edition GDR (released in Oct 08) is a major architectural release bringing several new features.

VSTS 2010 (and the VSTS 2008 Data Edition GDR release) introduce an architecture in which

·        SQL DDL Source Files are compiled into a in memory SQL Code DOM.  

·        When an existing database is imported it is first used to create an in memory SQL Code DOM model and then that model is used to create the script fragments used to persist that model in the Visual Studio Project System.

·        Similarly when a VS Data Project is opened the script fragments are used to build an in memory SQL Code DOM model which is then used as appropriate for operations like schema compare etc. 

·        VSTS Data continuously interprets, analyses  and validates this schema model to ensure it stays in sync with script in the VS Project System.  

·        At build time the SQL Code DOM is serialized into a XML “.DBSchema”  file that can then be used for deployment. During deployment  the DBSchema file is used to once again create a SQL Code DOM model , the target database is also used to create a second SQL Code DOM, then the SQL Compare engine compares the SQL Code DOM models and create a deployment script.

This elegant architecture as several benefits. Most notably the SQL Code DOM means that the components of VS Data and other third party extensions can add functionality on top of the SQL Code DOM without the overhead of parsing Script, building script generators, building import tools or interacting with the target database system to understand or change it’s state.  Partners can instead focus on working on the much simpler, accurate and expressive in Memory model objects.  This dramatically reduces the overhead involved in developing products to help database professionals and profiting from the associated market. Adding features on top of the SQL Code DOM is called  “Project Feature Extensibility”. Examples of this include graphical schema design, optimization tools, migration tools, ETL tools etc.

VSTS 2010 Development also introduces  a new provider model to supporting different Database Schema providers (DSPs) for different databases such as SQL Server, 2005, SQL Server 2008, Oracle, MySQL and DB2. Microsoft will only provide the DSPs for SQL Server and we are currently working with Database and Database tools vendors to provide the DSPs for other database products. DSPs need to integrate with (1) the Schema Model APIs (2) the VSTS Data Project system APIs (3) Project Feature APIs

So now you can add third-party database providers to manage changes to database servers other than SQL Server. The specific feature extensions depend on the database providers. For example, other database providers might support different types of database refactoring operations.

This opens up opportunities for VSIP and other partners, particularly if they have existing Intellectual Property in the area of Database SQL Language Parsers for the various Database products on the market. Such companies are in a good position to create Database Schema Providers (DSPs) for those third party database products so they can be used with VS Data.

VSTS Data 2010 also introduces tools for  T-SQL Static Code Analysis (like FxCop for SQL), Database Unit Testing and Test Data Generation. It is also integrated with Team Build and VSTS work items, roles and VSTS MSF methodology templates.

VSTS Data 2010 also introduces  “T-SQL Intellisense” with syntax colorization, and other features of the Visual Studio IDE.

VSTS 2008 Database edition launched with the following extensibility points:  Data Generators (test value generators for a type instance), Data Distributors (allowing statistical distribution of values when generating test data) and Test Conditions (providing the ability to define Test assertions used to validate database unit tests).

In VSTS 2008 GDR and VSTS 2010 we introduce the following new extensions:   Refactoring Operations Types (for example a split column refactoring operation) and Refactoring Targets and Custom TSQL Static Code Analysis Rules (this was originally released as a Power Tool).

While the architectural enhancements were released in the “GDR” for the DSP model to provide heterogeneous database support, all of the API’s to actually write a DSP are not public until VSTS 2010.  As of VSTS 2010 Beta 1 and beyond, all API’s are public and readily available for DSP authors to code against.

While DSP extensibility is a significant undertaking, feature extensions can be added by simply dropping an assembly into an extensions folder in Program Files and modifying an XML configuration file.

As of VSTS 2010 all of the “Database Edition” functionality ships in the VSTS 2010 Developer Edition.  The VSTS 2010 Developer Edition is very extensible at all levels within the stack.  Tool vendors can easily write new tools that plug into the platform, but use the power of the model for analysis.  Existing features such as Static Code Analysis, Refactoring, Data Generation, etc can be easily extended.  Finally, database platform vendors can even author a “DSP” to provide support for additional database platforms such as Oracle, IBM, etc.   There are many extensibility options opened up by VSTS 2010 Developer Edition, creative partners familiar with the needs of the database industry and Line of Business (LOB) Applications  should be able to identify many buseinss oportunties  and areas to add value.


For more info see the VSTS DB Team Blog at


Microsoft VSTS 2010 Test Products Overview


[To be reviewed by Neelesh Kamkolkar ; Ram Cherala ;Bruce Taimana; Michael Rigler; Chris Patterson; Vinod Malhotra; Ravi Shanker]

VSTS 2010 Test Blogs

·        Amit Chatterjee

·        James Wittaker

The various tools and applications in Microsoft Visual Studio Team System 2010 Test work together with the high level goals to help developers and testers to Create test plans, test suites, test configurations, and test cases with individual test steps and then to gather diagnostic information while running a test, and automatically add it to a bug . There is also support for manual tests with a new application which records manual test steps so they can be viewed or replayed them during a future test run. We also introduce support for the creation of  automated UI tests. Finally  we are introducing a new product allowing testers to create virtual environments that define the set of environments, assets and roles required to run a specific application.

The changes we are making to testing are all aligned with the overall VSTS 2010 goal to pushing quality upstream so as to reduce costs downstream


Microsoft Visual Studio Team Test 2010

With Microsoft Visual Studio Team System 2010 Test  introduces  Automated UI Tests,  known as coded UI tests. UI Tests can be coded or, using this tools,  you can record a manual test and then play it back as an automated test (for applications that support the following APIs: MSAA (Microsoft Accessibility API) and UIA  (UI Automation API)  .  You can import recorded actions and generate code  which you can then alter. This allows great flexibility. You can take a recorded test,  add validation code to check that your application under test is working correctly, or looping to  create load tests, or replace data entry keystrokes to create a data driven test.

VSIP partners (particularly component vendors) should ensure they support the MSAA (Microsoft Accessibility API) and UIA  (User interface API)  APIs so customers can use the Record and Playback feature.


The following are the partner opportunities for this feature

·        VSIP partners (particularly component vendors) should ensure they support the MSAA (Microsoft Accessibility API) and UIA  (UI Automation API)  APIs for their Winforms, WPF and Silverlight controls so customers can use the Record and Playback feature against their controls Partners should ensure compatibility with VSTT before releasing new controls. The following is the high level guideline on what needs to be supported.

o   For WinForms Controls (Support via MSAA)

§  Provide an Implementation of  System.Windows.Forms.AccessibleObject for your Custom Controls

§  Populate and expose following properties: Name, Bounds, Role, Parent

§  Provide implementation for HitTest(), Navigate(), GetChild() and GetChildCount() methods

§  Provide Value if the Control supports Value property

§  Implement Select() and DoDefaultAction() if control supports State

§  Based on your Control scenario, raise one or more of the following System.Windows.Forms.AccessibleEvents

§  ValueChange, StateChange, SystemCaptureStart, SystemCaptureEnd, Selection, SelctionAdd, SelctionRemove, SelctionWithin

o   For WPF and Silverlight Controls (Support via UI Automation)

§  Set unique AutomationId property, provide Name, HelpText via AutomationProperties Attached Property

§  Implement Custom AutomationPeers for your Custom WPF Control for navigation and actions

o   Use Accessibility Verifications tools for Testing:

§  AccExplorer, Acc Events: Available via Accessibility 2.0 SDK Tools

§  AccChecker:

§  UIAVerify:


·        By default, recording and playback on Web, WPF and Winforms applications is supported. The record and playback engine exposes an extensibility interface which VSIP partners can use to develop and deliver plugins to enable

o   Record and playback support on Custom controls that they develop

o   Record and playback support for third-party technologies

o   Record and playback support for third-party browsers

o   Extend automation library

VS2010 also brings improvements in Unit Tests. You can now customize how you run Unit Tests.  You can now programmatically start test runs, or get events when test results are generated or when a test run starts or finishes. For example, you can create your own customized program to replace mstest.exe or build a stand-alone Windows-based application for Team System Test tests.

This feature is extensible in the following ways

·        Create your own test runner to run within your own application

·        Load the collection of tests from any supported test type

·        Run tests either synchronously or asynchronously

·        Ability to save the results to the format that meets your needs

There are several partner opportunities related to this feature are

·        Ability to have customers run a subset of tests that your company have already written to verify functionality in the environment it has been deployed to.

·        Ability to publish test data to file or to the web for additional diagnosis

·        Use of the Visual Studio framework along with the diagnostic data adapter infrastructure to gather system information and other points of data necessary to diagnose the application that has been deployed

You can now extend the unit test type and create your own test types without having to start it from scratch.  The CodedUI test type is an example of this extension and demonstrates that the possibilities are limitless when you want to extend your tests to fill functionality that does not exist.

This feature is extensible in the following ways

·        Listen to events as they are called to initialize, invoke and clean up the assembly, class and test

·        Add custom attributes that can be read in during the invoke event and perform actions based on those actions

·        Parameterize your test cases for easier data extension

There are several partner opportunities related to this feature are

·        Provide testing functionality that are not available through the testing framework.  Some possibilities would be an Orcale™ DB Test Type Extension or SAP™ Test Type Extension

·        Extend the current framework to make testing easier, such as providing code to elevate/demote user privileges and provide testing features such as DataRow to the framework.

Finally, you can create your own diagnostic data adapters and add it to the testing infrastructure to integrate your product.  Out of the box, we provide a basic system information adapter, along with profiling and testing adapters to create rich bugs.  But why stop there?  These adapters can be used to collect more data, or use up valuable resources while the test is running.

This feature is extensible in the following ways

·        Create your own adapter and have it initialize when the run starts

·        You can start monitoring or gathering data when the test starts

·        Send data back to the client when the test ends or when a bug is filed

There are several partner opportunities related to this feature are

·        Integrated your product into the system so that data is gathered during testing

·        Provide additional valuable data that will help developers pinpoint testing holes or product issues with minimal additional effort on the part of the testing team.


Microsoft Visual Studio Team Test 2010 Essentials

Visual Studio Team Test 2010 Essentials allows you to can easily define your testing effort for a specific iteration in your project, run manual tests and measure your progress .  You can create test plans, test suites, test configurations and test cases to define the testing required. You can then create manual test cases that contain individual test steps .  Each test step includes an action to perform and can specify an expected result. You can run these tests and mark each step as passed or failed as you perform the actions on your application under test.  You can also create shared steps that are common to multiple test cases, in order to reduce the time required to create test steps, as well as the ongoing maintenance costs.

Visual Studio Team Test 2010 Essentials also supports “Record and Playback for applications that support the MSAA (Microsoft Accessibility API) and UIA  (User interface API)  APIs.  You can create recordings of actions you perform for a manual test case. You can play back this recording to quickly re-run steps in a test to verify a bug has been fixed. VSIP partners (particularly component vendors) should ensure they support the MSAA (Microsoft Accessibility API) and UIA  (User interface API)  APIs so customers can use this feature.

Visual Studio Team Test 2010 Essentials can collect diagnostic data on the impact on your system when testing and easily add collected data to a bug.  When you run a manual test with Test Runner, you can now make a video recording of the test case, and record the actions to a log file. You can add comments, and files such as screenshots while you run the test. In addition, for tests on applications which are in virtual environments, you can take snapshots of the environment and attach them to the bug.

For all types of tests you can also collect diagnostic trace data, code coverage data, or test impact analysis data. You can have your computer emulate a specific network, or you can create your own custom data diagnostic adapter.

If a test fails, you can create a bug using Test Runner. This bug is automatically populated with the data that you collected, so that a developer can find all the information that is required to fix the bug.

You can now group your automated tests using test categories, which are more flexible than test lists.

There are several partner opportunities related to this feature are

·        Data Diagnostic Adapters: You might want to create your own diagnostic data adapter to collect data when you run a test, or you might want to impact the system as part of your test. For example, you might want to collect log files that are created by your application under test and attach them to your test results, or you might want to run your tests when there is limited disk space left on your computer. Using APIs provided within Microsoft Visual Studio Team System 2010 Test you can write code to perform tasks at specific points in your test run. For example, you can perform tasks before you start to run your tests, after your tests are complete, before each individual test is run, or after each individual test is run. For more information see

·        Extensibility for Running Tests:  Customize How You Run Unit Tests.  You can now programmatically start new test runs, or get events when test results are generated or when a test run starts or finishes. For example, you can then use this to create your own customized program to replace mstest.exe or build a stand-alone Windows-based application for Team System Test tests. For more information see

·        Extending Record and Playback to additional UI platforms and components.


Microsoft Visual Studio Team Test 2010 Test Load Agent


VS2010 introduces  “Extensible  Data Collectors”  which allow partners to add collectors to support other platforms, application types or to allow collection of extra data not collected by the out of the box collectors.

VS 2010 also introduces new “Load Test Visualization”  tools to provide better visualization of the output and results of Load Tests.

The new Visual Studio Test Design-time extensibility points allow partners to add functionality to the design time experience for web tests and load tests in Visual Studio Team Test.  


Microsoft Visual Studio Team Lab Management 2010

Microsoft Visual Studio Team System 2010 Lab Management is an integrated solution that helps you leverage all the benefits of virtualization for application lifecycle management. Using Lab Management, you can quickly create virtual test environments, deploy applications on them using VSTS Team Build workflow, test applications in production-like environments and file rich bugs which can help minimize “No-repro” bugs.

Creating and managing environments for multi-tier applications is an error prone task today. Replicating the same environment at the same or another site is even a bigger problem. Lab Management surfaces environments as a first class entity. Using Lab Management, you can easily create and manage virtual or physical environments that define the set of roles required to run a specific application and the computers that will be used for each role. With a single mouse click, you can start, stop, save, take snapshot or delete a virtual environment. Since environment brings with it a ‘strong’ group notion, these operations are applied to all the virtual machines that are part of that environment. You can save a copy of the environment and share it with another person next door or across the ocean. These environments, created from virtual machine templates and customized to more closely match the target production environment, reduce the time that you have to spend on setting up the tests and increase the time that you have available to do the testing.


Using Lab Environment Viewer, you can easily interact with all the virtual machines in an environment, without having to remember individual computer names or having to juggle through multiple remote desktop sessions.

The tester developer ping-pong that involves developers repeatedly trying to replicate bugs and test environments is expensive and inefficient. The new Visual Studio Team System 2010 Lab Management aims to minimize this with the introduction of environment snapshots. In addition to video logs, action logs, event logs, system information and historical logs that other VSTS tools provide, now with a single mouse click, you can attach a link to Lab Environment snapshot to a bug for hard-to-reproduce bugs. Clicking on the environment snapshot gives developer direct access to the same environment, in the same state, that the tester used for filing the bug. Each person’s control is maintained and demarcation boundaries respected by network isolation which enables you to run multiple copies of the environment without computer name conflicts. Network isolation can also be used to create multiple copies a test environment to parallelize testing and reduce the testing cycle time.

You can use the VSTS Team Build Workflow capabilities to automatically provision a new environment or restore an existing environment to a ‘clean’ baseline, deploy new builds of your application to it and then run verification tests. This helps you automate the build-deploy-test process and significantly improve the productivity of the whole team.


This feature is extensible in the following ways

·        Creation of WorkFlow Activities

·        Creation of custom deployment templates for commonly used applications

There are several partner opportunities related to this feature are

·        Integration with 3rd party testing tools

·        Lab capacity planning, utilization and monitoring

·        Virtual machine lifecycle management

For More information see



Terry Clancy