Wednesday, February 18, 2009

VSTS References and Links

[Alright, I don't like plagiarism :) ;) ]

i) Microsoft - Team System Home:

ii) MSDN - Visual Studio Team System:

iii) MSDN Magazine - Team System:

iv) Wikipedia - Visual Studio Team System:

v) Pro Visual Studio 2005 Team System
Copyright © 2006 by Jeff Levinson and David Nelson
Publisher: Apress
ISBN-13 (pbk): 978-1-59059-460-5
ISBN-10 (pbk): 1-59059-460-6

vi) Team System CafĂ© - “VSTS Cake” Image, etc.

vii) Microsoft® Visual Studio 2010 Overview

viii) Visual Studio Team System 2010 Overview

ix) “Shining the Light on Rosario”

x) Agile Planning Tools In Visual Studio Team System 2010

VSTS – Benefits to Stake Holders and other team members

• Business stakeholders can view reports on the progress of the application through Microsoft SharePoint Services.

• Business stakeholders gain visibility into project activity and priorities to make informed decisions based on real-time data.

• Infrastructure support gets a solid understanding of the deployment needs of the application.

• VSTS improves communication and helps everyone on the team improve their skills and work more effectively together. These benefits translate directly in a higher return on investment because everything becomes easier and faster for everyone.

• VSTS eliminates the use of several different, costly systems because in VSTS it is all rolled into one integrated system. This results in a higher return on investment with one tool than we would get with a combination of tools.

VSTS – Benefits to QA - Business Processes Improvement

• VSTS ensures software quality using advanced quality tools/process templates at every step of the application life cycle.

• Microsoft encourages companies using VSTS to make use of the Microsoft Solutions Framework (MSF), a metamodel which describes business and software engineering processes to help implement an effective software development process.

• VSTS supports two conceptual frameworks for software development, Agile and Capability Maturity Model Integration (CMMI). Other frameworks can be added as well to support other methodologies.

VSTS – Benefits to the Testers

• Testers can use integrated testing tools, which allow for more thorough testing.

• Tests can also be run automatically via automated build tools.

VSTS – Benefits to the Developers

• Developers can look at the class diagrams to understand what is occurring. Any changes they make to the code will be reflected in the diagrams.

• Code can be effectively unit tested.

• VSTS allows all developers to use one tool with which they are familiar. It does not require a developer to learn how to use six different tools to perform the task.

• VSTS has tools to identify inefficient, insecure, or poor-quality code.

• Alerts can be configured so that if one developer’s code is modified by another developer, the former gets an email notification about the changes made by the latter.

• Database Edition provides advanced tools for database change management and testing.

• Team Foundation Build automatically gets the latest version from the version control tool, compiles it, deploys it, and runs any automated tests (unit or web tests) against the build. The results of the compilation and testing are stored in the VSTS data warehouse.

VSTS - Benefits to the Architects

• System architects can design an application as it applies to the network infrastructure and communicate that to the deployment and development team.

• Technical architects can design classes, relationships, and hierarchies that automatically generate skeleton code.

• Architect edition focuses on improving the design and validation of distributed systems.

VSTS - Benefits to the Architects

• System architects can design an application as it applies to the network infrastructure and communicate that to the deployment and development team.

• Technical architects can design classes, relationships, and hierarchies that automatically generate skeleton code.

• Architect edition focuses on improving the design and validation of distributed systems.

VSTS - Benefits to the Project Managers

The following are some benefits for the project managers: -

· Easy work item tracking: When team members check-in their work items into the version control, they can associate the changes that they have made with specific work items. The status of these work items is then reflected on the Project Portal. Work item association can be enforced via policies as well.

· Up-to-date information: Project Managers can get up-to-date information on which items on the project schedule are being worked on and when they are completed through familiar tools like Microsoft Project and Excel.

· Project Reports: Project Managers can view reports on work item status; build results; number of open bugs, closed bugs, and in-work bugs; and other information about the progress of the application through Microsoft SharePoint Services. Projects can be reported on by category, developer, deliverable, milestone, and so on. Project Managers can share reports with other stake holders of the project.

· Ad Hoc Reports: SSRS features an end-user ad-hoc report builder, so project managers can create their own reports or customize existing reports.

· Project Metrics: TFS offers a data warehouse of project-related metrics, ranging from defect trends, test results, and quality indicators to work complete, progress reports, and unplanned work reports.

· No daily status reports needed from team members: VSTS work item tracking system, version control system, reporting system mean that the team members no longer have to report daily status to the project manager - the project manager can just pull the data.

· Trend Analysis: VSTS data warehouse, allows an organization to mine the data for trends in the overall software development life cycle.

· Early identification of problems: VSTS allows problems to be caught early and solved quickly before they become serious issues that affect the schedule. These problems can range from developers not completing work on time to bugs in the code.

· Work analysis across multiple projects: VSTS also allows for the analysis of work across multiple projects.

· Predicting project schedules: It becomes simple to track the organization's project history and use that information to predict future project schedules.

· Single User interface: VSTS integrates all of the needed functionality, including a project management tool and reporting tool, directly into one interface.

What is new in the VSTS 2010?

The following new features are expected in the upcoming version of VSTS i.e. in VSTS 2010: -

Tool to discover and identify existing code assets and architecture - the new Architecture Explorer: 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 using, re-using, or discarding existing code.

Tools to enforce architecture constraints on code: VSTS 2010 provides tools to ensure architectural consistency through the lifecycle. The Architecture Layer Diagram can be coupled to code making it an active diagram that can be used for validation. Example: An architect designs a system where the presentation layer should not talk to the data layer. Visual Studio Team System 2010 is able to enforce this at check-in of the code.

Tools to eliminate “No-Repro” Bugs: Finding bugs that can’t be reproduced is a common problem. VSTS 2010 has some tools to help isolate the issue and enable faster fixes. It has tools for developers to see exactly what testers have done when finding a bug.

Comprehensive metrics and dashboards for shared visibility into project status and progress against deliverables.

Cross project reports: Dashboards and cross project reports that provide roll up of status across diverse projects with powerful drill down to get a thorough understanding.

Improved work item tracking capabilities: Full traceability to track project deliverables against business requirements and the ability to conduct rapid impact analysis of proposed changes.

Integration with Microsoft Office Project Server: This helps in joint prioritization and management of IT projects.

New project scheduling features: These enable better coordination between project management and the rest of the organization.

Agile project scheduling with Excel: VSTS 2010 includes agile project scheduling features with Excel.

Multiple Project Management: Features for project management across multiple projects for proactively load balancing resources according to business priorities.

Improvements to automated build: A new Windows Workflow Foundation based build engine that enables better extensibility to manage the entire build process. It makes it easy to parallelize a build across multiple machines. Introduces the notion of "build agent" pooling so that a farm of build machines can process builds simultaneously rather than processing one build at a time.

• Improvements to multi-server administration build and source control.

Easy custom reports: A simplified data warehouse and reporting experience makes it easier to build custom reports that fit exactly the questions one wants to answer.

Tools to ensure that changes are properly tested: 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. This ensures that all changes are tested effectively, with prioritized tests being run without having to run all of the tests.

• Powerful new features to enable developers and testers to quickly identify, communicate, prioritize, diagnose and resolve bugs.

Tools for better documentation of test scenarios and collection of test data.

Testing automation and guidance to help developers and testers focus on business-level testing rather than repetitive, manual tasks. Tools for manual testers to help them manage their test runs, automate them to reduce manual labor and report actionable bugs that the developer is sure to be able to reproduce and fix.

Tools for focused test planning and progress tracking: A TFS based test case management system enables tracking all the test cases, relate them to requirements and plans, track progress and perform impact analysis.

• Tools to transparently see the quality of requirements and level of testing.

• Tools to find the gaps in testing to fill them.

Business Alignment features: - These features ensure that the team is building the right thing for the business need and that it is going to be successful when completed.

Testing & Application Quality: Helps developers to design and build high quality applications from the beginning, QA organization to verify the quality before deployment, and analysts and project managers to ensure that what is being done meets their requirements.

Quality metrics for a ‘go/no-go’ release decision on whether an application is ready for production and has been fully tested against business requirements.

Rapid integration of remote, distributed, disconnected and outsourced teams into the development process.

Easy customization of process and guidance from Microsoft and partners to match the way your team works

Enhanced version control capabilities including gated check-in, branch visualization and build workflow.

A Brief Introduction to the Architecture of VSTS 2008

VSTS 2008 comprises of both client and server components described below: -

Server Side Components

Microsoft Team Foundation Server (TFS) is the server side component of VSTS that runs on a MS Windows 2003 or MS Windows 2008 Server along with WSS 3.0 or MOSS 2007. TFS acts as a central repository to store all project artifacts in one location and access that information and data from a tool of our choice: Visual Studio, Outlook, Microsoft Project, Excel, Eclipse, Web Access, SharePoint etc. TFS can use SQL Server 2005 or SQL Server 2008 as its back end. To display a wide range of reports, TFS uses MS SQL Reporting and Analysis Services.

TFS acts both as a data storage and as a collaboration backend. It provides work item tracking, reporting, version control repository, etc. Without Team Foundation all of the other components of VSTS are essentially stand-alone components that run on the client. Once Team Foundation becomes part of the picture, the various client pieces work together as a cohesive unit.

TFS provides source control by storing all the code, along with a record of all changes that have been made to the code in a SQL Server database. It uses SQL Server Reporting Services to create a wide variety of reports. It keeps track of the current check-outs and of all change history. It allows different security access levels to be set on different items.

TFS also includes a tightly integrated and highly configurable build server, which is based on MSBuild. The build server can be used to make validated builds of the most recent code contained in the source control. A build can be validated using Visual Studio's Code Analysis, Test Tools and Code Coverage.

TFS provides a Windows SharePoint Services Portal for every project to give one central location for project documentation. TFS provides Work Item Tracking to give visibility of all work outstanding in the project (i.e. use cases, tasks, test cases, and bugs).

TFS can be configured to support any development process with a Process Template. By default it includes Microsoft Solutions Framework (MSF) for Agile Software Development and MSF for CMMI Process Improvement. Partner organizations offer processes including SCRUM, EUP and FDD. These templates can be used as is, or customized to enact the development process.

TFS exposes information and capabilities to the client VSTS IDE through TFS Client API / web services. For example, VSTS Team Explorer allows browsing and managing the items in a team project. Creating and viewing TFS analysis reports is also possible through the VSTS IDE

Client Side Components
  • Microsoft Visual Studio Team System Architecture Edition: Provides visual designers for software architects, systems operations managers, and developers.
  • Microsoft Visual Studio Team System Development Edition: Provides development tools for building applications and service-oriented products, unit testing tools, profiling tools, and code analysis tools.
  • Microsoft Visual Studio Team System Test Edition: Provides web testing, load testing, unit testing, code coverage, and other testing tools.
  • Microsoft Visual Studio Team System Database Edition: Provides database development and testing tools
  • Microsoft Visual Studio Team System Team Suite: Includes all the above client side tools in a single IDE suite.
In addition to the above components, other non-VSTS products such as Microsoft Office Project, Microsoft Office Excel, Outlook, etc. too can integrate with the central Team Foundation Server. Non-developers who are not skilled or interested in Visual Studio can use these familiar tools to interact with the development team.

Since VSTS is an extensible environment, integrating other third party tools into it is easy. Many tool vendors have been working with Microsoft to create integration points with their tools so that we can swap them with ones that come with VSTS.

The Need of VSTS

The following are some of the needs that are addressed by VSTS: -

Communication Needs: Modern IT teams need a highly efficient communication model. A model that entails easy flow of up-to-the-minute accurate information between the team members and at the same time maintains confidentiality of certain information items or source code by providing restricted access to them. The team members - project managers, architects, developers, testers, system administrators, support staff, etc. - may be present in the same room or scattered across the globe. Even though the team might have regular status meetings, send and receive a large amount of e-mail, make a lot of expensive phone calls, collaborate using a SharePoint or WSS site, the information is still not always up-to-the-minute accurate, and it takes a lot of time to sift through all of it.

Integration needs: IT teams need an integrated set of tools to perform various project related tasks, because a great degree of disjointedness results by the use of separate, sometimes unrelated tools for performing project tasks such as creating the application architecture, tracking the work items and deliverables, tracking work schedules, developing code modules, testing the code modules, storing the various artifacts, tracking object dependencies, generating project related reports, etc.

Process guidance needs: IT teams need to ensure that the development process follows an effective development methodology such as Agile Development Methodology, Extreme Programming (XP), Rational Unified Process (RUP), Microsoft Solutions Framework (MSF), etc., based on the nature of the project.

A Brief Introduction to VSTS

Microsoft’s VSTS or “Visual Studio Team System” is an extensible and integrated set of tools, processes and guidance for Application Life-cycle Management (ALM) and software development. This set of tools can be used for software development, version control, team collaboration, work item tracking, project metrics, reporting, project related business intelligence, build management, and process guidance.

VSTS helps an organization to implement an effective development methodology, integrating development experience with project management. For a multi-disciplined IT team, it provides a complete set of integrated tools for Project Managers, Architects, Designers, Application Developers, Database Developers, and Testers. It enables the team members to improve communications, and to continuously collaborate and utilize a set of tools and guidance at every step of the application life cycle.

Friday, November 14, 2008

Loading and Displaying a Web User Control Within a Microsoft SharePoint 2007 (MOSS 2007) Web Part

Hi there,

Here is the source code of a custom Web Part that loads and displays a Web User Control within a Microsoft Office SharePoint Server 2007 WebPart. The Web User Control should be copied to a sub folder named "UserControls" under the root virtual folder of your Microsoft Office SharePoint Server 2007 site, and the name of the web user control should be mentioned in the web part settings tab of this web part.

You can take and use this code in whatever way you want FOR FREE :) but if you think that this code saved your day, or that you can make millions of dollars with this code, you owe me a beer :D :) ;)


// ------------ Start ----------------- : -

using System;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls.WebParts;
using System.ComponentModel;

namespace WebUserControlWebpart
/// <summary>
/// Displays a custom web user control within a
/// Microsoft Office SharePoint Server 2007 Web part.
/// </summary>
public class WebUserControlWebpart : System.Web.UI.WebControls.WebParts.WebPart
private const string USER_CONTROL_SUBFOLDER = @"\UserControls\";

private string m_strUserControlPath;
private string m_strUserControlName;
private string m_strErrorHTML;

private System.Web.UI.Control m_objUserControl;

/// <summary>
/// Default constructor.
/// </summary>
public WebUserControlWebpart()
this.m_objUserControl = null;
this.m_strUserControlPath = null;
this.m_strErrorHTML = string.Empty;

WebDisplayName("Web User Control Name (e.g. ucMyUserControl.ascx )"),
WebDescription("Web User Control Name (e.g. ucMyUserControl.ascx ). " +
"It should be present in a subfolder named 'UserControls', " +
"subfolder named 'UserControls', under the root under the " +
"root virtual folder."),
Category("Web Part Settings"),
public string UserControlName
return m_strUserControlName;
this.m_strUserControlName = value;

if(value != null && !value.Equals(string.Empty))
this.m_strUserControlPath = USER_CONTROL_SUBFOLDER + value;

/// <summary>
/// This method of the WebPart base class is overriden to
/// load a web user control and add it to the controls collection
/// of this web part, so that the said web user control can be
/// displayed within this web part. The web user control will be
/// loaded only if its path has been assigned to the
/// "m_strUserControlPath" variable of this class.
/// </summary>
protected override void CreateChildControls()
if (this.m_strUserControlPath != null
&& ! this.m_strUserControlPath.Equals(string.Empty))
this.m_objUserControl =

catch (Exception ex)

/// <summary>
/// This method of the WebPart class is overriden to render the
/// web user control (whose path is assigned to "m_strUserControlPath"
/// variable of this class) within this web part. If an error has
/// occured then the "m_strErrorHTML" variable of this class will
/// not be null or empty and that text/Html will be displayed instead
/// of the web user control.
/// </summary>
/// <param name="output"> The HTML writer to write out to </param>
protected override void Render(HtmlTextWriter output)
const string DEFAULT_TEXT =
"Please specify the name of the web user control to display";


if (this.m_strErrorHTML != null &&
if (this.m_objUserControl != null)
catch (Exception ex)

/// <summary>
/// Ruturns custom Html that can be used to display the description
/// and other information about the exception that is passed as an
/// argument.
/// </summary>
/// <param name="ex">The exception that has occured</param>
/// <returns></returns>
private string GetErrorMessage(Exception ex)
"An unexpected error has occured!";

string strErrMsg =
"<br /><b>{0}</b><br />Error Message = '{1}'<br />" +
"Error Source = '{2}'<br />" +
"Target Site = '{3}'<br />More Details = '{4}",
DEFAULT_ERROR_MESSAGE, ex.Message, ex.Source,
ex.TargetSite.ToString(), ex.ToString());

return strErrMsg;

/// <summary>
/// This function displays the description of any error that occurs within the webpart.
/// </summary>
/// <param name="ex">The exception that occured.</param>
private void PublishException(Exception ex)
this.m_strErrorHTML += GetErrorMessage(ex);

// ------------ End -----------------.