Srikanth R

Project Server 2007 VSTS Connector

2007-06-12T10:16:59Z

Project Server 2007 VSTS Connector was released in Codeplex. Here is the description of this from Codeplex

The Visual Studio Team System Project Server 2007 Connector is designed to integrate the project management capabilities of VSTS with Project Server 2007. It's been developed by the Visual Studio Team System Rangers in response to significant customer demand for a connector solution. Future versions of Team System will have native integration with Project Server, in the meantime this Connector solution is the best way to integrate the two Microsoft products. This solution builds on the previous PS2003 VSTS Connector, published on GotDotNet. This solution is intended to provide guidance, provided as source code that can be used "as is," extended, or modified by developers to use on enterprise development projects

Performance Testing Guide

2007-06-05T09:10:24Z

Performance testing guide is now available on codeplex. This guide shows you an end-to-end approach for implementing performance testing. Whether you are new to performance testing, or looking for ways to improve your current performance testing approach, you will find insights that you can tailor for your specific scenarios. This guide is related to Performance Testing Guidance Project . - J.D. Meier, Carlos Farre, Prashant Bansode, Scott Barber, Dennis Rea

"Silent" Commandline option for Branching in Orcas

2007-05-28T09:37:28Z

Another great feature in Orcas Version control is that there is an option to create a branch without having to download any of the file locally ( i.e without any get operations). This new option is "/silent" argument for the tf branch command and this prevents the get operations and thus doing the braching in a faster way.

Here's the screenshot how it can be used

Cheers !

Comparing performance reports with the Visual Studio Team System Profiler

2007-05-25T11:13:00Z

While I was exploring some great features of Orcas I came across this interesting great blog post that describes some new features in the profiler that are now available with Visual Studio Team System "Orcas" beta 1. Here's short desciption from this blog

With the recent release of the first Beta for Visual Studio Team System (codename Orcas) customers will get their first chance to see all the great new features that we are adding to the product. For the profiler in particular we’ve added some very cool new features that I’m really happy to finally be able to reveal publicly

Don't miss to visit this blog and this feature !

Links to Learning more about Team system

2007-05-25T11:00:00Z

The below links should be very useful to customers to clarify what exactly they will need to purchase in order to enable source control/bug tracking/testing scenarios within VSTS /Team Foundation Server

Presales website

VSTS datasheet

Cheers !

SnagIt! integration with TFS

2007-05-25T10:31:00Z

I just came across this news from bharry's blog. This is a great news for testers to create bugs and improve their productivity !

Heres the contents of the blog...

I just got mail from TechSmith - makers of SnagIt! that they have added support for Team System. Being an occasional user of SnagIt! myself, I tried it out on our dogfood server and it worked like a charm. SnagIt! allows you to take screenshots and then automatically create a bug with the screenshot attached at the click of a button - very nice. SnagIt! also has powerful capabilities for editing/annotating the screenshots. It's a nice tool. Check out the new update at:

http://www.techsmith.com/community/blogcomments.asp?thread=356

TFS Best Practices

2007-05-25T09:07:00Z

The Microsoft Patterns and Practices team, in concert with the TFS team and a panel of customer reviewer has just released a terrific document on TFS Best Practices. This is distinct from the TFS help on MSDN in the sense that it is not "How-to" guidance but is conceptual information and recommendations for how to use TFS to fit your development process

Happy Reading !

New Version Control features in Orcas

2007-05-21T17:28:00Z

I am very much excited about the new features of Orcas. I recently blogged about new Code Metrics feature. In this blog I explain the new features of Version Control within Orcas

Destroy- The version control allows the destroy operation that provides administrators with the ability to remove files and folders from the version control system permanently. The destroyed files and folders cannot be recovered once they are destroyed. The Destroy feature will allow administrators to achieve SQL server disk space usage goals without constantly needing to add more disks to the data tier machine. Destroy also facilitates removing versioned file contents that must be permanently removed from the system for any other reason.

Heres the documentation screenshot of how this command can be run This command can only be run by an administrator

Annotate - This was available as Team Foundation Server Microsoft TFS PowerToys already, but now it is part of the product. It gives you a chance to see who made what changes to a file. Annotate is a feature that allows developers to inspect a source code file and see at line-by-line level of detail who last changed each section of code. It brings together changeset data with difference technology to enable developers to quickly learn change history inside a source file.

Folder Diff - Orcas now supports compare operations on folders, whereby the contents of the folder are recursively compared to identify files that differ. Folder diff can compare local folders to local folders, local folders to server folders, and server folders to server folders. It will be really useful to identify differences between branches, files that you’ve changed locally, and files that have changed between two points in time. Check the Folder Difference blog of Tan Phan about the exact differences.

Get Latest on Checkout - This is an optional setting on a team project or on an individual basis, you can have Team Foundation Server always download the latest version of a file when you check it out. This helps ensure that you don’t have to merge your changes with somebody else’s when you check the file back in. This option can also be set at Team Project level by Administrator

There are lot of improvements on Version control part of Orcas and you can try it yourself by downloading Orcas

Soon to follow a blog on great new features on Orcas Team Build. Stay tuned .....

Outsourced Projects using Visual Studio Team System

2007-05-20T12:55:00Z

I came across this interesting blog by Richard Murillo and thought of sharing it. In this post he explains lessons learnt and how to leverage Visual studio Team System to execute outsourced projects. Here's the content of what he has to say

"Having been included in two separate teams where our outsourced projects don't go as well as expected I cannot help but to take a step back and ask why things are consistently failing with separate teams, and separate organizations.

The commonalities in both projects were fixed-bid (i.e. fixed price, features and time) using a modified waterfall model (to account for geographic locations). I know—you say the waterfall model doesn't work. Be that as it may organizations revert to this model and are thus handicapped; unable to make adjustments to the changing business and unable to make definitive decisions on how to improve their process, but more on that later. Other commonalities included high level and low level designs, unit test cases, test cases, etc.

I have heard that groups similar to mine are having great success with outsourced projects, and I myself have also been involved with projects that were executed to great success, however I assert that for us there are areas of improvement. At a high level, I can sum it up in one word: process.

Where have my two projects failed? IMHO it is in the analysis of the requirements. The requirements had the vendors pegged implementing features on product technologies they were unfamiliar with—some churn in requirements and with new technology. Traditionally engineering teams would perform proof of concepts and experiments to validate design, and clickable prototypes to share with customers to stabilize requirements (business and technical). While some of that was done here, I still see where it could have been improved. In both instances, we started with a solid vendor relationship that quickly begins to fall apart due to lack of trust. IMHO the biggest areas we are lacking are:

Trust between teams
High SNR in communication (i.e. direct, candid communications on issues, risk and status)
Close coordination between said teams

IMHO in both projects are considered high risk when examining the vendor skill set, staffing model, and experience with projects of this complexity. In most situations you can apply the Pareto principle (AKA 80-20 rule) where 80% of staff is offshore while 20% is onsite for R&D phases, moving to a 90-10 planned iterative model for build and less onsite still for stabilization.

In both projects the offshore team encountered additional issues during implementation that require workarounds for resolution, R&D, or a complete shift in approach. On both projects we tried to mitigate risk by having frequent check-ins with the offshore team and checking progress on a tight basis (one was almost daily, the other bi-weekly). Alas when significant and unexpected delays arose the relationship fell to pieces and in response we put in-house staff on the project to sure it up and get it going in the right direction.

Lessons Learned

Complete as many iterations as you can: That is, don't disrupt forward progress on the project for the sake of getting a work product from the team, but do get deliverables as often as it makes sense. Some of our projects get some weekly, others monthly.
Use collaborative tools to increase confidence in deliverables: Your in-house staff does not have to wait until the end of the formal delivery cycle to perform review or check in with the offshore team. Utilize tools like LiveMeeting Net Meeting, Windows Live Messenger, etc. to increase collaboration
Code review, code review, code review: DO NOT UNDERESTIMATE THIS. A majority of issues we found on one project were found in code review by in-house staff familiar with the business rules. In both projects the adherence to offshore code reviews prior to sending to our in-house staff was not maintained, resulting in many bugs raised later in the cycles. In the reviews we took code that was a representative sample (chosen at random, but was a deep slice) and did a review. Additionally we looked at key strategic areas for performance bottlenecks and security to ensure code conventions, standards, and requirements were being met
Integrate as frequently as possible: Our teams use branches to logically separate the project or feature into areas for work. As a matter of practice, the more frequently these branches can be integrated the faster you can identify and resolve defects.
Where possible, leverage frameworks: Use application blocks (Enterprise Library), Guidance Automation (Web Client Software Factory, Smart Client Software Factory) to solve common problems. Where possible, create your own frameworks and reuse them on projects to reduce the amount of custom code required to be written, which decreases development time and improves quality.
Use Design Patterns: These patterns illustrate common ways to solve problems. Being standard, they can convey meaning across geographical boundaries. Further, by implementing patterns maintenance complexity is reduced and documentation and clarity is improved. A different vendor in a different country, maybe even in-house staff, may need to understand and modify the code—using a proven design allows ramp up to easily occur.
Use useful metrics to measure quality and progress: Build metrics into SLAs and look at meaningful metrics, such as defect density, bug reactivations, code churn, code coverage (unit test or otherwise), project velocity, etc.

Leveraging Visual Studio Team System

I have found that VSTS handles the needs of geographically dispersed development teams (and their inherent challenges) in a variety of ways:

"Better" communication and coordination: Team Foundation Server provides the ability to track work items (tasks, bugs, issues, requirements, risks, change requests) in addition to source code and documentation. The architecture, utilizing web services and cache servers, is optimized for distributed teams working over slow or unreliable connections. The product also allows for customizable notification of events to give you the clarity you need from the projects and help improve onsite/offshore communications
"Better" status reports: Coupled with the data warehouse maintaining statistics and work item history, reports can be generated to give you insight in to some of the metrics I mentioned above. The platform is also extensible, utilizing SQL Analysis Services (SSAS) and SQL Server Reporting Services (SSRS) to allow team members to gather information with various levels of granularity.
"Better" code quality: the product also includes a unit testing framework that works with the centralized build and reporting portions to give indications of code churn, unit test coverage, and pass rates. Check in policies can be configured to check if the code compiles, run static code analysis, even run selected tests

Each one of these allow the onsite team to ensure compliance with corporate standards and gain trust in confidence in the offshore team's ability to deliver a quality, stable product."

In his another blog he explains how VSTS can help prevent failures in outsourced projects

How can Visual Studio Team System help?

Gartner advises companies that plan on offshoring work to figure out their IT process maturity and identify gaps in your process. As previously mentioned, it is important to set all expectations clearly up front with your vendor. When using Visual Studio 2005 with Team Foundation Server, several mechanisms out of box enable teams to work effectively in these environments:

Process: out of the box, Visual Studio Team Foundation server includes MSF for CMMI Process Improvement Level 3 and MSF for Agile Development work item templates. By utilizing the templates and the process behind them, teams can effectively work across physical boundaries with increased confidence and transparency, allowing software development activities to be predictable and success repeatable.
Communication: Visual Studio Team System facilitates the transparency between individuals and teams with work items, a shared team portal, integrated change management, and a common data repository. The availability of information, and insight into an individual's progress, creates a more unified work environment regardless of physical location. Project managers can stay informed on an individual's progress without having to visit each individual—having real time information about each individual's work and their progress allows project managers to create precise schedules and report more accurately to management
Productivity: utilizing the common repository, managers and leads can answer common questions such as: What's in the current build that QA can test today; are requirements being met; are my teams adhereing to quality standards; is the product ready. Further, it provides the single team portal for integrating source code, issue tracking, project plans, vision statements and others that are critical assets to a project team.

This should definitely be useful !

SDC Build Tasks

2007-05-19T14:06:00Z

The SDC build tasks is now available in CodePlex http://www.codeplex.com/sdctasks

Project Description from the Site :

This is the latest version of the SDC Tasks for .NET 2.0. The SDC Tasks are a collection of MSBuild tasks designed to make your life easier. You can use these tasks in your own MSBuild projects. You can use them stand alone and, if all else fails, you can use them as sample code.
There are over 300 tasks included in this library including tasks for: creating websites, creating application pools, creating ActiveDirectory users, running FxCop, configuring virtual servers, creating zip files, configuring COM+, creating folder shares, installing into the GAC, configuring SQL Server, configuring BizTalk 2004 and BizTalk 2006 etc

Use these taks and save your time in writing these tasks !

How to change process guidance template on existing project?

2007-05-18T09:12:00Z

I found this interesting question in the VSTS MSF Forum that many customers have and answer from Alan Ridlehoover . Heres the answer for it.....

The short answer is no, there is no way to change the process template of an existing project.

Think of it like this: A process template in TFS is similar to a document template in Word.

In Word, all documents are based on a template. The default template in Word 2007 is Normal.DOTX. It contains your default font and other formatting preferences. Other templates, such as UrbanLetter.DOTX, contain different formatting as well as placeholders for content. Once a document is created based on a specific template, you can change the content and/or formatting without affecting the underlying template.
In TFS, all projects are based on a process template. There is no default process template. Instead, you must choose from either MSF for Agile or MSF for CMMI. Other templates are also available from third parties. Once a project is created, you can change the content (specific work items, etc.) and/or formatting (work item type definitions) without affecting the underlying template. (More on this below.)

That said, if you still wish to begin using the CMMI template, my advice is to begin fresh, with a new project. To do this:

Move your source code either by getting it out of the old project and checking it in to the new project (which will not bring history), or by starting the new project off a branch of the old source tree (which will bring history)
Move your work items via Excel (which will not bring history - to my knowledge, there is no way to keep history when moving work items between projects)
- In the old project, create a query with all the fields and records you want and export it to Excel
- In the new project create a query with all the fields you want to import and export it to Excel
- Cut & paste (or write a macro)

Alternatively, it is also possible to modify the individual work item type definitions within an existing project using WITExport.exe and WITImport.exe. Together these programs import and export work item type definitions from an existing project (as XML documents). So, you can export a WIT, modify it, and import it. If you go this direction, you will definitely want to check out the Visual Studio 2005 SDK 3.0 - September 2006 RTM (which you can find here), as it contains the documentation for the XML format you'll be modifying. Note: Changing a WIT for a specific project does NOT update the underlying process template. Also note that going this direction may have negative side-effects, such as broken reports. The safest method is to create a new project as described above.

Team System Widgets

2007-05-17T18:05:00Z

Here's is a cool list of various Visual Studio 2005 and Team Foundation Server add-ins, add-ons, widgets, and extensibility solutions.

Cheers

Srikanth

Work Item Creator is now on CodePlex

2007-05-17T10:26:00Z

Work Item Creator is a Standalone application that enable you to create Work Items and organize them in a hierarchical way.
This software also includes WINetwork, a Team System Alert Web Service that is aware of Work Item changes, and update related ones using predefined schemas.

Here's the screenshot of the tool

How Tos (Visual Studio Team System)

2007-05-14T11:06:00Z

Find the answers for the below questions here

How To: Perform a Baseless Merge in Team Foundation Server
How To: Step Through Creating a Custom Check-in Policy for Team Foundation Server 2005
How To: Step Through Creating Your Source Tree in Team Foundation Server 2005
How To: Structure Your ASP.NET Applications for Team Foundation Server
How To: Structure Your Source Control Folders in Team Foundation Server
How To: Structure Your Windows Applications for Team Foundation Server

Happy Reading !

Visual Studio Code Metrics

2007-05-12T12:36:00Z

The new Code Metrics feature for Visual Studio ‘Orcas’! Available in Visual Studio Team Developer and Team Suite, this new feature allows users to generate code metrics for projects and solutions and displays the results in the Code Metrics Results tool window. An example Code metrics Results window is shown below

This feature can generate five different metrics: Maintainability Index, Cyclomatic Complexity, Depth of Inheritance, Class Coupling, and Lines of Code.

Maintainability Index - Measures ease of code Maintanance and higher values for this is better

Cyclomatic Complexity - Measures the number of branches and lower values for this is better

Depth of Inheritance - This measures the lenght of object inheritance hierarchy and lower values for this is better

Class Coupling - Measures number of classes that are referenced and lower values are better

Lines of Code - Measures lines of executable code and lower values are better

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.

As you can see in the figure Visual Studio gives Red or Green icon for the index based on which you can change your code to improve code quality.

Users will are able to sort the results in the window by column. For example, above the results are sorted by the Maintainability Index column. Note that the proper hierarchy is maintained after sorting

Users can also filter the results from a particular metric for values between a specified minimum and maximum value. As you can see in below the results of filtering out any results with a Maintainability Index greater than 100 are displayed.

Users can also export these results into Excel where they can perform their own calculations and transformations.

To generate code metrics, simply do the following:

In Solution Explorer, right-click on your solution/project and choose Generate Code Metrics

Download Orcas and try it out !!!