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

Extensibility Series – WPF & Silverlight Design-Time Code Sharing

terrycl — Tue, 24 Nov 2009 20:55:00 GMT

There is plenty of new functionality in VS 2010 but not nearly as much information on extending it. Karl Shifflett published a two part series on creating design times for Silverlight & WPF controls in 2010. Take a look: http://karlshifflett.wordpress.com/2009/11/20/extensibility-series-wpf-silverlight-design-time-code-sharing-part-i/

Visual Studio 2010 Test Tools - Partner Integration Opportunities

terrycl — Wed, 18 Nov 2009 06:56:00 GMT

With the recent announcements and availability of Visual Studio 2010 and .NET Framework 4 Beta 2 much attention is now focused on both the testing features and capabilities offered in the new range of products. With all these new features and capabilities come many new partner opportunities. I have prepared this paper to help partners understand, at a high level, the new VS 2010 testing features , and the associated partner opportunities and to dive deeper in this area than I did in my previous blog here.

For other information about Visual Studio 2010 and .NET Framework 4 visit the Microsoft Visual Studio 2010 and .NET Framework 4 Beta site to download the Beta, submit feedback, access forums, etc. On Twitter search for hashtags #VisualStudio and #VS2010

1. Background and Context

a. The Visual Studio Test vision

b. Visual Studio Ultimate 2010 and Team Foundation Server 2010

i. What is new in 2010

ii. The Visual Studio Ultimate Test framework

2. Extending Visual Studio Ultimate Test components

a. Third Party Integration Guidance

i. Supporting support Coded UI Tests and Record and Playback on third party technologies

ii. Integrate third party test tools and/or cross platform environments with the Visual Studio 2010 Test Tools

iii. Integration with Custom Diagnostics

iv. Migration and Synchronization or test data between ALM systems

v. Training and Test Methodologies

3. Summary & Next Steps

4. More Information

Background and Context

The Visual Studio Test Vision

The Visual Studio vision for Test is to provide great development tools, tightly integrated with great testing tools so customers can produce great software. VS2010 delivers tools that bring new insight, information and opportunities to software testers providing increased empowerment to contribute more fundamentally to software quality.

The Visual Studio Test vision is part of a broader vision to manage the full software development lifecycle in one place:

There is a degree of consistency in customer feedback around testing and software development:

• “My testers are spending too long testing the same thing”

• “Tooling is too complex and too expensive (time, licenses, people)”

• “It is expensive to maintain separate test teams for different platforms and technologies”

• “The developers say the reported defects are useless”

• “It is difficult to know when software is ready to ship”

• “Developers and testers work in silos and don’t communicate/speak the same language”

• “When requirements or software is changed it is difficult to know what needs to be tested”

Visual Studio (VS) 2010 intends to address these issues and more. VS2010 will deliver test software that simply works, for both the developer and the tester. The testing tools of VS2010 are designed to simplify testing and to remove obstacles between testers and developers with VS2010’s shared test management software, work items, historical debug, and screen capture. These changes can largely remove the “no repro” problem and provide a much higher fidelity of bug data back to developers to allow them to expedite fixes.

The extensibility of VS2010 Test tools will open the opportunity for partners to bring these benefits to the broader audience of X Platform users and to support test scenarios not otherwise supported by MSFT. These scenarios include testing of migrated Cobol, CICS and other host applications, LOB application testing for systems such as SAP and Oracle financials, J2EE, Java and Linux testing and certain types of functional tests. It is also possible to extend VS2010 Test tools to support other third party test tools to offer protection of customer’s investments in tests written for those tools or to allow those tools to be used in situations where MSFT test tools are not currently an option.

With these integrations customers will have a compelling option available. One well architected test infrastructure to assist both testers and developers, and span across all platforms, languages and runtimes in use. This infrastructure provides unified reporting for project progress and team performance across each of the associated teams and environments. Managers, testers and developers across all platforms should realize significant benefit in moving to these tools.

VS2010 plans to democratize testing by putting powerful, approachable tools into the hands of more testers and allow them to fundamentally impact software quality. In summary VS2010:

· Aligns testing with the lifecycle

· Creates tighter dev/test interaction

· Enables highly leveraged testing teams

· Is extensible to other platforms, applications, environments and test tools.

Partners are a key part of this vision, with the vision representing a significant opportunity for partners interested in providing X Platform, LOB testing and other specialized components. In the end customers on all platforms and systems benefit from this unified approach to Testing.

Visual Studio Ultimate 2010 and Team Foundation Server (TFS) 2010

What is new in Visual Studio 2010

Visual Studio Team System (VSTS) 2005 introduced the core Test Framework which will be carried forward into Visual Studio 2010 and Team Foundation Server 2010. With the introduction of VS 2010 and TFS 2010 many new software test capabilities are introduced, such as:

Team Test
Performance Testing	Extensible performance solution that includes hot spot identification and analysis as well as rich Excel based analysis and reporting
UI Test Automation	• UI automation framework that supports Fast Forward for Manual Testing as well as coded UI across multiple UI technologies including Web, Winform, and WPF
Manual Testing	• Lightweight, efficient tooling to support manual testing with integrated action recording as well as rich bug filing
Test Case Management	• Infrastructures to manage the testing effort and ultimately be able to answer the question “are we ready to ship?”
Test Execution	• The ability to execute tests locally and remotely, to collect detailed data during execution, enabling rich bug reporting.

Lab Management
Manage Lab Environment	Manage multi-machine environments using virtual machines, with the ability to create, store, start/shutdown full environments, reducing the need for IT personnel being involved in such operations.
Snapshot & Reproduce Environments	Ability to take snapshots of lab environments and revert to them allowing teams to collaborate effectively in identifying and resolving bugs that are hard to recreate.
Application Deployment	Ability to automatically deploy applications in the lab environment allowing teams to effectively automate build verification tests and other activities requiring application deployments
Build Integration Workflow	Ability to create work flows for the build that enables lab environments to be automatically deployed when triggered during build

The various testing components of VS 2010 are each targeted at different types of testers ranging from the Generalist to the Specialist tester as detailed in the following diagram:

These VS 2010 Test Components also shown in the following high level view of all the components that have a role in the testing process. There are three (3) client tools used to manipulate test information or to run test locally or directly. These client tools connect to TFS, which acts as the heart of the system. The build server works with Lab Management and Test Case Management in TFS to run automated tests as part of the build process.

To provide organizations with simplified ways to purchase and license core development technologies, MSFT is announcing a new packaging lineup and licensing options for MSDN and Visual Studio 2010.

This new approach to branding and packaging more closely aligns with other MSFT products that developers use every day, (including Windows and Office), which simplifies the purchasing process . The following diagram details what Debugging, Diagnostics, Testing and Lab Management features are available in each of the newly announced products:

As part of the broad VS 2010 launch Team Foundation Server (TFS) 2010 will begin to play a significant role in testing with the introduction of two key new services. These services are:

· Test Case Management Services, providing Test Case Management, Execution and Rich Integration

· Lab Management Services providing centralized control and management of Test labs comprising multiple physical and virtual test machines.

The Visual Studio 2010 Test Tools Framework

Microsoft® Visual Studio® 2010 Test Tools give you the testing tools to be more productive throughout your testing life cycle of planning, testing and progress tracking. The architecture of the VS 2010 Test Tools is built around the VS 2010 Test Tools Framework. This framework lets you create, manage, edit, and run tests, as well as obtain and store test results. Several test types, including Unit, Web, load, Coded UI and manual tests, in addition to the measurement of code coverage, are integrated into VS. VS Test tools can be extended to add new test types. The VS Test Tools Framework is the overall architecture and environment in which tests run. It consists of the following:

· Test Plans, Test Suites, Test Cases and Configurations. You can plan your testing effort for a team project by using test plans. You define your testing effort by creating any necessary test suites, test cases, or configurations. The configurations are used to determine which set ups you want to use to run test suites or test cases.

· With these items defined, you are ready for testing. Manual tests can be run from Microsoft Test and Lab Manager using the Test Runner. You can also run automated tests from Microsoft Test and Lab Manager as long as there is an automation associated with a test case. These test results will be associated with a test plan.

· In addition, automated tests unassociated with a plan can also be run from VS. Tests can be selected to run individually, as part of a check-in policy that uses test categories. They can also be run from Team Build and from the command line.

· For better integration between VS Test Tools and other parts of VS, test results should be stored into the TFS database. This enables users to easily generate trend and historical reports, compare different kinds of data, see the amount of as well as which bugs were found because of testing and more.

· Typically a Test Plan is used to define and manage your testing for a particular product.

· Test Plans consist of Test Suites which are collections of Test Cases. Test Cases are typically aimed at testing a particular feature or subsystem.

· When requirements, user stories, or features are ready to be tested, you can select a Test Plan or Test Case as appropriate and run your tests for each specified configuration. This approach enables you to target your testing and measure progress as tests are run and report the amount of testing that remains.

· “Test Cases” are stored as “Work Items” in the TFS Work Item store. VS 2010 supports many work item types and work items can be associated with each other using links. Links can also have assigned “types” including “Parent/Child,” “Tests/TestedBy,” “Related,” “Affects/AffectedBy.” Test Cases are related to other work items in VS 2010 TFS as shown in the following diagram.

· The following figure shows an example of a Test Case being edited in “Microsoft Test and Lab Manager” (which is included in Microsoft® Visual Studio® 2010 Ultimate & Microsoft® Visual Studio® Test Elements 2010):

· Test Cases are really just metadata, which point at Manual and/or Automated implementations. In the case of Manual Tests they consist of one or more Test Steps (Test Steps can be normal steps or shared steps). The following diagram shows the Test Runner of “Microsoft Test and Lab Manager” providing guidance, recording, and collecting feedback during a manual test. Note the Test Steps on the left (which indicate that three (3) Test Steps have passedand one has failed).

· Beyond Test Cases, most other test artifacts are stored as custom objects in the Test Management (TM) database store (a logical subset of the TFS SQL Server Database store). The Test Management database store includes Test Plans, Test Suites, Test Configurations, Test Steps (for manual tests), Test Results, Code coverage data, Test impact data, Run and result attachments & Test settings.

· A Test Management object model (TM OM) can be used to peruse, edit, or create TM database artifacts like Plans, Test Suites, Test Configurations, and Test Steps etc. This model is recommended in place of direct database access.

· TFS Catalog: Additional information is also stored in the TFS Catalog including Test environments and Test controllers.

· VS Test Types: VS 2010 testing tools provide several test types that can be used for specific software testing purposes. Custom Test Types can also be created to meet other testing needs. VS 2010 supports the following test types “out of the box”:

o Unit Tests

§ Unit tests give developers and testers a quick way to check for logic errors in the methods of classes in C#, Visual Basic .NET, and C++ projects. Unit tests allow the developer to assess the quality of their own code and also provide a security mechanism to reduce regressions when adding new functionality or changing existing functionality (such as when refactoring). An additional feature of Unit Tests is that they can be re-used within Load/Performance tests, providing broad, flexible support for application performance testing.

o Web Tests

§ A Web Performance test (previously simply called a Web test in VSTS 2005/2008) consists of a series of HTTP requests. Web tests work at the protocol layer by issuing HTTP requests. Web tests do not run JavaScript. However, you can simulate JavaScript actions at runtime by using Web test plug-ins, Web test request plug-ins, extraction rules, or coded Web tests. Web tests are used to test the functionality of Web applications and to test Web applications under load. Web tests are used both in performance tests and stress tests. You can create Web tests by recording your activities in a browser session. You can also build Web tests manually by using the Web Test Editor.

o Load Tests

§ The primary goal of a load test is to simulate many users accessing a server at the same time. When you add Web tests to a load test, you simulate multiple users opening simultaneous connections to a server and making multiple HTTP requests. You can set properties on load tests that broadly apply to the individual Web tests. When you add unit tests to a load test, you exercise the performance of non-Web based server components. An example application of a unit test under load is to test data access model components. Load tests can be used with a set of computers known as a Test Environment (aka Test Rig), which consists of agents and a controller.

o Coded UI Tests

§ Coded UI tests are automated tests of the user interface. These tests provide functional testing of the user interface and validation of user interface controls. Automated UI tests enable you to test to ensure the user interface is functioning correctly. They are quicker to run than manual tests thus can be run more frequently. A key advantage to these tests is that they use .Net languages (code is generated for C# and VB.Net) against a .Net API, thus organizations can use/re-use familiar skills and existing code to test their apps. This also results in the test team having interchangeable skills with the development team.

o Manual Tests

§ In VS 2005/2008 manual tests are usually in the form of a Word document, in VS2010 this format is deprecated and is replaced by the new Work Item based Test Case already discussed.

o Generic Tests

§ You use generic tests to wrap external programs and tests that were not originally developed for use in the Visual Studio Test Tools. After you have done this, the generic test is treated by the test engine as any other test type. That is, you can work with generic tests using the Visual Studio Test Tools windows. For example, you can run generic tests from the Test View window and the Test List Editor and you can obtain and publish results from generic tests as from other tests.

o Ordered Tests

§ An ordered test contains other tests that are meant to be run in a specified order. An ordered test appears as a single test in the Test List Editor and the Test View window. Its results appear in a single row in the Test Results window, but you can obtain individual results for each test that was run as a part of the ordered test.

· Custom Test Types

o In addition to using the built-in test types of VS Test Tools such as unit tests, load tests, coded UI and Web tests, developers can create and integrate custom test tools into the VS Test platform using the Test Type Extensibility Framework, the same framework that MSFT used to develop the built-in test types. The Test Type Extensibility Framework is intended for developers and testers who want to do either or both of the following:

§ Integrate existing test tools into the test environment

§ Create and integrate entirely new test tools that perform types of testing that are not supported by the built-in test types of Visual Studio Test Tools

o VS Test Tools also provide a more basic way to integrate custom test tools: the built-in generic test type. This test type lets you run any of your test tools that use a command line, and then captures and interprets the returned results. Even though generic tests serve as an efficient light-weight solution for integrating tests, they are better suited for simple tests and test harnesses that do not require more advanced extensibility features, such as a custom test editor or results viewer, and a run-configuration editor.

o A Custom Test Type is a DLL exposing two sets of APIs:

§ VSX package APIs providing UI and only used by the Visual Studio IDE

§ Test Execution APIs to provide test specific behavior and control of tests. These APIs are used by the test agent to control remote tests and the Visual Studio IDE to control local tests (thus local tests do not need a controller or agent)

o Custom Test Types can be created using VS. Custom Test Type definitions are stored in a custom “VSX” assembly. When queried for which services it provides, the assembly will return it’s test type. New Custom Test Types will show up in VS, and can be tied to Test Case work items. In turn, these can be included in test suites in “Microsoft Test and Lab Manager” and run with automated test runs, as long as the custom test type is installed on the machines where the test will be run. (Custom Test Types are installed on target test machines by copying the assembly that defines the custom test type into the PrivateAssembly folder of the install location of the agent).

o When developing Custom Test Types several levels of features can be optionally supported. If only basic test-tool integration is needed, only a small set of core extensibility areas are needed to create a simple test type that runs in the test environment. Such a test type can then be used in conjunction with all the features for managing tests, including the Test Manager, Test View, and Test Results windows. By implementing additional classes and a “VSX” package, you can add other features such as a custom test editor, integration with the run configuration dialog box, and a custom results viewer for your new test type. Detailed below are the ways in which you can integrate a new test type into the VS test environment:

§ Basic Test Management Windows. For tests that produce simple results, basic integration lets test users view, manage, and run tests.

§ Custom Editing Window and Results Viewer. For more advanced test types, you can display custom UI components for authoring tests and viewing their results.

§ Creating Tests that Run Under Load. You can also create tests that will run under a load test.

§ Adding Custom Run Configuration Settings. Your new test types can access the built-in run-configuration settings, and you can add custom run-configuration settings.

§ Custom Shortcut Menu Options. You can make special commands available for your new test type by adding them to shortcut menus.

o Note that “Microsoft Test and Lab Manager” does not use or install Test Type DLLs. It uses a lowest common denominator level of functionality (Start Stop….) achieved by communicating directly to the controller without need of the information and functions provided by Test Type DLLs

o For more information on Custom Test Types please see http://msdn.microsoft.com/en-us/library/bb166484(VS.100).aspx or search for “High-Level Test Platform Extensibility Areas” in MSDN

· UI Automation testing is a key new feature with VS Premium 2010. UI Automation Testing is supported for Winforms, and WPF applications that support the MSAA (Microsoft Accessibility API) or UIA (UI Automation API) APIs . (Web applications are also supported via MSAA and DOM manipulation). Support for Silverlight Testing will be added after the release of VS2010. Third parties can provide tools or libraries to extend applications based on other technologies (e.g. Flash and Java) and component vendors should update components to support MSAA or UIA. The following table shows currently planed platform support for UI Automation:

· A test configuration is a set of configuration variables that specify the correct setup required for testing an application. The configuration variables include hardware, operating system, software, and any other characteristics that are important to use when you run the tests. Each test configuration can represent an entry in your test matrix as shown in the following diagram:

· Test Environments, Controllers and Agents. You can set up a group of computers to run tests. The group consists of a single “Controller” and one or more agents. Collectively, this group is called an “Environment.”

o An agent is the part of the environment that is used to run tests and generate simulated load

o The Controller is a separate “service” process which the VS IDE or TFS uses to communicate with one or more Agents on remote machines. For example, in a load test the Controller might control Agents on hundreds of machines creating the load. The Controller is the part of the Test Environment (aka Test Rig) that is used to coordinate the Agents and collect the test results. TFS uses a Controller (or Controllers) to connect to Agents on virtual machines provisioned by Lab Manager in order to run, control and receive feedback from tests

o The test Environment and infrastructure are basically the same for the various test types supported:

§ Unit Tests

§ Load Tests

§ Coded UI Tests

§ Web Tests

o A test environment is not used when a test is run locally. Instead VS Test Tools use the Text Execution APIs in the Test Type DLL to control the test directly

· Test Agents. The Test Agents are responsible for:

o Test Execution and control including

§ Start

§ Stop

§ Step (Start and run to the end of the next Step)

o Data Collection and passing data back to source (to VS Test Tools or to TFS Lab Management Server). Examples of data that might be collected include:

§ Screen Capture

§ Capture of the state of variables defined in the Test Plan

§ Collection of Historical Debug information

§ Capture of application performance statistics

§ Capture of machine performance statistics

§ Capture of Network, Keyboard, Mouse, Touch Screen traffic

§ More…

o Test Agents install VS Test Types DLLs and Custom Test Types DLLs as add-ins to equip them with Test Type specific functionality. As noted above Test Agent will use the Test Execution APIs in the Test Type DLL and ignore the “VSIP” Package APIs in that DLL.

· Host Adapters

o A host is a test execution environment, an application process in which test code is executed, and in the case of unit tests, production code as well. VS Test Tools provide a default test host, VSTestHost.exe. By default, tests are executed in the VSTestHost.exe process.

o There are limitations on running tests using the default test host. For example, when you run unit tests in VSTestHost.exe, the production code is not executed in its real execution environment. Production code may not work when not running in its real execution environment. A typical example is that of unit tests for ASP.NET Web applications. The ASP.NET application code may need to access the ASP.NET context, which makes objects such as the HttpSessionState, HttpApplication, and HttpRequest available to the application code. Also, page-specific objects must be initialized properly so that application code that works with them can run without throwing exceptions. VSTestHost.exe cannot provide either the ASP.NET context or these runtime objects. VS 2010 Test Tools overcomes this problem by using an ASP.NET host adapter. You are able to run unit tests for ASP.NET Web applications in the IIS process or in an ASP.NET Development Server process

o There are other situations in which you want to execute tests in hosts other than the default test host. VS 2010 Test Tools provide the means by which you can develop your own “host adapters.” For more information please see http://msdn.microsoft.com/en-us/library/bb166558.aspx or search for “Creating and Using Host Adapters” on MSDN.

· Cross Platform Testing

o Today agents only exist for Windows. The Controller connects to the Agent on the target Test machine using proprietary .Net remoteing which only works for Windows machines. For cross platform testing Microsoft is considering the creation of a controller proxy as a separate service which may support cross platform testing by supporting platform agnostic protocols (perhaps SOAP or REST) so partners can support non windows agents. The controller proxy is still under consideration, partners interested in working with Microsoft to create Cross Platform testing tools using such a facility should contact us on vsipinfo@microsoft.com

In VS 2010, testing tools allow increased production throughout the testing life cycle of planning, testing and progress tracking. The testing tools are integrated with Team Foundation Server, allow you to define your testing based on the same team projects being used by others in your organization.

Extending Visual Studio 2010 Test Tools

Third Party Integration Guidance

The primary scenarios or areas of opportunity for partners to extend VS 2010 Test Tools are:

· Write plug-ins for Java, Flash, Components suites etc. to support Coded UI Tests and Record and Playback of tests on those platforms

· Integrate third party test tools and/or cross platform environments with the VS 2010 Test Tools. Required integration components include Custom Test Types, and Agents

· Integration with custom diagnostics & historical debugging.

· Migration and Synchronization or test data between ALM systems

· Training and Test Methodologies

Additional details below:

· Providing support Coded UI Tests / UI Automation Testing and Record and Playback of tests on various technologies. Partner opportunities include:

o Extending other environments and applications to offer U I Automation support for to un-supported platforms such as Flash, SAP, CICS, Cobol etc by providing plug-ins to expose those applications for automation

o Component Vendors should update components to support MSAA or UIA APIs and then test components to confirm that UI Automation Testing works with applications using those components

· Supporting third party, and/or cross platform test tools. For partners with existing Test Tools and in particular complementary test tools such as cross platform test tools we offer the following guidance regarding how best to integrate with VS 2010 Test Tools:

o Use VS 2010 Team Foundation Server Work Items and Test Management (TM) Database as much as possible to store information and results related to tests. To do this:

§ Third party test tools should store Test Cases as TFS work items of Type=Test Case. Work item types can be extended where the third party test software require more information to be stored than can be handled by the standard VS types. Third party tests will often contain executables and run time dependencies on the third party test environments which make “compatibility” between test environments impossible. The use of a common infrastructure for storage and management of tests simplifies the test environment and reduces training costs which can result in common processes and skill set requirements across test types and environments.

§ Third parties test tools should store artifacts like Test Plans, Test Suites, Test Configurations, Test Steps (for manual tests), Test Results , Code coverage data, Test impact data, Run and result attachments, and Test settings etc. in the Test Management (TM) Database. Partners should use the Test Management object model (TM OM) to create (peruse or edit) the TM database

§ The above Test artifacts should be used to enable the following scenario: the end user of “Microsoft Test and Lab Manager” ( included in Microsoft® Visual Studio® 2010 Ultimate & Microsoft® Visual Studio® Test Elements 2010) would be able to use it in nearly or exactly the same way to run a third party test as to run a MSFT test. This approach is designed to drive greater simplicity and standardization into the test process while lowering training costs and skill requirements.

o Support Automated Testing using VS Test. This means supporting test cases defined in VS 2010 Test Tools to be executed on third party test tools or platforms such as commercial or open source software test execution frameworks (functional testing, performance testing, security testing, etc.) and/or on other operating system platforms. This means

§ The creation of new test types for those target environments and

§ The creation of Third Party Test Agents.

§ For cross platform agents use of the planned controller proxy will be required to allow use of standard protocols (controller proxy is still under consideration)

In this way it is possible to support third party test tools to protect customers’ investments in tests written for those tools or to allow those tools to be used in situations where MSFT test tools are not an option.

o Support for Automated testing using TFS Test Case Management Services. This means providing the Third Party Test Types and Agents to deploy, run, monitor and control non MSFT Tests and/or non-Windows platforms from TFS Test Case Management Services. It is also means collecting results from those tests and storing them in the Test Management (TM) database. Third Party Test Types run as an extension to TFS Test Case Management Services

o Support for Automated testing using the VS Lab Manager Services of TFS. This means extending the VS Lab Management Services of TFS using Powershell scripts etc. to support the creation of virtual instances of other non-MSFT operating systems such Linux or operating systems configured to test certain classes of applications such as Mainframe applications, web applications, SAP applications etc. VS Lab Manager Services works in concert with Test Case Management Services to deploy and run the tests in question as well as to collect results of those tests.

o Support for specific technologies such as SOA, Cloud or, Runtime environments (such as flex, flash, Java, J2EE, CICS , Mainframe Emulation etc.) This means the creation of new and/or extension of existing test types that can provide test execution, result analysis and reporting capability for those technologies and provide the Third Party Test Types and Agents to deploy, run, monitor and control those tests

o Support for Packaged and LOB applications such as SAP, Dynamics or Oracle Financials. This should cover both load, performance and functional testing. Protocol testing such as SAP, SIP, etc. should also be considered

o Extensibility for newer domains. For example, functional testing for packaged apps, flex, flash, Java, etc. Performance testing for additional protocols such as SAP, SIP, etc.

o Data Diagnostics is a broad area of opportunity for partners and includes:

§ Ability to collect data (system, application diagnostics or other) on non-Windows environments, non-.NET environments or from third party test systems

§ Ability to extend existing data collectors to provide more functionality

§ The degree of integration and functionality of Test Agents is dependent upon design objectives but could range from

· No changes necessary to an existing Third Party Test Agent because integration is done by way of a Proxy, to

· Significant integration of the Test Agent to support things such as:

o Screen capture

o Capture of the state of variables defined in the Test Plan

o Collection of historical debug information

o Capture of application performance statistics

o Capture of machine performance statistics

o Capture of Network, Keyboard, Mouse, Touch Screen traffic

o Capture of application specific data from systems like SAP, Oracle Financials, Dynamics etc.

o More…

o There are also several opportunities in the areas of Test Planning, Process Integration and Reporting:

§ Partners can create, extend or customize TFS process templates to meet specific customer needs and to implement and enact specific testing methodologies

§ Partners should verify that standard TFS reports accurately reflect third party data stored in standard VS formats such as Test Plans, Cases, Steps etc. This includes reports such as the following:

§ Partners can customize and extend out of the box reporting to address customer needs

§ Custom reports are created using the TFS reporting tools (based on SQL Server Analysis Services, Reporting Services, Excel Services and SharePoint). Reports should offer reporting for any Custom data collected and stored on TFS work items beyond the data for which TFS provides standard report formats

· Migration and Synchronization of test data between ALM systems.

o Opportunities exist for partners to create tools that migrate test data from other test management systems to TCM/TFS

o There are also opportunities around the development of interoperability tools that allow for bi-directional sync of data between TFS and other test case/requirements mgmt systems

· Training and Test Methodologies

o With the new functionality in VS 2010 there is a significant opportunity for partners to develop courseware, certification, and training around test

o There is also an opportunity to take well established test methodologies and codify them as TFS Process Templates so that those methodologies can be “enacted” by the VS / TFS ALM system. This is an effective way to take methodologies that may languish as books on the shelf and bring them to live inside familiar tools.

Summary and Next Steps

With such integrations in place the combination of MSFT + Partner test products are intended to appear nearly seamless to the user. Procedures, reports and skill can be used consistently across a broad range of test types, platforms and teams and with improved communication between testers and developers on all platforms. Such a combined offering will be unique in the test market and provide significant differentiated value in the test marketplace.

Next steps depend on your situation

· Component Vendors should focus on updating component suites to support Coded UI Tests and Record and Playback of tests .

· Test Tool vendors should look the opportunities related to

o Integrating third party test tools and/or cross platform environments with the VS 2010 Test Tools.

o Migration and Synchronization or test data between ALM systems

· Software diagnostics partners should look at the opportunities related to integration with custom diagnostics & historical debugging.

· Training Companies should look at the production and delivery of training materials and courses related to the new Test tools in VS 2010

· Test and ALM Methodology companies should look at the possibility of

Partners wanting assistance with such integrations should consider joining the Visual Studio Industry Partner Program (See http://msdn.microsoft.com/vsip ) and for more information please email vsipinfo@microsoft.com .

More information

Key MSDN Links

More detailed information on testing with VS 2010:

http://msdn.microsoft.com/en-us/library/ms182409(VS.100).aspx

http://msdn.microsoft.com/en-us/library/ms182409(VS.80).aspx

http://msdn.microsoft.com/en-us/library/fda2bad5.aspx

Visual Studio SDK - Visual Studio Team Edition for Testers

http://msdn.microsoft.com/en-us/library/bb166187(VS.80).aspx

Visual Studio 2010 Test Tools Blogs

Team Test Blog	http://blogs.msdn.com/vstsqualitytools/
Lab Management Team Blog	http://blogs.msdn.com/lab_management/
Amit Chatterjee	http://blogs.msdn.com/amit_chatterjee/
EdGlas Blog on load testing	http://blogs.msdn.com/edglas/
Mathew Aniyan Blog	http://blogs.msdn.com/mathew_aniyan/

Visual Studio 2010 New Features, Extensibility Points and Partner Opportunities

http://blogs.msdn.com/terryclancy/archive/2009/05/19/visual-studio-2010-new-features-extensibility-points-and-partner-opportunities.aspx

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

http://blogs.msdn.com/terryclancy/archive/2009/05/20/visual-studio-team-system-2010-new-features-extensibility-points-and-partner-opportunities.aspx

More …..

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

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

Additional VS Team Tools resources/links/videos at:

http://www.teamsystemcafe.net/Resources.aspx

Resources to get started with Visual Studio 2010 Beta 2

Visual Studio 2010 and .NET Framework 4 Training Course http://channel9.msdn.com/learn/courses/VS2010/

Getting Started with TFS in VS2010 http://blogs.msdn.com/jasonz/archive/2009/10/21/tutorial-getting-started-with-tfs-in-vs2010.aspx

Link to MSDN Library of resources on 2010 http://msdn.microsoft.com/en-us/library/dd831853(VS.100).aspx

Oracle releases new versions of Oracle Visual Studio tools and Oracle .NET data provider

terrycl — Wed, 18 Nov 2009 00:46:00 GMT

Oracle has released a new version of their Visual Studio tools and their .NET data provider. I talked to Christian Shay ( http://cshay.blogspot.com/ ), who is the product manager for Oracle Developer Tools for Visual Studio and he let me know that these products can be downloaded as part of the Oracle Data Access (ODAC) bundled from this link ( http://www.oracle.com/technology/software/tech/windows/odpnet/index.html ).

He also talked to me about some of the features they have added in this release including performance tuning Visual Studio tools, new tools and APIs to help in writing .NET messenging applications, as well as self tuning features added to the Oracle data provider to bump up data access performance. He recommended that if you are interested in using Oracle's Visual Studio tools and/or .NET data provider you should visit Oracle's .NET Developer Center ( http://www.oracle.com/technology/tech/dotnet/index.html ) . This web site has video demonstrations, step by step tutorials, code samples, and support forums.

Here's some other useful links Christian mentioned:

ODT SQL Tuning Advisor Video Demonstration: http://www.oracle.com/technology/tech/dotnet/viewlets/sqltuneadvisor_viewlet/sqltuneadvisor.html

ODT Oracle Performance Analyzer Video Demonstration: http://www.oracle.com/technology/tech/dotnet/viewlets/addm_viewlet/addm_viewlet.html

Using Visual Studio Tools Walkthroughs http://www.oracle.com/technology/obe/11gr2_db_prod/index/index.htm#t3s7

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.

Top Microsoft .NET Trends – What You Need to Know about Licensing, Protection and Reporting

terrycl — Sat, 12 Sep 2009 08:00:00 GMT

On Thursday, September 24, 2009 - 2:00 p.m. ET/11:00 a.m. PT I will be presenting with Bob Cadd, Strategic Accounts Director, InishTech & Victor DeMarines VP, Products, V.i. Labs on Top Microsoft .NET Trends – What You Need to Know about Licensing, Protection and Reporting

For more information or to register please visit http://www.vilabs.com/septweb/default.aspx?AspxAutoDetectCookieSupport=1

Software vendors, enterprises, and technology providers are increasingly turning to the Microsoft .NET platform to create and deploy new innovative applications. As they do, key requirements surface to ensure that organizations maximize the revenue or value derived from these applications and protect the intellectual property (IP) contained within them.

Because .NET applications are more susceptible to being decompiled and reverse engineered, organizations need to consider implementing granular licensing processes and protection for sensitive software IP.

Speakers from Microsoft, InishTech, and V.i. Labs will discuss how these key .NET requirements can be met through a combination of licensing technology, software protection, and tamper detection and reporting.

Attend this webinar and you will learn about the latest trends in .NET technology and adoption and how to:

Implement a tamper resistant license system to maximize customer revenue and prevent overuse within an install base
Secure valuable IP within easily decompiled .NET code
Track and report on tampering and piracy to ensure maximum revenue and value preservation

Who should attend:

Directors or VPs of Software Development/Engineering, Product Management, and Software Licensing
Compliance officers
CTOs
General counsel

Development Tools Ecosystem Summit | October 19-23, 2009

terrycl — Thu, 27 Aug 2009 03:05:00 GMT

Start planning your travell !!!!! On October 19-23, 2009, the VS Ecosystem Product & Marketing team will host our annual Visual Studio extensibility conference for Visual Studio Industry Partners, Inner Circle Partners & the community alike to learn how to extend Visual Studio. This multi-day event begins with a public conference for all developers looking to learn about extending VS 2010 and then continues on with a private event for VSIP program members under NDA to discuss additional business & technical topics. The event closes with 1:1 developer clinic time for our growing ecosystem of Visual Studio developers. Expected Attendance 400+ and will be hosted at the Microsoft Conference Center in Redmond, WA.

October 19th & 20th - Visual Studio Extensibility Days: Two tracks of presentations that are open to all developers who extend Visual Studio, including VSIP and Inner Circle partners, the Visual Studio extensibility community and internal Microsoft employees. Session content & demos should focus entirely on VS 2010.

October 21st - Partner Business and Strategy Day: Two tracks for VSIP and Inner Circle partners and insiders under NDA only, focusing primarily on the business strategy, marketing discussions, and early information about undisclosed technologies. This may include unannounced changes to Dev10, Dev11 planning, other platform strategies & initiatives.

October 22^nd and 23rd - VSIP Developer Clinic: Developer clinic on Microsoft campus B20 where VSIP program members, under NDA only, meet 1:1 with Microsoft subject matter experts.

Highlights

· Opening Keynote – Rico Mariani (Partner Architect, Microsoft)

· Oct. 21 Partner Keynote – Somasegar (Senior Vice President, Microsoft)

Social Events

Monday October 19: 6:00-7:30 PM - Ask the Experts, Partner & Publisher Fair: During this social event, Visual Studio extensibility developers, VSIP and Inner Circle partners can interact with Microsoft experts, other partners and 3^rd party publishers.

Tuesday October 20: 6:00-8:00 PM - Partner Networking Reception: After a visit to the company store, VSIP and Inner Circle partners are invited to network at the Microsoft Company Museum. Drinks, desserts, and appetizers will be served.

Wednesday October 21: 6:00-9:00 PM - VSIP Partner Dinner: Dinner at the Januik Winery in Woodinville, WA. Buses will provide transportation from the Conference Center to and from the event. Maps will be provided for those that have their own transportation.

Registration Details

General Extensibility Developers: Check out full event details on MSDN, an agenda and session details will be posted soon! Register Now !

VSIP Partners & Inner Circle Partners: All partner program members are invited to this event and should register on the Development Tools Ecosystem Partner Portal.

Microsoft FTE: Microsoft employees are invited to attend this event as well. When you register on the link above, please ensure to enter Microsoft as your Company and use your alias as your email address.

Contact Information

Please email dtes@microsoft.com for registration and general event questions.

MSDN Subscriber offers from our VSIP partners

terrycl — Wed, 05 Aug 2009 04:31:00 GMT

MSDN Subscriber Offers from VSIP Partners July 31, 2009:

ComponentOne, LLC:

ComponentOne Stimulus Package: A Complete Component Suite and a Help Authoring Tool Offered at Special Savings

As an MSDN subscriber, you can get 15% off Studio Enterprise 2009 and Doc-To-Help. Get the control you need – .NET, ASP.NET, Silverlight, Mobile, and ActiveX – with Studio Enterprise. And don’t forget your documentation – author and publish the widest range or print deliverables with Doc-To-Help. See why these products have been named industry winners for the past 20+ years; get yours today.

http://www.componentone.com/msdnoffer/

DevelopGuidance:

RADvolution Designer Database Edition exclusive offer

This powerful RAD tool extends Visual Studio. Rapidly build professional database applications in no-time! Without the need to code. Enrich yourself with more than 250 features. New: wizards which create full functional datagrid and data entry forms, SimpleComboBox, LookupComboBox, export to Excel, open/save custom user queries, simple & advanced email management support and much more! See www.DevelopGuidance.com for demos and a free trial.

http://www.developguidance.com/radvolution_SpecialMSDNOffer.htm

InnerWorkings:

Self-Paced Developer Training for .NET Framework 3.5

Learn to create data driven Web applications in .NET 3.5, using LINQ, ASP.NET Dynamic Data, ADO.NET Data Services & MVC. 10% discount for MSDN developers using coupon code IWMSDN09.

http://www.innerworkings.com/catalog/programs/B0008-CS/.net-framework-3.5-with-cs-2008

Kentico Software:

10% off on Kentico CMS for ASP.NET

MSDN Subscribers can get 10% discount on Kentico CMS for ASP.NET. Kentico CMS is a full-featured content management system for building web sites, on-line stores, intranets and Web 2.0 social networks. It's easy to use for content editors and provides unmatched flexibility for web developers. It features workflow, permissions, multilingual support, full-text search, on-line forms, newsletters, forums, e-commerce, blogs, polls, wiki, web analytics.

http://www.kentico.com/MSDN.aspx

Telerik:

Exclusive deal by Telerik: RadControls for WinForms – FREE Developer License

Telerik, the leading vendor of .NET UI components and tools, has a special offer for all active MSDN subscribers – free Developer License for RadControls for WinForms ($799 in value), with community support only. Take advantage of the offer now and enjoy a powerful grid, advanced docking control, scheduler and everything you need to build unique and visually stunning line-of-business applications. The offer is valid through October 31st, 2009.

http://www.telerik.com/community/promos/msdn-winforms.aspx?utm_source=MSDN_subscribers&utm_medium=banner&utm_campaign=WinForms_promo

FarPoint Technologies, Inc.:

Integrate Excel Documents into BizTalk using Spread for BizTalk - Free Developer License!

Codelessly integrate Excel Documents into your BizTalk 2006/2009 Applications using Spread for BizTalk Pipeline Components. Use the Visual Studio 2005/2008-integrated wizard and designer to build schemas and design your Excel Document layouts. Contact us at FPSales@fpoint.com to receive your Free Developer License.

http://www.FarPointSpread.com/BizTalk

EMC/Conchango release Scrum for Team System V3 Beta 1

terrycl — Tue, 04 Aug 2009 01:54:00 GMT

EMC/Conchango have released Scrum for Team System V3 Beta 1 for use with VSTS/TFS 2010 Beta 1.

Version 3 is designed expressly for TFS 2010, taking advantage of the new platform’s capabilities.

Please be aware that the current beta version of Scrum for Team System has only been tested against TFS 2010 Beta 1; in the near future we will be testing against the forthcoming pre release versions of Visual Studio and will post the outcome of that testing.

Some of the highlights of version 3:

· Sophisticated multi-team support

o Individual team capacity and concurrent teams on different Sprint lengths

o Concurrent teams with the same Sprint length but different start & finish dates

o Add and remove teams on a per-sprint basis

· New QA Model

o Acceptance Test driven

o Microsoft Test & Lab Manager compatible

· New & Extended Reports (limited selection available in Beta 1 – more to follow)

· Event Service Enhancements – provides much more “heavy lifting” and less manual steps

o Transition – one field changing effects another

o Aggregation – sums up related fields

o XML rule set then determines next action

o Composite transition criteria

· Enhanced Work Item Queries

o Leverage hierarchical work item relationships

o Task based queries

If you are interested in participating in the program then please follow the steps below:

Use the following link to create an ID:
http://www.scrumforteamsystem.com/cs/user/CreateUser.aspx?ReturnUrl=/cs/Default.aspx
Wait for e-mail and then follow instructions to complete Registration.

Send an e-mail requesting to join the Scrum for Team System V3.0 Beta 1 program (Subject: Beta) to ScrumforTeamSystem@emc.com with your UserID and the e-mail address used to create the UserID.
They will send you an email with a link to the Scrum for Team System V3.0 Beta 1 Forum

To follow the latest developments on the Scrum for Team System blog: http://blogs.conchango.com/sfts/, which will also provide links out to the personal blogs of the team.

Quest release public beta of Project Fuze, the DSP for Oracle database support in VSTS 2010

terrycl — Tue, 21 Jul 2009 16:55:00 GMT

After many, many months in thier super-secret development lab Quest have now released the first public beta version of their Database Schema Provider (DSP) delivering Oracle database support in Visual Studio Team System 2010 (Beta1) !

With this you can develop Qracle schema, PL SQL, stored procedures, triggers and more right from within Visual Studio. What's more this work can all be done off-line, deployed to various servers even if they have different versions of the database, and all work can be stored under Team Foundation Server source code control along with the rest of your applicaiton..... Finally your DBAs can work as part of the development team !

The public beta is now available on TeamFuze.net – make sure that you visit Microsoft’s site for more information on their public beta of Visual Studio Team System 2010 since you’ll need to have that running in order to try out Project Fuze.

Beta participation is free and open to anyone. However, in order to make the software actually useful to you, Quest need to hear back from you about the things you like as well as the things you don’t like. So please join the forums and post often!

Quest have recorded a video demonstration of how to use Project Fuze inside of Visual Studio Team System 2010. In it they cover creating a new Oracle database project, importing your schema, managing and altering objects, comparing your changes to the live schema and deploying them back to the database. Don’t forget to bookmark our YouTube playlist for future video updates.

Terry Clancy

Micro Focus Launches ReUZE™ at Microsoft WPC

terrycl — Fri, 17 Jul 2009 23:23:00 GMT

Micro Focus^® (LSE.MCRO.L), a leading provider of enterprise application management and modernization solutions, today, at the Microsoft World Wide Partner Conference (WPC), announced a new high performance, low cost solution for customers wishing to migrate Cobol, CICS, JCL, and other applications from the mainframe onto the Windows platform while retaining competitive advantage through the re-use of the enterprise applications running their business today.

With contemporary Visual Studio based Integrated Development Environment, Micro Focus ReUZE™ Developer will enable customers to take advantage of improved developer productivity, cross team collaboration and dramatically improved application life-cycle management with integration with Visual Studio Team System.

Building on this solid framework, Micro Focus ReUZE™ Server emulates the mainframe on Windows and is designed to fully exploit 64-bit Windows architecture, and SQL Server database while supporting the highest level of compatibility with existing application platforms. Unlike other solutions which insist on rewriting mainframe application data sources for SQL Server, or removing mainframe syntax from programs, the Micro Focus solution typically leaves the source code unchanged as the application is moved to Windows and the data is moved to SQL Server. Thus DB2 SQL code is translated to SQL Server Transact SQL on the fly. All this reduces costs, risk, and delivers the highest levels of performance and reliability.

“Our number one priority is to help customers realize the most value from their existing IT assets and move into tomorrow with complete confidence,” said Eddie Amos, General Manager, Developer Tools and Platform Business, Microsoft Corp. “Micro Focus has been a pivotal partner in helping to change the application modernization landscape by reducing costs, improving development processes and providing greater choice for mainframe customers.”

For more information see

· Micro Focus ReUZE™ Developer

· Micro Focus ReUZE™ Server

InnerWorkings helps INETA members build .NET skills - for free!

terrycl — Fri, 19 Jun 2009 23:37:00 GMT

Through July 31, InnerWorkings is giving away 7 hours of the latest hands-on .NET learning to any INETA member, no strings attached. This is your chance to sharpen your current skills or learn some new technologies at no cost, using InnerWorkings Developer. The 7 hours of .NET learning include the following technologies:

• ASP.NET MVC

• ADO.NET Data Services
• Silverlight 2
• Threading

InnerWorkings, believe in hands-on learning – check out their quick product tour for more information. Their learning environment is integrated with Visual Studio and theri patented code-judging engine provides instant feedback on your solutions

JNBridgePro by JNBridge Named 'Best of Tech·Ed 2009 Awards Winner'

terrycl — Fri, 29 May 2009 03:34:00 GMT

"JNBridgePro" from Vistual Studio Industry Partner (VSIP) Program member JNBridge was named as a Winner in the Best of Tech·Ed 2009 awards program in the Software Components and Middleware category by Penton Media's Windows IT Pro and SQL Server Magazine.

The Best of Tech·Ed 2009 awards recognize companies who offer innovative products for the industry. The judges reviewed more than 170 products and services submitted for the contest and chose 35 finalists to be interviewed at the Tech·Ed 2009 IT Pro Conference in Los Angeles, Calif. Winners were announced on May 13, 2009, at an evening reception and are also posted on www.WindowsITPro.com/awards.

Analytics for Windows and ASP.NET from Dev Express Named 'Best of Tech·Ed 2009 Awards Winner'

terrycl — Fri, 29 May 2009 03:23:00 GMT

"Analytics for Windows and ASP.NET" from Vistual Studio Industry Partner (VSIP) Program member Dev Express was named as a Winner in the Best of Tech·Ed 2009 awards program in the Attendees' Pick category by Penton Media's Windows IT Pro and SQL Server Magazine.

Ekobit TeamCompanion for Outlook v 2.1 released

terrycl — Tue, 26 May 2009 10:52:00 GMT

Our VSIP partner Ekobit recently released the new version of their Team System client implemented as an Outlook AddIn: TeamCompanion for Outlook v2.1. The new version brings improved performance and enhancements to existing features, but also some exciting new features. TeamCompanion’s goal is to provide a general purpose TFS client integrated in Outlook with rich feature set aimed at all project stakeholders who want to combine Outlook’s collaboration and communication features with the ability to access TFS artifacts.
This release is a free update for all existing customers.

Following is the list of new and improved features of TeamCompanion:

· Reports (including multiple saved parameter sets for each report)

· “Query by example“ Work Item Query editor (including full-text search support)

· Powerful online and offline work item search capabilities including desktop search integration with Query by Example query editor for full text online search and desktop search integration for full text offline search in any work item field, TeamCompanion gives you all the tools you need to find the information you need.

· Attaching mails to work items using drag-n-drop

· Work Item Query management

· Scheduled Work Item queries

For the complete list of features visit the TeamCompanion’s homepage.
TeamCompanion is available as a free 90-days fully functional trial.

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, VSIP Partners and more ......

Extensibility Series – WPF & Silverlight Design-Time Code Sharing

Visual Studio 2010 Test Tools - Partner Integration Opportunities

Contents

Background and Context

Extending Visual Studio 2010 Test Tools

Summary and Next Steps

More information

Oracle releases new versions of Oracle Visual Studio tools and Oracle .NET data provider

Going to Oracle Open World !!

Top Microsoft .NET Trends – What You Need to Know about Licensing, Protection and Reporting

Development Tools Ecosystem Summit | October 19-23, 2009

MSDN Subscriber offers from our VSIP partners

EMC/Conchango release Scrum for Team System V3 Beta 1

Quest release public beta of Project Fuze, the DSP for Oracle database support in VSTS 2010

Micro Focus Launches ReUZE™ at Microsoft WPC

InnerWorkings helps INETA members build .NET skills - for free!

JNBridgePro by JNBridge Named 'Best of Tech·Ed 2009 Awards Winner'

Analytics for Windows and ASP.NET from Dev Express Named 'Best of Tech·Ed 2009 Awards Winner'

Ekobit TeamCompanion for Outlook v 2.1 released

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

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

Microsoft VSTS 2010 Test Products Overview