Visual Studio, VSIP Partners and more ...... : 2010

Going to Oracle Open World !!

terrycl — Wed, 07 Oct 2009 23:05:00 GMT

I will be spending Mon-Thurs next week at Oracle Open World :-)

I will be in booth 3701 with Quest Software presenting TeamFuze. We will demonstrate how Quest’s new product, Project Fuze, will “fuse” Oracle developers into Microsoft Visual Studio Team System 2010, giving them a complete application lifecycle management solution. TeamFuse is a Oracle database schema provider for Visual Studio 2010. Attendees can meet with Quest and Microsoft staff at the booth, and register to win exciting giveaways, including two Xboxes. So if you are there drop in and say hi and learn more about using Visual Studio 2010 to manage your Oracle Databases.

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

terrycl — Wed, 20 May 2009 19:04:00 GMT

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 msdn.microsoft.com and the Microsoft Blogs at http://blogs.msdn.com/search/ 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: http://blogs.msdn.com/jimlamb/archive/2009/01/06/tfs-2008-hp-quality-center-connector-december-pre-release.aspx 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 http://blogs.msdn.com/mitrik/default.aspx .

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 (http://visualstudiogallery.com/).

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.

http://blogs.msdn.com/fxcop/

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 http://blogs.msdn.com/VSTSQualityTools/

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

Profiling

· 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 http://blogs.msdn.com/vstsdb/

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: http://www.codeplex.com/AccCheck

§ UIAVerify: http://www.codeplex.com/UIAutomationVerify

· 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 http://msdn.microsoft.com/en-us/library/dd286727(VS.100).aspx

· 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 http://msdn.microsoft.com/en-us/library/dd470573(VS.100).aspx

· 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 3^rd party testing tools

· Lab capacity planning, utilization and monitoring

· Virtual machine lifecycle management

For More information see

http://blogs.msdn.com/lab_management/

http://blogs.msdn.com/somasegar/archive/2008/12/12/lab-management-in-vsts-2010.aspx

http://msdn.microsoft.com/en-us/teamsystem/default.aspx

Terry Clancy

Visual Studio 2010 New Features, Extensibility Points and Partner Opportunities

terrycl — Wed, 20 May 2009 01:43:00 GMT

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. Today (below) I will cover new features and extensibility points of Visual Studio 2010. 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 Visual Studio (VS) 2010. As I already mentioned, it does not include new Visual Studio Team System (VSTS) or Team Foundation Server (TFS) features – these will be covered in a separate document due soon. 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.

You can download the beta here.

General Visual Studio Information here

More Visual Studio 2010 information here

Jason Zanders Blog on Visual Studio 2010 here

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.

Visual Studio 2010 New Features, Extensibility Points and Partner Opportunities

New Code Editor and MEF

Visual Studio (VS) 2010 introduces a new Editor composed of extensible objects using the Microsoft Extensibility Framework (MEF). It is built on WPF to provide a 1st-class graphics engine with APIs written & designed for the latest version of .NET. This time around we are documenting APIs as part of our development process to improve documentation and help. We are also focused on delivering improved data structures and algorithms. Immutable Text Snapshots allow access to stable version of text buffer from any thread.

The new editor represents one of the first Visual Studio components to move to a managed code, MEF architecture. Other components moving to this architecture in VS2010 include the Visual Studio Languages, Web Tools, the Debugger, the new C++ project system, DSL Tools, and SharePoint Designer. Each of these components are using or offering MEF extension points. The editor represents Visual Studio’s largest investment in a MEF architecture. These moves to managed code and MEF will be followed by others as much of Visual Studio moves to this new architectural foundation in following versions.

Shims will provide 80+ percent compatibility to minimize the work for partners migrating code to the new editor. However where possible partners should update their code to use the new managed editor interfaces for the VS2010 editor. This will result in better performance and simpler code that is easier to understand and maintain. It will also migrate to the follow-on version of Visual Studio with less problems because we will be deprecating the shims in the next version after VS2010.

Partners should also consider using MEF for their own extensibility requirements in their own .NET based applications, that is, other applications have nothing to do with Visual Studio.

WPF and the New Visual Studio UI

VS 2010 incorporates a new WPF-based presentation layer and many core UI assets have been migrated to WPF, for example the menus and toolbars, code editor, start page, etc. VS 2010 also incorporates a fresh new theme that will provide a pleasant and favorable work environment for developers. Although not required for compatibility, VSIP partners should consider utilizing WPF for new UI, and in planning updates to their existing extensions, consider migrating UI to WPF. VS 2010 makes it easy to integrate WPF UI with the VS WPF visual tree through the use of new VS window hosting interfaces, and in doing so, inherit VS 2010 theme styling. For partners with unmanaged extensions, the cost of adding new WPF UI to existing packages can be significantly reduced through the use of the new GelFx framework. When using WPF in Visual Studio extensions please review the VS2010 IDE WPF Style Guidelines which are being added to the Visual Studio SDK documentation, to ensure a consistent user experience for Visual Studio developers.

VS2010 Shell

The Visual Studio Shell enables developers to rapidly create and distribute their own custom tools by building them on top of the core Visual Studio IDE. There are two shell “modes” and both are available via a royalty-free license.

The Visual Studio Shell (Integrated Mode) enables developers to distribute a copy of Visual Studio containing only their tools. If Visual studio is then installed, these tools will be integrated with the rest of the installed Visual Studio components. An example of a Visual Studio Shell (Integrated Mode) application is the Visual Studio Team Foundation Client, which enables non-developers to query TFS work items, and vertically integrates with any VS SKU to allow developers to do the same. The VS Shell (Integrated Mode) has proven to be popular with language developers as it allows them to ship a standalone tool but at the same time if used with Visual Studio Professional it allows their language to appear alongside C# and VB in the single instance of the Visual Studio IDE.

The VS Shell (Isolated Mode) allows developers to distribute tools and applications built on the VS IDE, but run as a separately branded and customized application on the user’s machine. This can be ideal for applications targeting non-developers as it allows you to control and simplify the User Interface. An example of a Visual Studio Shell (Isolated Mode) application is the AddOn Studio for World of Warcraft. The VS Shell (Isolated Mode) is gaining adoption in vertical markets such as manufacturing and IT Operations.

Since the underlying package formats are the same, components developed for one shell mode can be deployed to the other.

For the Visual Studio 2010 Shell, we’ve made targeted investments to the developer experience:

· No more complicated load keys! - Developers are no longer required to procure a Package Load Key (PLK) or a Shell Load Key (SLK) to develop Visual Studio 2010 Shell applications!

· No requirement for Registry. Packages can now be installed without requiring developers to update configuration settings in the Windows registry. In many cases, this means that packages can now be x-copy deployed.

· Easier, more robust deployment – The redistributable shell installers have been updated to support Windows Installer source caching features, thus is during a repair, user’s won’t be required to point MSI to the original installation file or media.

· Improved SDK tooling – New templates have been added to make it easier to get started with the Visual Studio Shell, and create common types of extensions. For Visual Studio Shell (Isolated Mode) developers, we’ve significantly improved performance of our F5 Debugging experience.

Additionally, all enhancements to core Visual Studio 2010 components are included with the Visual Studio Shell. Developers using the VS 2010 shell will have access to the new WPF Shell, the New Code Editor with Updated Intellisense, all new Debugger and Web features, and a New Help Infrastructure optimized for search and deployment.

Visual Studio Help

Visual Studio 10 will come with a completely re-engineered Help system that introduces a new flexible, standards based Help framework which will ultimately be used in other products beyond Visual Studio. Help3 is a help system replacement for Microsoft Help 2.x . This new help system will be easier to produce content for, and will interfere less with Visual Studio itself. The standards based approach delivers not only a much better local experience but also a seamless transition to an online web browser and with infrastructure and tooling much more consistent other Visual Studio and internet technologies.

Visual Studio 2008 and prior versions use a proprietary help system in which content was normally packaged into .hxs or .chm file formats. With VS2010 these formats will go away and moving forward help content will be stored primarily XHTML, will be packaged into Zip-format containers. These containers will be based on the PKZip format. These containers can conceivably hold any type of content, from HTML to XML, from art to videos. The containers will have a special file extension (.mshcc – Microsoft Help Content Container). Specific XML tags are used to control the behavior of the Help system. For example special tags are used to define “Contents” hierarchy and “Index” listings and “F1” help behavior. Viewers will access a specific topic through a URI provider using a standards protocol being defined for the purpose.

The primary Visual Studio 2010 help viewer will be a web browser (for either local or remote use). At some stage third party viewers applications will also be supported but this may not be a supported scenario in the VS2010 release.

The new help system uses a custom full text search engine to index the VS (and partners’) help content providing a best of breed search speed and experience

The new storage architecture enables many new rich scenarios. For example, VSIP partners can now add new containers of content to designated locations and have those tied to product content through the properties. Partner pages can be created as children of pages that are part of the standard Visual Studio help, thus they would then appear in the Help content tree under the standard Visual Studio pages.

The main implication for partners that extend Visual Studio is the need to migrate any help documentation and content to the work with the new Visual Studio help. Microsoft is working with Help Authoring product companies such as Component One (Doc2Help) and Innovasys (Help Studio) to work towards their support of this new format as soon as possible.

In the first version of this new help system, all APIs will be marked as internal and thus they can not be uses as extensibility points. In later versions of this software we plan to mark specific APIs as external to expose then as extensibility points for partners.

VS2010 Extension Manager

The VS2010 Extension Manager enables developers to more easily share, acquire and manage Visual Studio Extensions. It will support extensions such as Project Templates, Item Templates, VS Packages, Managed Extensibility Framework (MEF) components, and even custom extension types . Users will be able to use new features inside the VS IDE to browse, download and install content from the Visual Studio Gallery. Once installed, extensions can also be managed from within Visual Studio (view, enable/disable and uninstall). The extension manager will display the same content and extensions as the Visual Studio Gallery ( www.visulalstudiogallery.com ) which will continue to provide browser access as an alternative to view and download VS extensions . The VS2010 Extension Manager also introduces a new file format for deployment of VS extensions. VSIX files are based on the Open Packaging Convention (OPC) Zip format and contain a manifest and payload. At install time, the contents are then automatically XCopy deployed respecting the folder structure inside the zip file. The Extension Manager and VSIX deployment model represent significant opportunities for VSIP Partners as it makes extensions much easier for partners to package into a single file for hosting, and provides an in product experience for customers to find and acquire extensions. For Visual Studio users, it provides a single point for finding, downloading, installing and managing extensions.

Web Tools

Visual Studio 2010 includes an array of new functionality for Web developers which include support for new features now available in the 4.0 framework. The most notable improvements to date are all listed in the following document: What's new in FX4.0 and VS10.

VSIP and component developers should be aware of the multi-targeting model within the IDE, and be aware of the ASP.NET and project compilation model for both Web Sites and Web Applications. For example, controls and their associated designers operating in the IDE are always the latest (>4.0) regardless of the target framework. This means that such components need to be target-aware and perform operations based on the ‘filtered’ types, but also be aware of the target where behavioral differences in the components’ developer experience needs to be accounted for, for example smart-tag operations or dialogs that result in features only applicable for a given target. Similarly, the compilation system uses a model to determine the target based on the prescience of a target framework moniker in Web.config, but uses a mechanism to read specific sections of the relevant root Web.config for the given target.

ASP.NET components that target FX3.5 and therefore VS2008 should work without modification, but developers should note specifics related to other production targets such as Windows Azure. As of March 2009, the Windows Azure Tools extend VS2008. Future releases of the Windows Azure Tools will support VS2010. Windows Azure currently only supports running managed assemblies that work on the 3.5 framework. If you are producing components for FX4 only, you should note that Windows Azure, at this time, is not a supported platform.

Windows Azure supports ASP.NET and uses IIS; however, there are some differences for a developer writing Cloud Services than for a developer targeting ASP.NET/IIS on a Windows Server. In particular:

· Windows Azure provides a specific logging API that should be used

· Windows Azure applications and services can preserve user and session state in each instance; to increase the scale of the application, additional Windows Azure instances can be created from the online management portal. State can be shared across all instances. Please refer to the sample Role, Membership and Session providers in the Windows Azure SDK. These providers require configuration in the application.

· Cloud storage do not provide native SQL support so any VSIP component relying on SQL, LINQ to SQL or SQLDataSource may need to be updated. SQL server functionality accessible from Windows Azure was announced at Mix ’09 and will be available in the future.

Please note that it is strongly recommended that partners do not release separate components for Azure but that they produce components that can deploy to either .NET or Azure. Microsoft wants the developer experience to be as seamless as possible as developers move applications between .NET on Windows and Azure.

Web Deployment and Web Packaging

Today, deploying a web application is not as easy as it should be. Whether you are deploying your web to a shared hosting environment and paying monthly to maintain it OR whether you have a web server/s managed by your enterprise, there are a lot of manual steps involved in getting your application from point A to point B.

If you are deploying your web application to a shared hoster then today you have to use technologies like FTP which take a long time to get your web content to the hosted server. After deploying your content you have to manually go to hoster control panel and install your database by running sql scripts and configure various IIS settings like marking a folder as an application to isolate it from the rest of the application.

If you are in an enterprise environment and you want to get a web application deployed you have to systematically document each step that your server admins and DBAs have to perform. In most circumstances you also have to ask your admins to modify the web.config files and go to IIS Manager and configure your settings apart from deploying your web content. Your DBA has to do the necessary steps of running the SQL scripts in the right order to get your DB up and running. Such installations many a times take hours to complete.

With Visual Studio 2010 and IIS Web Deployment Tool (MsDeploy.exe) we are introducing a set of technologies which can seamlessly deploy your applications taking care of the problems stated above. Microsoft Web Deployment Tool is a free download available on the web (currently in Beta2). You can download MSDeploy from below location:

http://blogs.iis.net/msdeploy/archive/2008/10/29/the-web-deployment-tool-beta-2-is-now-available.aspx

Do note that installing Visual Studio 2010 will automatically install MSDeploy for you.

Web Deployment feature sets in VS 2010 can be broken down into following major areas:

1. Web Packaging - VS 2010 uses MSDeploy to create a .zip file for your application which we call as a web package. This file contains meta data + the below artifacts

a. All of your IIS Settings (e.g. application pools, error pages etc)

b. Web Content (e.g. .aspx, .ascx, .js, images etc)

c. SQL Server DB

d. Various other artifacts like Security Certs, GAC Components, Registry etc

2. A web package can then be taken to any server and installed either via IIS Manager UI Wizard or even via command line or API for automated deployment scenarios.

3. Web.Config Transformation – With VS 2010 web deployment we are introducing XML Document Transform (XDT) which will allow you to transform your development time web.config file to production/deployment time web.config file. The transformation is controlled by web.config TRANSFORM files named web.debug.config, web.release.config etc. The naming of these files is tied to the MSBuild configuration you are trying to deploy. The transform file will need just the changes that you really want to make to your deployed web.config… You can control the type of changes by instructing the XDT engine using simple and easy to understand syntax…

e.g. the below syntax in web.release.config will replace the connectionString section with new values in the web.config file which is produced for deployment of your release configuration:

</connectionStrings>

4. DB Deployment – VS 2010 allows you to deploy your application along with all of its dependencies including database dependencies on SQL Server. Just by providing the connection string of your source database VS10 will automatically script its data/schema and package it for deployment. VS will also allow you to provide custom .sql scripts and also sequence them correctly to run on the server. Once your DB is packaged along with your IIS Settings and web content you can choose to deploy it to any server by providing the connection string at the install time.

5. 1-Click Publish - VS 2010 will allow you to not only package your web applications with all of its dependencies but also use IIS remote management service to publish the application to remote server. VS 2010 will now allow you to create a publish profile of your hoster account or of various testing servers and save your credentials securely so that going forward you can deploy to any of these publish profiles with just one click using Web One Click toolbar. With VS 10 you will also be able to publish using MsBuild command line so that you can configure your team build environment to include publishing in continuous integration model.

Silverlight and WPF Tools

The WPF Designer extensibility API will be changing in VS 2010 to accommodate both WPF and Silverlight. We will publish more details of these changes when we ship Beta1. In the meantime the VS2010 extensibility highlights are:

· A full extensibility model for both WPF and Silverlight designers

· A much broader shared extensibility model with Blend 3 - Menu Actions, Adorners and so on are now available in both products - see Unni's blog for a peek http://blogs.msdn.com/unnir/archive/2009/03/27/a-sample-that-shows-the-new-blend-design-surface-extensibility.aspx

· Richer property browser API including access to the EditingContext and Model from property editors

· The ability to share design time across the WPF and Silverlight

· Support for side-by-side VS 2008 and VS 2010 design time assemblies

SharePoint Integration

Visual Studio 2010 introduces new SharePoint tools in an effort to make SharePoint development easier and more intuitive for .NET developers. These tools include new project and item templates you can use to create SharePoint sites, lists, document libraries, workflows and other types of SharePoint content. Visual Studio 2010 also provides new visual designers for Web Parts, application pages, business data catalog (BDC) models, and packaging. In addition, in Visual Studio 2010 you can now use Server Explorer to connect to your SharePoint sites and navigate the hierarchy and contents of these sites from within Visual Studio.

Although these projects and tools meet the requirements of many application development scenarios, you might discover some cases where different or new functionality is needed. In these cases, you can adapt the SharePoint project, templates and tools by using a new Visual Studio extensibility API. This API lets you create new types of SharePoint project items that application developers can use to build SharePoint solutions. It also allows you to extend existing SharePoint project items as well as enhance project deployment. Finally, you can use the extensibility API to add or extend content nodes for SharePoint sites in Server Explorer.

Visual Studio Multi Targeting

In Visual Studio 2010, we’ve extended Multi-Targeting beyond the limited support found in Visual Studio 2008 with two key goals in mind. First, we sought to enable end user developers to leverage the new features found in Visual Studio 2010 to write code for their existing applications. This means that we fully support existing .NET Framework 2.0, 3.0 and 3.5 assets in Visual Studio 2010 with a high degree of fidelity. Second, we sought to decouple Visual Studio 2010 from its target frameworks so that Microsoft can ship new frameworks, framework profiles, and framework service packs without patching Visual Studio. This means that Visual Studio 2010 uses the same data driven mechanisms to light up IDE features for versions of Silverlight, the .NET framework, and other “.NET like” frameworks. For adding entirely new platforms to Visual Studio 2010, see Platform Extensibility and the new C++ Project System.

For Visual Studio Industry Partner (VSIP) program members this implies several key changes to the way you work with target frameworks in the Visual Studio 2010 IDE. First and foremost, you can no longer assume the VS2010 IDE supports a fixed set of frameworks; depending on the installed frameworks the user can have 1 to n targetable frameworks installed. The IDE provides framework enumeration mechanisms to help packages stay on top of this. Second, the term framework no longer implies the .NET Framework. With support for other related framework families such as Silverlight, or the .NET Compact Framework, via the same mechanisms, the assumption that you are working with the full, desktop, .NET Framework at all times must go away as well. To that end we are deprecating the TargetFrameworkVersion project system property and replacing it with the Target Framework Moniker, a three component identifier that includes framework identifier, version, and profile. Third, we’ve introduced the concept of “framework profiles” a mechanism that allows for arbitrary reductions in the type surface area of a given full framework. For more information on working with profiles see the Multi-Targeting Problems and Solutions document.

To help deal with this new more dynamic Multi-Targeting experience Visual Studio 2010 now provides services to assist in providing the correct target framework appearance at all times. For designer authors we’ve added type filtering services that allow you to use the data driven mechanisms to filter the appearance of the running framework so that it appears to be the users target framework. For language vendors we have similar data driven mechanisms to provide compilers with the correct set of assemblies during compilation and IntelliSense production. For those who develop code understanding tools a hybrid of these mechanisms will work best depending on the scenario. We look forward to working with you all to make Visual Studio 2010 the best Visual Studio release ever. With the right diligence we can make supporting new frameworks in your products as simple as dropping a few files on disk rather than a major servicing event.

Visual C++ Project/Build Extensibility

In Visual Studio 2010, the Visual C++ Build System will be based on MSBuild. On top of this build system, the new Common Project System ships for the first time with support for C++ only. The current plan is that the Common Project System will be used by the other VS languages in future versions of Visual Studio. One of the big advantages of moving to these new platforms is the ability to provide new compelling extensibility points on which VSIP partners can build their Project & Build related tools. An overview of these changes is available here: http://blogs.msdn.com/vcblog/archive/2008/11/20/printf-hello-msbuild-n.aspx

Adding a new tool to the build has never been easier. As a build tool developer you can choose:

· Which build features you want to support and which to delegate to MSBuild components:

o Task implementation: You can implement your own task or rely on the XAML Task Factory functionality to create a task on the fly based on your XAML definition (Custom Build Rule).

o Incremental build support: You can delegate to FileTracker to keep track of your tool's inputs and outputs in order to honor incremental builds.

o Clean operations: Customize clean operations if you are creating intermediate files during build.

· What level of Project System's Property Pages support you want:

o Basic support: A simple XAML file similar in format with the Custom Build Rules file format will be enough to show a property grid similar to the C++ or Linker nodes.

o Customized Property Grid: Simple MEF components allow extenders to provide custom Property Editors (i.e. Certificate picker, directory list editor, etc.) or custom Property Dropdown providers (i.e. a dynamic list of servers or a valid list of files considering other project settings). More details about MEF available here: http://code.msdn.microsoft.com/mef

o Custom UI: Combining a XAML definition and a MEF component, you can replace the property grid with your custom UI.

· How you want to deploy your tool: central location (under Program Files) or enlistment based (checked in with the rest of the client's sources), or both.

Partner Opportunities in this area revolve around the possibility of marketing new Build related tools. Examples of this may include code generators, code analysis, language compilers, versioning or signing tools.

Visual C++ Platform Extensibility

One of the Visual C++ Project System extensibility points is the ability to add additional Platforms to the build system. This would allow developers for example to use the new Visual C++ Project System to target Mobile platforms running an Embedded operating systems. Platform extenders can provide their own customizations to the build system and wire new tools or replace existing ones as part of their platform specific targets. For more information about adding/replacing tools in the build see the Project/Build Extensibility topic above.

Once a new platform is installed, the Project System will light up to the changes allowing developers to add the new platform to their projects using the Configuration Manager, configure its settings in the Property Pages or Property Manager, build and debug.

A significant partner opportunity exists in providing tools for VS2010 to enable targeting of other popular platforms.

Further platform customizations are supported:

o individual tool customizations as detailed in the Project/Build Extensibility topic,

o new custom Debuggers or new Deployment tools the user can pick, configure and run.

Visual C++ Native Multi-targeting

Visual C++ 2010 ships with a lot of enhancements in the compiler and native libraries (i.e. C++0x support, a new Concurrency Runtime, Vista/Windows 7 support in MFC, etc.) but sometimes adopting the new IDE together with the new libraries can be a problem for developers because a lot of the 3rd party components being used may still be built against VC9 runtime. To ease adoption, VC++ 2010 supports Native Multi-targeting for all the PC platforms (x86, X64 and Itanium).

This enables developers to move to the latest IDE while still targeting the Visual C++ 9 tools and libraries that shipped with Visual Studio 2008 (this requires VS2008 to be installed on the machine). Out of the box, only VS2008 will be supported, but this is an extensibility point that can allow future additions (i.e. to support older versions of Visual C++, or future versions of the Windows SDK). Supporting older versions of the tools and libraries may be a opportunity for partners working in that area.

Also, Native Multi-targeting is not limited to the PC platforms as the same extensibility pattern can be used by other Platform Extenders.

Native Code tools

VS 2010 will include new native C++ libraries to help develop take advantage of Vista & Windows7 innovations. Examples of those features (but not limited to) are Restart Manager & Task Dialog support as well as MFC Style implementation of the Windows Ribbon. Partners with Native Code extensions to Visual Studio may want to consider using these new facilities.

Parallel Computing Platform (PCP)

The manycore shift presents an unprecedented business opportunity for developers to design new software experiences that take advantage of the performance power of manycore architectures. At the same time, parallel programming is complex, difficult and labor-intensive, for even the most skilled developers. Microsoft’s goal is to simplify parallel programming by taking a holistic approach and providing solutions which span from local to distributed computing and from task concurrency to data parallelism.

Microsoft plans to deliver a solution-stack consisting of OS resource management, a concurrency runtime, programming models, language extensions, libraries, and tools, which will make it simpler for both native and managed code developers to safely and productively build robust, scalable and responsive applications. This will also enable industry partners to complement Microsoft’s technologies in order to solve the complex problems associated with developing high-quality parallel software.

Visual Studio® 2010 and the .NET Framework 4.0 will introduce a number of technologies as part of Microsoft’s Parallel Computing Initiative to help programmers build innovative applications that utilize the power of multi-core architectures. These include the following:

· The Concurrency Runtime will simplify development by making it easy for developers to manage the resources of the underlying hardware. It will also manage the scheduling details of mapping programming tasks to the available hardware. The Concurrency Runtime gives developers the ability to choose from a rich set of coordination mechanisms such as message passing and locks that automatically interoperate with the scheduler. Further, it provides a common framework for the interoperation of different components, so component developers are free to use the techniques and patterns that fit their problem best.

· The Parallel Pattern Library is a set of native libraries that align well with the C++ Standard Template Library (STL) and use the Concurrency Runtime to ensure the efficient and scalable use of system resources. It provides support for describing task centric work items and synchronization, for expressing structured and unstructured parallelism and for implementing speculation and transformation. It further provides a set of commonly used concurrent containers and messaging primitives for working with shared state and for coordinating state isolation via message passing. The Parallel Pattern Library also utilizes additional new support in the C Runtime Library (CRT) to ensure the proper propagation of exceptions. The Parallel Pattern Library uses a new language feature known as lambda functions, which were just approved into the C++ draft standard, to enable easier migration of sequential code to parallel implementations.

· Parallel Extensions to the .NET Framework simplifies development by providing library-based support for introducing concurrency into applications written with any .NET language, including C# and Visual Basic. It includes the Task Parallel Library (TPL), which provides support for imperative data and task parallelism; Parallel LINQ (PLINQ), which provides support for declarative data parallelism and Coordination Data Structures (CDS), which provide support for work coordination and managing shared state.

· Parallel debugging windows which will provide a view of tasks running in the application, and a graphical view of parallel call stacks.

· Parallel profiling views which will give developers an understanding of their application’s core utilization, thread behavior and contention blocking, and thread execution pattern per core.

For VSIP partners, the opportunities range from using these technologies to increase the performance of your software to providing complementary toolsets to help in the creation of parallel code.

More information is available at the MSDN Parallel Computing Development Center.

Deployment and Installation

The .NET Framework 2.0 introduced Click Once. Thus applications had two deployment options (1) Click Once (Click on a link and if you do not already have a current version of the assembly in your assembly cache, then it is downloaded. The Assembly can then run in the Browser Sandbox) or (2) MSI – standard way is installation that does not require internet connectivity.

With .NET Framework 3.5 SP1 it is possible to customize the ClickOnce application install experience and enable scenarios like packaging the ClickOnce application files in a single installer along with the .NET framework installation. This is especially useful with the “Client Profile” of the .NET framework which is a smaller subset (approx 27 MB) of the full framework that provides the fastest framework install experience for client applications. An application that has been installed with a customized installer behaves just like any other ClickOnce application and keeps itself up-to-date by downloading new versions of the application assemblies as they become available. Through the custom installer the developer can control every aspect of the ClickOnce Install and Update experience like the trust prompts and downloading of updates.

Cloud Tools

As of March 2009, the Windows Azure Tools extend VS2008. Future releases of the Windows Azure Tools will support VS2010. We are working to make VS 2010 the premiere development tooling for creating and deploying Windows Azure applications. Windows Azure currently only supports running managed assemblies that work on the 3.5 framework. If you are producing components for FX4 only, you should note that Windows Azure, at this time, is not a supported platform.

Windows Azure Tools for Microsoft Visual Studio includes project templates, configuration of the Service Model, integration with the Windows Azure local development tools, debugging, and publishing.

Windows Azure Cloud Services consist of a Web and/or Worker Role. A Web Role has http and/or https endpoints and can make outbound calls to the internet. A Worker Role can run managed code in a background process including making outbound calls to the internet. A Worker Role does cannot have any endpoints. By default, all Windows Azure Roles run in Windows Azure Trust, which is a slightly modified version of the ASP.NET Medium Trust. Each role can be configured to run in Full Trust. The instances of each Role can be increased or decreased independently and easily to increase or decrease the capacity of the Cloud Service.

ASP.NET components should work without modification with VS2010 and .NET 4.0. It is recommended that ASP.NET Component Vendors update components to work not only on .NET 4.0 on Windows but also on Windows Azure. Please note that it is strongly recommended that partners do not release separate components for Windows Azure but that they produce components that can deploy to either .NET or Windows Azure. This is because Microsoft wants the developer experience to be as seamless as possible as developers move applications between .NET on Windows and Windows Azure.

Third party managed languages should work on Windows Azure. To allow Visual Studio 2010 to deploy applications using third party applications correctly partners will need to have separate projects for each of the Windows Azure Web or Worker Roles and some integration work with the Windows Azure Tools is required.

Partners that deliver coding productivity features could consider a number of possible new features targeting Azure. They could add code snippets or other forms of code generation targeting Windows Azure, or produce more complete or targeted Visual Studio Project templates targeting particular Scenarios.

Other partners may want to consider other value added solutions to provide High Performance Computing, Backup, or Storage solutions on this platform. There may also be a market for Development Tools that plug in to Visual Studio to ease cloud based development. Finally there will be a broader opportunity for complete applications targeting the Microsoft Cloud platform.

Enhanced version of Dotfuscator Community Edition™

Microsoft Visual Studio 2010 also contains an enhanced version of Dotfuscator Community Edition™ (CE). Dotfuscator CE, which has been included with every version of Visual Studio starting with Visual Studio 2003, prevents the reverse engineering of .NET applications. The Visual Studio 2010 version, renamed Dotfuscator Software Services Community Edition™, has been extended with instrumentation capabilities including tamper detection and defense, feature level application monitoring and automatic time limits on .NET application use.

Specific new features include:

· The injection of feature and session monitoring (streaming usage data to a developer-specified endpoint),

· The injection of application expiry dates, and

· The injection of tamper defense and notification.

If you want a detailed walk through, check out Bill Leach’s blog entry at http://blogs.preemptive.com/post/Whate28099s-new-with-Dotfuscator-in-Visual-Studio-2010-Beta-1.aspx

There are opportunities for partners to

· Provide cloud-based services around these capabilities

· Launch their own customer experience improvement programs

· Build BPM and BI solutions driven in part by application runtime intelligence

· Monitor customer usage of their own product features

Terry Clancy