Every customer today faces a similar set of business problems:
- How do we build high quality applications that deliver real business value?
- How do we embrace the Application Lifecycle Management model effectively?
- How can we ensure that all members of the team – both technical and non-technical – are part of the process?
- How can we get the most value from our existing code assets?
- How do we make powerful modeling tools available to everyone in the application lifecycle?
Our ALM tooling specifically addresses these questions and helps customers create high quality applications that deliver value to the business. We are evolving the market beyond the first generation of ALM tooling, by:
- Building quality into the lifecycle
- Ensuring architectural consistency through the lifecycle
- Eliminating “No-Repro” bugs
- Ensuring smooth build handoffs and high quality builds
- Incorporating performance in the lifecycle
- Driving efficiency into the test effort
- QA Team aligned with Business Analysts, Architects, and Developers
- Eliminating tedious tasks
- Improving setup and deployment of tests
- Choosing the right tests
- Ensure Complete Testing
- Focused test planning and progress tracking
- Transparently see the quality of requirements and level of testing
- Finding the gaps in testing and fill them
- Ensuring changes are properly tested
The following sections highlight specific feature of Visual Studio Team System 2010 that address the common business needs.
Modeling that Works with Code
For most businesses only about 20% of the code being written today is for new applications; the majority of work is being done on existing code bases. A typical issue encountered when working on existing code is not having good tools to help the architect or developer understand the system. This can make it challenging to not only understand what needs to be done to make the required changes, but it makes it equally challenging to understand the broader impact of the changes. Often it isn’t until much later that an unexpected bug is discovered as a result of a change.
Our modeling tools have tight integration into the actual code of the application. This means that a developer or architect can use models to explore existing code assets. The new Architecture Explorer in Visual Studio Team System gives developers and architects the capability of creating a full architectural picture of existing code; understanding how they fit together; understanding how they “work.” This leads to better information about how to use, re-use, or even whether or not to discard existing code. The Architecture Explorer provides architects and developers a mechanism for visualizing code assets in a number of ways including graphs, stacked diagrams and dependency matrices.
The introduction of the Architecture Layer Diagram means that a developer or architect can use models to enforce constraints on code as well. The Architecture Layer Diagram can be coupled to code making it an active diagram that can be used for validation. For example, when an architect designs a system where the presentation layer should not talk to the data layer, you want to be able to enforce that model at check-in. VSTS 2010 can do that. These capabilities delivered in VSTS 2010 are part of the Microsoft’s overall modeling story.
Learn more about modeling by watching the Trends in Software Modeling webcast featuring Jeffrey Hammond (Forrester Research), Cameron Skinner (Microsoft, Visual Studio Team System), and Clemens Reijnen (Sogeti).
Identify the Test Impact
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.
The new Test Impact View window enables a developer to view a list of tests that need to be run as the result of a code change. The developer can toggle between an Impacted Tests view and a Code Changes view.
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.
content taken by http://msdn.microsoft.com/en-us/vstudio/bb725993.aspx