Richard Murillo on Software Development : Team Foundation Server

Why moving work offshore fails

Richard Murillo — Fri, 20 Apr 2007 19:19:00 GMT

Not to say that all offshore projects fail, I have both been a contributor and leader in projects that have been a great success and those that have been complete failures. Each project had its own reasons for failing and were defined by the business (e.g. why are you sending it offshore to begin with) that typically include cost savings, quality, increased turnaround in deliverables, and customer satisfaction--all of which are key drivers for moving work offshore, but in doing so there are key areas your business must pay close attention to.

According to Gartner, businesses will spend more than $50 billion USD on offshore and "near-shore" outsourcing by 2007 and many projects will fail because of poor planning. Gartner also maintains that there are benefits achieved by those businesses that successfully outsource their non-core processes, however, rewards will not be instant.

Reasons for Failure

Often times, the effort and time involved in communicating with offshore team members and maintaining that relationship is underestimated. In my experiences with offshore teams to date, there has often been a lack of key items to complete awarded work effectively (like infrastructure, soft skills, planning). Additionally, coordinating between the teams requires longer hours, detailed planning, and cultural training—all of which are more expensive when working with offshore than with your own staff and can, as I have observed here, lead to lower morale and reduced deliverable output. Gartner also observes that lack of productivity in the offshore is also an issue for several reasons including high staff turnover and skill levels, especially in highly competitive markets such as Bangalore and Hyderabad, India.

Much like the dot com days, new programmers coming into the field of work are inexperienced, attaining only the necessary core skills for them to receive a job in this field and often struggle with ambiguities in specification or shifting directives. As such, the teams typically do not operate with clear processes and depend on the competence and heroics of those more experienced and not on the use of proven processes. In spite of the chaos, these teams often produce usable work products; however, they frequently exceed the budget and schedule. More often than not these teams over commit, abandon any established process in times of chaos, and may not be able to repeat past successes again.

What's more, senior executives are not involved to keep strategy on track and morale high—they are only in the picture when a significant escalation occurs or to sign a new deal. As I mentioned in my previous entry, in order for an offshore deal to succeed there needs to be a good level of communication between all parties. Requirements, goals, and expectations have to be defined clearly and in detail. Your onshore managers need to explain to the coordinating staff why the work has been sent offshore and what benefits are expected.

More often than not, the cultural differences will come into play creating havoc for the project; classic incarnations of this include not questioning authority and just pressing forward by the offshore team. All too many times do we find out late that guidance or requirements had been ignored for cross cutting to please the schedule rather than announcing a slip.

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.

Team Foundation Server Power Tools (tfpt) 1.2 Released

Richard Murillo — Wed, 21 Feb 2007 22:49:12 GMT

Today the Team Foundation Server team announced the release of version 1.2 of Team Foundation Power Tools (formally known as Power Toys). What are the Power Toys you say? They're extra functionality delivered out of band for Team Foundation Server including some really useful stuff (get changes for changeset, consolidated annotation of a file, command line history, and rollback to name a few).

In the latest release they have included support for Windows Vista (woo-hoo!) and several new tools:

[from announcement]

Workspace Command (tfpt.exe) - Use the workspace command for additional workspace operations not supported in the currently shipping Team Foundation Server command-line tool (tf.exe).
Treeclean Command - Use the treeclean command to see and optionally delete files in the current directory and all subdirectories that are not under version control.
Process Template Editor - A tool that provides a user interface for authoring work item types and some of the associated process template components.
Check-in Policy Pack - A set of custom policies that address often expressed customer needs. For example, the Custom Path Policy allows you to filter the specific items upon which another policy acts.
Build Test Tools Task - An MSBuild task that allows you to run unit tests by specifying the DLLs or a file name pattern in the TfsBuild.proj file instead of using .vsmdi files to specify which tests to run.

One thing that I am very excited for is the new path policy (included in the Check-In Policy Pack). This allows policies to be applied to specific paths in team foundation server (i.e. don't check for valid unit tests on a directory with 3^rd party source code). The other policy I'm excited for is the work item query policy—my project teams have several builds operating concurrently within the same team project and sometimes a private build is executed and picks up work items and associations not belonging to it specifically creating false relationships and throwing off some of our reporting.

To download version 1.2, go to the Microsoft Download center at http://www.microsoft.com/downloads/details.aspx?familyid=7324c3db-658d-441b-8522-689c557d0a79&displaylang=en Help for the new tools can be found on the TFPT Forums at http://forums.microsoft.com/MSDN/ShowForum.aspx?ForumID=930&SiteID=1

Additional information on the tools in depth can be found on Rich's Developer Tools Blog

Getting my Sandcastle Team Build targets file to work with Sandcastle September CTP

Richard Murillo — Tue, 31 Oct 2006 20:45:00 GMT

A few things before we get started:

You will need the HTML Help Workshop installed
September CTP of Sandcastle
My September CTP Sandcastle Targets File (attached)
This file needs to be copied to your %programfiles%\MSBuild directory

Next you will need to make some modifications to the standard configuration file (I am using the VS2005 style)

Make a copy of %programfiles%\Sandcastle\Presentation\vs2005\configuration\sandcastle.config
Change references of
1. ..\..\ to %programfiles%\sandcastle\
2. ..\cpref_reflection to %programfiles%\sandcastle\examples\cpref_reflection

Update your TFSBuild.proj to include the following:

Add a new Import tag referencing the sandcastle targets file
Add a new target called DocumentCLR
<Target Name="DocumentCLR">
<CallTarget Targets="SandcastleDocument" ContinueOnError="false" />
<MakeDir Condition="!Exists('$(BinariesRoot)\Documentation')" Directories="$(BinariesRoot)\Documentation" ContinueOnError="false" />
<Copy SourceFiles="$(SandcastleWorkingDirectory)\Output\$(SandcastleDocumentationName).chm" DestinationFiles="$(BinariesRoot)\Documentation\$(SandcastleDocumentationName).chm" ContinueOnError="false"/>
</Target>
Add an additional target that overrides the AfterCompile target
<Target Name="AfterCompile">
<CallTarget RunEachTargetSeparately="true" Targets="DocumentCLR" ContinueOnError="false"/>
<OnError ExecuteTargets=" OnBuildBreak;"/>
</Target>
Update your TFSBuild.rsp file to include some configuration
/p:SandcastleDocumentationName=NameOfYourCHM
/p:SandcastleConfiguration="C:\Path_TO_MODIFIED_CONFIG\sandcastle.config"
/p:SandcastleDocumentationOutput=$(BinariesRoot)\Documentation
/p:SandcastleDependencies="%windir%\Microsoft.NET\Framework\v2.0.50727\*.dll,\\lcabuildvm01\3rdParty\Dependencies\*.dll,%windir%\assembly\GAC_MSIL\Microsoft.VisualStudio.QualityTools.UnitTestFramework\8.0.0.0__b03f5f7f11d50a3a\Microsoft.VisualStudio.QualityTools.UnitTestFramework.dll"
/p:SandcastleHelpGeneration=CHM

Reusable MSBuild Sandcastle Targets File

Richard Murillo — Tue, 31 Oct 2006 03:24:00 GMT

Based on a past post, I have an external targets file you can place in your $(MSBuildExtensionsPath) folder (attached in zip).

You can call it like this:

</Target>

</Target>

The following is configuration from my msbuild response file:

/p:SandcastleDocumentationName=MyProjectDocumentation

/p:SandcastleConfiguration=C:\YOUR\CONFIG\sandcastle.config

/p:SandcastleDocumentationOutput=$(BinariesRoot)\Documentation

/p:SandcastleDependencies="%windir%\Microsoft.NET\Framework\v2.0.50727\*.dll,C:\YOUR\Dependencies\*.dll,%windir%\assembly\GAC_MSIL\Microsoft.VisualStudio.QualityTools.UnitTestFramework\8.0.0.0__b03f5f7f11d50a3a\Microsoft.VisualStudio.QualityTools.UnitTestFramework.dll"

/p:SandcastleHelpGeneration=CHM

Note: tested with build 2.0.2426.28539

Using Sandcastle August CTP and MSBuild to produce CHM documentation automatically

Richard Murillo — Sat, 30 Sep 2006 03:44:20 GMT

First, we created a cmd file to do the build for us. Syntax for calling the file is Build.cmd "PathToBinaries" "Name of the documentation" (more on this later)

@echo off

PUSHD %1

"%programfiles%\Sandcastle\ProductionTools\mrefbuilder.exe" *.dll /out:%~dp0\reflection.org /dep:%windir%\Microsoft.NET\Framework\v2.0.50727\*.dll,C:\deps\*.dll,%WINDIR%\assembly\GAC_MSIL\Microsoft.VisualStudio.QualityTools.UnitTestFramework\8.0.0.0__b03f5f7f11d50a3a\Microsoft.VisualStudio.QualityTools.UnitTestFramework.dll

IF ERRORLEVEL 1 EXIT /B 1

POPD

"%programFiles%\Sandcastle\ProductionTools\XslTransform.exe" /xsl:"%programfiles%\Sandcastle\ProductionTransforms\AddOverloads.xsl" /xsl:"%programfiles%\Sandcastle\ProductionTransforms\AddGuidFilenames.xsl" reflection.org /out:reflection.xml

IF ERRORLEVEL 1 EXIT /B 1

"%programFiles%\Sandcastle\ProductionTools\XslTransform.exe" /xsl:"%programfiles%\Sandcastle\ProductionTransforms\ReflectionToManifest.xsl" reflection.xml /out:manifest.xml

IF ERRORLEVEL 1 EXIT /B 1

if not exist Output mkdir Output
if not exist Output\html mkdir Output\html
if not exist Output\art mkdir Output\art
if not exist Output\scripts mkdir Output\scripts
if not exist Output\styles mkdir Output\styles
copy "%programfiles%\Sandcastle\Presentation\art\*" Output\art > NUL
copy "%programfiles%\Sandcastle\Presentation\scripts\*" Output\scripts > NUL
copy "%programfiles%\Sandcastle\Presentation\styles\*" Output\styles > NUL

"%programfiles%\Sandcastle\ProductionTools\BuildAssembler.exe" /config:sandcastle.config manifest.xml
IF ERRORLEVEL 1 EXIT /B 1

"%programFiles%\Sandcastle\ProductionTools\XslTransform.exe" /xsl:"%programfiles%\Sandcastle\ProductionTransforms\ReflectionToChmProject.xsl" reflection.xml /out:Output\%2.hhp

IF ERRORLEVEL 1 EXIT /B 1

"%programFiles%\Sandcastle\ProductionTools\XslTransform.exe" /xsl:"%programfiles%\Sandcastle\ProductionTransforms\ReflectionToChmContents.xsl" reflection.xml /arg:html=Output\html /out:Output\%2.hhc

IF ERRORLEVEL 1 EXIT /B 1

"%programFiles%\Sandcastle\ProductionTools\XslTransform.exe" /xsl:"%programfiles%\Sandcastle\ProductionTransforms\ReflectionToChmIndex.xsl" reflection.xml /out:Output\%2.hhk

IF ERRORLEVEL 1 EXIT /B 1

CD OUTPUT

"%programfiles%\HTML Help Workshop\hhc.exe" %2.hhp

CD ..

There is also a configuration file we're using referenced in our call to BuildAssembler.exe; here is that

<configuration>

  <dduetools>

    <builder>

      <components>

        <!-- Create skeleton document -->

        <component type="Microsoft.Ddue.Tools.CopyFromFileComponent" assembly="%programfiles%\Sandcastle\ProductionTools\BuildComponents\BuildComponents.dll">

      <data file="%programfiles%\Sandcastle\Presentation\transforms\skeleton.xml" />

      <copy source="/*" target="/" />

    </component>

        <!-- Copy in reflection data -->

    <component type="Microsoft.Ddue.Tools.CopyFromIndexComponent" assembly="%programfiles%\Sandcastle\ProductionTools\BuildComponents\BuildComponents.dll">

          <index name="reflection" value="/reflection/apis/api" key="@id" cache="10">

            <data files="reflection.xml" />

          </index>

          <copy name="reflection" source="*" target="/document/reference" />

    </component>

    <!-- Copy in container data -->

    <component type="Microsoft.Ddue.Tools.CopyFromIndexComponent" assembly="%programfiles%\Sandcastle\ProductionTools\BuildComponents\BuildComponents.dll">

          <copy name="reflection" key="string(/document/reference/containers/container/@namespace)" source="*[not(local-name()='elements')]" target="/document/reference/containers/container[@namespace]" />

    </component>

    <component type="Microsoft.Ddue.Tools.CopyFromIndexComponent" assembly="%programfiles%\Sandcastle\ProductionTools\BuildComponents\BuildComponents.dll">

          <copy name="reflection" key="string(/document/reference/containers/container/@type)" source="*[not(local-name()='elements')]" target="/document/reference/containers/container[@type]" />

    </component>

    <!-- Generate syntax -->

    <component type="Microsoft.Ddue.Tools.IfThenComponent" assembly="%programfiles%\Sandcastle\ProductionTools\BuildComponents\BuildComponents.dll">

      <if condition="not(starts-with($key,'Overload:') or starts-with($key,'R:'))" />

          <then>

      <component type="Microsoft.Ddue.Tools.SyntaxComponent" assembly="%programfiles%\Sandcastle\ProductionTools\BuildComponents\BuildComponents.dll">

        <syntax input="/document/reference" output="/document/syntax" />

        <generators>

              <generator type="Microsoft.Ddue.Tools.CSharpDeclarationSyntaxGenerator" assembly="%programfiles%\Sandcastle\ProductionTools\BuildComponents\SyntaxGenerators.dll" />

              <generator type="Microsoft.Ddue.Tools.VisualBasicDeclarationSyntaxGenerator" assembly="%programfiles%\Sandcastle\ProductionTools\BuildComponents\SyntaxGenerators.dll" />

              <generator type="Microsoft.Ddue.Tools.CPlusPlusDeclarationSyntaxGenerator" assembly="%programfiles%\Sandcastle\ProductionTools\BuildComponents\SyntaxGenerators.dll" />

            </generators>

          </component>

          </then>

    </component>

    <!-- Copy in comments -->

    <component type="Microsoft.Ddue.Tools.CopyFromIndexComponent" assembly="%programfiles%\Sandcastle\ProductionTools\BuildComponents\BuildComponents.dll">

          <index name="comments" value="/doc/members/member" key="@name" cache="100">

            <data files="Documentation\*.xml" />

          </index>

          <copy name="comments" source="*" target="/document/comments" />

    </component>

    <!-- Copy in reflection data and comments for members -->

        <component type="Microsoft.Ddue.Tools.ForEachComponent" assembly="%programfiles%\Sandcastle\ProductionTools\BuildComponents\BuildComponents.dll">

          <variable expression="/document/reference/elements/element/@api" />

          <components>

            <component type="Microsoft.Ddue.Tools.CopyFromIndexComponent" assembly="%programfiles%\Sandcastle\ProductionTools\BuildComponents\BuildComponents.dll">

          <copy name="reflection" source="*[not(local-name()='elements')]" target="/document/reference/elements/element[@api=$key]" />

        </component>

            <component type="Microsoft.Ddue.Tools.CopyFromIndexComponent" assembly="%programfiles%\Sandcastle\ProductionTools\BuildComponents\BuildComponents.dll">

              <copy name="comments" source="summary" target="/document/reference/elements/element[@api=$key]" />

            </component>

          </components>

        </component>

    <!-- transform -->

        <component type="Microsoft.Ddue.Tools.TransformComponent" assembly="%programfiles%\Sandcastle\ProductionTools\BuildComponents\BuildComponents.dll">

          <transform file="%programfiles%\Sandcastle\Presentation\transforms\main_sandcastle.xsl" />

        </component>

    <!-- resolve shared content -->

        <component type="Microsoft.Ddue.Tools.SharedContentComponent" assembly="%programfiles%\Sandcastle\ProductionTools\BuildComponents\BuildComponents.dll">

          <content file="%programfiles%\Sandcastle\Presentation\content\shared_content.xml" />

          <content file="%programfiles%\Sandcastle\Presentation\content\reference_content.xml" />

    </component>

    <!-- resolve reference links -->

    <component type="Microsoft.Ddue.Tools.ResolveReferenceLinksComponent" assembly="%programfiles%\Sandcastle\ProductionTools\BuildComponents\BuildComponents.dll">

      <targets files="reflection.xml" type="local" />

    </component>

    <!-- save the result -->

        <component type="Microsoft.Ddue.Tools.SaveComponent" assembly="%programfiles%\Sandcastle\ProductionTools\BuildComponents\BuildComponents.dll">

          <save path="concat('Output\html\',/html/head/meta[@name='guid']/@content,'.htm')" indent="false" omit-xml-declaration="true" />

        </component>

      </components>

    </builder>

  </dduetools>

</configuration>

Now we have to hook it up to MSBuild. Within the TFSProj.proj file, a new target was created called by an override to the Team Build AfterDrop target

<PropertyGroup>

    <SandcastleDocumentDirectory>$(TEMP)\SandcastleDocument</SandcastleDocumentDirectory>

</PropertyGroup>

<Target Name="SandcastleDocument">

    <CreateProperty Value="MyDocumentation">

      <Output TaskParameter="Value" PropertyName="SandcastleDocumentationName"/>

    </CreateProperty>

    <RemoveDir Condition="Exists('$(SandcastleDocumentDirectory)')" Directories="$(SandcastleDocumentDirectory)" ContinueOnError="false"/>

    <MakeDir Directories="$(SandcastleDocumentDirectory)" ContinueOnError="false" />

    <CreateItem Include="$(SolutionRoot)\Sandcastle\Aug 2006 CTP\Build.cmd">

      <Output ItemName="SandcastleBuildScript" TaskParameter="Include"/>

    </CreateItem>

    <Copy SourceFiles="@(SandcastleBuildScript)" DestinationFiles="@(SandcastleBuildScript -> '$(SandcastleDocumentDirectory)\Build.cmd')" ContinueOnError="false" />

    <CreateItem Include="$(SolutionRoot)\Sandcastle\Aug 2006 CTP\sandcastle.config">

      <Output ItemName="SandcastleConfiguration" TaskParameter="Include"/>

    </CreateItem>

    <Copy SourceFiles="@(SandcastleConfiguration)" DestinationFiles="@(SandcastleConfiguration -> '$(SandcastleDocumentDirectory)\sandcastle.config')" ContinueOnError="false" />

    <MakeDir Directories="$(SandcastleDocumentDirectory)\Documentation" ContinueOnError="false"/>

    <CreateItem Include="$(BinariesRoot)\x86\Debug\*.xml">

      <Output ItemName="CodeDocumentationFiles" TaskParameter="Include"/>

    </CreateItem>

    <Copy SourceFiles="@(CodeDocumentationFiles)" DestinationFiles="@(CodeDocumentationFiles -> '$(SandcastleDocumentDirectory)\Documentation\%(Filename)%(Extension)')" ContinueOnError="false"/>

    <Exec WorkingDirectory="$(SandcastleDocumentDirectory)" Command="Build.cmd &quot;$(BinariesRoot)\x86\Debug&quot; $(SandcastleDocumentationName)" ContinueOnError="false" />

    <CreateItem Include="$(SandcastleDocumentDirectory)\output\$(SandcastleDocumentationName).chm" ContinueOnError="false">

      <Output ItemName="SandcastleDocumentationFiles" TaskParameter="Include"/>

    </CreateItem>

    <MakeDir Condition="!Exists('$(BinariesRoot)\Documentation')" Directories="$(BinariesRoot)\Documentation" ContinueOnError="false" />

    <Copy SourceFiles="@(SandcastleDocumentationFiles)" DestinationFiles="@(SandcastleDocumentationFiles -> '$(BinariesRoot)\Documentation\%(RecursiveDir)%(Filename)%(Extension)')" ContinueOnError="false" />

    <OnError ExecuteTargets="OnBuildBreak;"/>

  </Target>

I'm on Channel9!

Richard Murillo — Thu, 27 Jul 2006 00:50:00 GMT

Yay!

I'm on the front page of Channel9 with an interview about using Visual Studio Team System in MSIT's Legal group.

Full link for your reference: http://channel9.msdn.com/showpost.aspx?postid=220125

Key Design Scenarios with Visual Studio Team System and Team Foundation Server - System, Application, Resource Reuse

Richard Murillo — Tue, 02 May 2006 21:26:00 GMT

In order to effectively execute an IT strategy a roadmap must be created to contain and identify what common areas exist for the business' solution that could be leveraged by other systems in the enterprise or organization; or which capabilities the solution can leverage.

Typically architects will draw their solution design on a whiteboard, and link dependant systems that way. The key problem with that is there are a number of settings and data that are required on each node that can't easily be placed on the whiteboard. In Visual Studio 2005 Architect and Team Suite SKUs architects can go beyond the whiteboard and use the distributed system diagramming tool in Visual Studio 2005.

From this diagram the architect can update how the distributed systems are defined in a solution. Opportunities for reuse can be identified and the overall distributed system architecture can be changed quickly and easily. Then, after baseline, the architect can have Visual Studio 2005 build the stubs for these services and applications with definitions and attributes set at this aggregate level. The diagram also serves as documentation for technical requirements and can be updated after the solution is though with development to represent as-built.

The key idea in all of this is we begin with the end in mind and developing our IT solution to business needs. We can use these diagrams to form views of our solution--other views available in VSTS include the system designer (a drill down into each node above), class designer (a further drill down into a visual view of the code in a system), the logical datacenter designer (provides a visual representation of the desired deployment locations), and the deployment designer (creates entire deployment plan).

As I mentioned before, it is imperative that architects identify where existing systems or their own systems could be re-used by other areas of the business to reduce cost and improve ROI. The solution design, application design, and web service endpoint design are all key to determine what resources are available and which are needed and ultimately act as inputs to those components design or re-design to suite a more generic purpose.

Visual Studio Team Foundation Server Feature Requests

Richard Murillo — Fri, 28 Apr 2006 10:59:00 GMT

I find it difficult to manage many Shared Queries in the work item tracker of VSTF. Sometimes I want to save my ad-hoc query for distribution to a small set of people (maybe just a peer even), but find no way to really make that easy except for sharing the query with the entire team. Even there, you could have hundreds of queries with no real way to group them, so you have to get creative with the naming.

Scenario: I am in a meeting and I need to quickly query WIT to respond to a question. If I do not have an instance of Visual Studio running on my laptop, I would need to start one up (alternate: MSTSC in to my primary development workstation and open a new VSTS instance there) and wait for it to connect to VSTF. Then I would need to hunt down the query, or create a new query based on the criteria, then wait for the results. After I get my results and present them verbally, Bob, a peer developer, also wants to see the results and other various details that I didn't explicitly communicate in my answer. I would have to save my query as a shared query and give him the name so he could hunt it down.

Features I want:

An easy way to share WIQL queries with team members as an external file that can be executed by anyone that has read access to the team foundation server.
- Value Propositions
  - Queries can be shared easily with users who do not actively watch a VSTF WIT database
  - Queries can be stored outside of VSTF (email, SharePoint, etc.)
    Update: this is possible in a limited fashion and is hidden away. When creating a VSTS query, you can File -> Save As... to save it as a file directly. You cannot, however, export an existing query directly to a file. You must open the query, modify it, change it back to the way it was (i.e. add a clause then remove it) then do a File -> Safe As... and save it as a file.
A way to organize the work item queries into folders and, for shared queries, adjust permissions on a folder level based on TFS or Windows security group
- Value Propositions:
  - Enhanced organization allows users to find relevant information quickly
  - Security lock down can prevent unauthorized editing of a query (i.e. only the triage team can create, update, or delete triage queries)
Functionality to search by query name, creator, last updated, etc.
- Value Proposition:
  - If my team instance has many WIT folders or queries I may need to locate a query quickly and easily
  - May wish to check for duplicate query name or search for a query that already has similar functionality that I can copy then modify for my purposes (find query from last release containing known issues and copy that to a new query so I can change the version, etc. for a new known issues query).

Goals:

Users can update existing VSTF, or create new VSTF instances and/or installations without breaking changes

IMHO if we coupled this with a command line tool that I previously proposed some users would not need Visual Studio or Office at all to manage the queries which would be nice.

gh9zRYb9z3NLEeu

Key Design Scenarios with Visual Studio Team System and Team Foundation Server

Richard Murillo — Wed, 26 Apr 2006 21:23:00 GMT

First I want to start out with some observations:

The Business expects IT to provide a technology advantage with the right capabilities at the right price at the right time
A business strategy alone is not sufficient for IT planning

Business rarely asks for IT infrastructure capabilities

Every business capability is highly dependant on the IT infrastructure

It is difficult to make a business case without a strategy except when there is obvious pain

Given that state of things most solutions are reactive and the solutions that are delivered are often tightly coupled with a business process so other processes that require similar functionality will either have to copy/paste code or build it themselves--either way it's a losing battle; we are shooting ourselves in the foot by driving up maintenance costs and reducing ROI. Then when something goes wrong we act--the entire notion of reactive maintenance and augmentation is an issue itself and this is where architecture planning and the new visualization tools of VSTS come into play.

A few of the key concepts to architecture planning revolve around clarity of business needs and IT objectives. However, more importantly IT needs to anticipate business needs to meet expectations (right solution, for the right price, at the right time). To do this we must understand our objectives and best practices to help us choose the right approach (direction and design patterns).

To understand and anticipate business needs we need to identify what capabilities the business might need for various aspects of conducting their business. Next we need to answer several key questions about those needs:

For each capability what will change over time?

Who
Where
What
When
How

Once we understand what the business needs, we can create an IT roadmap for those needs, identifying success factors, objectives, and design principles.

In the future I will publish a series of posts around the following key design scenarios:

Contract-first design
Scenario-driven design
Business process-driven design
Framework design
System, application, resource reuse
Requirements Traceability
Design patterns, guidance, prescriptive architecture
Cross-lifecycle and Team Collaboration

Strategic Architecture solutions are a way of thinking

Richard Murillo — Sat, 22 Apr 2006 01:39:00 GMT

Expanding on my previous post on accountability, fostering alignment across the enterprise is really driven from multiple angles: market opportunity, technology opportunity, capability and business operations--all which create a business strategy. In that are 5 main tenets: effectiveness, competitiveness, agility, accountability, and efficiency.

One of the key objectives of Visual Studio Team Foundation server is to create an environment where teams can collaborate and leverage past experience; this is where I think the real value of IT lies. A key item I have begun to include in my documents is that we should have multiple value propositions for each objective--a value proposition from the business and one from IT. VSTF allows us to foster collaboration and create value, but we still have to measure the effectiveness in translating business vision and strategy. Enter Balanced Score Cards.

BSCs are about clarity and turning vision and strategy into action and providing feedback on those actions. Most importantly, BSCs are more than just about profit and cost reduction, which is great, but only a segment of issues. BSCs allow for balance:

"The balanced scorecard retains traditional financial measures. But financial measures tell the story of past events, an adequate story for industrial age companies for which investments in long-term capabilities and customer relationships were not critical for success. These financial measures are inadequate, however, for guiding and evaluating the journey that information age companies must make to create future value through investment in customers, suppliers, employees, processes, technology, and innovation."

Every project has basic elements that can be used by BSCs: customers, budget, learning opportunities and growth, customer satisfaction, etc. and as such, architecture should be mapped to those elements. Visual Studio Team System Architect and Team Suite SKUs include some great visualization tools to provide a visual element to our complex systems, such as a datacenter view and code entity relationships.

In order for projects and feature teams to collaborate effectively, first they must identify which goals are shared. Those goals must then be mapped back to business strategy in a way that provides clarity. Since most human beings are visually oriented, the addition of visual views of our systems allow us to quickly and succulently (a picture is worth a thousand words) describe and recognize reusable technical areas. However, in order to successfully provide shared systems or components, one must leverage standards that exist (global, industry, team, project, etc.), focus on key integration requirements, as well as use extensibility models and OOP techniques to handle special cases. This ensures that components are developed against a clear set of goals that is transparent to everyone. Other projects then can use these views, which can be exported as images, to identify if and where the components or services provide value to their objectives during their envisioning and planning phases.

As we shift into this kind of thinking we are placing more and more emphasis on process, that is, creating deliverables consistently and reliably whether it's a process to support the application, a business-oriented process (such as a human to human workflow), or strategic planning. There are several key areas we can focus on to improve process efficiency such as having a managed workflow, minimal variation in our processes, or stakeholder/participant insight.

One key item to realize when thinking about how this architecture decision could be useful in the future is to be aware that future changes should not hurt. This can be done through encapsulation which then allow improvements to be implemented with little overall pain to the service or component itself and to other applications that are dependent on it. It is through encapsulation that you can standardize how instances of your process, component, system, service, etc. are created or invoked, and automatically test normalized user scenarios to provide quality and consistency. With these scenarios you can derive values for various metrics, such as performance, which are reflected in the BSC.

Example

You analyze a high priority user scenario and see that in the workflow there are a number of calls to your web service that reduce the responsiveness of the calling application due to the overhead of running the HTTP request and parsing the response. You then optimize this scenario by reducing the amount of fine grained calls to your service by providing a coarse grained interface to be used by calling applications.

As teams adopt these practices the organization drives toward excellence by implementing consistent best practices, optimizing return on investments (ROI), and increasing communication by collaborating, which is eased by a consistent context for exchange of information. The dependency of another application to your own forces quality up and dissolves team indifference.

Key Take-Aways

Shared components and services significantly improve communication and alignment with business objectives

In order to drive the need for dependency on a component, it must clearly communicate its value propositions and be integral to the value chain of another project
To maintain order, policies must be enforced
Each component or service has value and associated cost which can be measured using a Balanced Score Card
Each component or service can be in-sourced, outsourced, and multi-sourced
The encapsulation of business capabilities promotes
- continuous improvement
- flexible souring choices
- teaches an organization about itself

Driving Accountability with VSTF

Richard Murillo — Wed, 19 Apr 2006 23:34:00 GMT

I used to work with a developer, an agile methodology evangelist, who would often tell me stories about agile methodologies applied to industries other than information technology. In a specific instance, I recall him telling me a story about a Japanese auto factory that implemented the LEAN methodology for manufacturing.

Basically the story was that anyone in the factory could stop the production line if they found an issue.

An interesting concept indeed. Today I read another article about Japanese Auto Production plant that only kept a few spare parts for issues encountered on the production line. If the production line ran out of spare parts, the entire line was shut down while new parts were ordered.

This idea drives an interesting behavior: no one single person wakes up in the morning and aspires to shut down the production line. In the automobile manufacturing plant it turns out that the vendors supplying the parts also did not want to be in the position of halting all production in the plant, so they simply shipped higher quality parts because higher quality was expected from them (this is known as the Pygmalion effect) and they know they would be held accountable.

One thing I have been doing recently at Microsoft is driving collaboration with Visual Studio Team Foundation server and helping spot issues with our developing products by integrating components more frequently and regularly. This provides a shorter feedback loop where we can address the issues sooner, rather than waiting until a big quality push at the end of the project, running out of time, and having to solve the issues with a service release.

The integration portions for VSTF come right out of the box--static code analysis to ensure a base level of code quality, automated builds with team build, greatly enhanced branching and merging capabilities to allow teams with multiple features to integrate frequently without being detrimental to the overall project progress, work item and issue tracking, et al.

In the not too distant future I will be posting more information regarding the business value of VSTS and VSTF (following my premier on Channel9) and what mindset changes need to occur to get the most value out of these great new tools that have shipped.

Visual Studio Team Foundation Server MSSCCI Provider

Richard Murillo — Tue, 11 Apr 2006 20:46:00 GMT

Version 1.0 of the Visual Studio Team Foundation Server MSSCCI Provider has been released to the web! This is very exciting for me--the MSSCCI provider allows the integrated use of the new version control system available in Team Foundation Server from products that did not support it OOB such as:

Visual Studio .NET 2003
Visual Basic 6 (SP6 required)
SQL Server Management Studio (SSMS)

An issue arises with the new MSSCCI provider though--having multiple providers installed on your development machine at once. For example, other devs on my team still use VSS 6.0 for our legacy systems, but now they can begin to migrate the sources over to the new source control system. But managing multiple MSSCCI providers can be a bit tricky. Ed Hintz posted an entry on his blog about dealing with multiple MSSCCI providers and switching between the two. Essentially you can run the following commands to switch easily back and forth in your environments:

From Ed Hintz's entry:

[The] following command line command will set the provider to SourceSafe.

reg add HKLM\Software\SourceCodeControlProvider /v ProviderRegKey /d Software\Microsoft\SourceSafe /f

Likewise, the following command will set the provider to TFS.

reg add HKLM\Software\SourceCodeControlProvider /v ProviderRegKey /d "Software\Microsoft\Team Foundation Server MSSCCI Provider" /f

If you want to migrate from VSS 6.0 to VSTFS Source management then you would have used the VSSConverter command line utility. Rob Caron has posted an entry on his blog that a 3rd party has created a GUI for the utility to simplify the migration.

Improving Team Foundation Server performance

Richard Murillo — Fri, 07 Apr 2006 04:19:00 GMT

Buck Hodges has a post in his blog outlining various tips for improving performance on

Verifying LAN settings are correct
Not running tf.exe on the app tier
Batching TF.exe requests in a command file

http://blogs.msdn.com/buckh/archive/2005/12/12/503015.aspx

Tim Noonan has also provided some other registry tweaks to improve performance within the IDE
http://blogs.msdn.com/hippietim/archive/2006/03/14/551320.aspx

Source: http://blogs.msdn.com/buckh/archive/2006/03/14/vs_registry.aspx

The Differences between TFS Trial and RTM

Richard Murillo — Thu, 06 Apr 2006 01:10:00 GMT

I received a comment on my blog asking about the differences between TFS Trial and RTM. Here are some highlights:

Bits are 99.99% identical
Trial has the same process guidance version of MSF (4.0), however, there are some known issues that exist with broken links in the Trial version of TFS (KB articles to be posted along with a patch to fix the issue)
Trial version expires after 180 days
You can upgrade the Trail to Retail though the setup UI
Only those covered under the MSDN Universal/Premium solutions have access to the Trial version and Workgroup Edition

If you wish to purchase TFS you can do that with Microsoft directly with a Volume Licensing Agreement (http://www.microsoft.com/licensing/resources/default.mspx) or directly from a reseller.

Additional information about RTM and purchasing FPP or VLA editions can be found on Eric Lee's blog "Why can't I buy Team Foundation Server right now?"

Some Helpful Visual Studio Team System and Team Foundation Server books

Richard Murillo — Mon, 03 Apr 2006 07:07:00 GMT

Software Engineering with Microsoft Visual Studio Team System (Out May 17)

Software Engineering with Microsoft Visual Studio Team System is written for a software team that is considering running a software project using Visual Studio Team System (VSTS). It is about the “why” of VSTS: its guiding ideas, why they are presented in certain ways, and how they fit into the process of managing the software lifecycle. This book is the next best thing to having an onsite coach who can lead the team through a consistent set of processes.

As group product planner for VSTS, Sam Guckenheimer has been the chief customer advocate for VSTS, responsible for its end-to-end external design. He has written this book as a framework for thinking about software projects in a way that can be directly tooled by VSTS. It presents essential theory and practical examples to describe a realistic process for IT projects.

Working with Microsoft Visual Studio 2005 Team System

Get a pragmatic overview of the new team-based system of products that bring Visual Studio development tools to the enterprise—allowing architects, developers, testers, and project managers to collaborate in a single, extensible development environment. With insights from the Microsoft Visual Studio product team, early users, and the author's hands-on experience, readers will understand how to use this tightly integrated set of lifecycle development tools to simplify cross-team communication, reduce development complexity, accelerate productivity, and help save time and money.