Ed Squared

Creating E-Mail Alerts for Team Members in TFS

Ed Blankenship (EdSquared.com) — Thu, 09 Feb 2012 18:48:44 GMT

In TFS 2005, TFS 2008, and TFS 2010, the alerting system has always been based on a “self-subscription” model which means if you want an e-mail alert then you need to create it for yourself. This could be problematic if new team members didn’t know about the self-subscription model. Now, you could use the Alerts Explorer from the TFS Power Tools to create e-mail alerts for other people but then those alerts are actually owned by the person creating them and not able to be managed, edited, or disabled for the person they are intended. There are other potential workarounds that people have discussed for any of the TFS versions I mentioned above. A good question on Stack Overflow has some discussion as well.

In the latest builds of the Team Foundation Service Preview (which ultimately will be features we will see in the next version of TFS – TFS 11), we can now see that administrators are able to create team alerts that help the scenario I described above. Managing personal and team alerts are exposed in Team Web Access. Notice in this Work Item alert, the new [Me] value that is available for the filter clauses.

You can also create other types of alerts like Build Alerts and Code Review Alerts.

What I also noticed is that administrators can view & troubleshoot other user’s e-mail alerts that they have created including personal alerts. That was particularly troublesome for TFS Administration in the past but should help out quite a bit for user’s who report problems in the future. An administrator can now even help craft the appropriate e-mail alert for the user using the right filters and grouping of clauses which I find to be the most commonly reported issues with creating alerts.

Ed Blankenship

Brought to you by Ed Blankenship and Ed Kisinger at EdSquared.com

Replacing Compare and Diff Tools for TFS Version Control

Ed Blankenship (EdSquared.com) — Tue, 24 Jan 2012 15:40:01 GMT

Even though the TFS product team is planning to completely replace the awful source compare experience in the next version of TFS, I need something for use with prior versions of Visual Studio including Visual Studio 2010. The new version inside of Visual Studio 11 is pretty awesome. I have actually decided on Code Compare Pro by Devart for my legacy versions. They have both a free version and a Pro version that includes a 30-day trial.

During the installation, you can specify whether you want to integrate Code Compare with the TFS tools and when you do that, it adds the relevant settings automatically to your Visual Studio options for TFS Version Control. That’s classy and a nice touch for the installer. BTW – this is the exact way you would do this manually if you have a different compare tool that you like better. There are plenty out there…

This now allows you to use your new specified tool anytime you would do a compare or merge operation even from the Windows Explorer Shell Extensions plug-in from the TFS Power Tools. It will even allow for a three-way merge & diff experience which can be quite helpful at times if you are in need of it.

Ed Blankenship

Brought to you by Ed Blankenship and Ed Kisinger at EdSquared.com

Using the Related Twitter Accounts Tag in the Tweet Button

Ed Blankenship (EdSquared.com) — Fri, 06 Jan 2012 20:31:18 GMT

If you have a site like ours, you might want to give people the opportunity to share your content socially. One of the ways you can do that is using the Tweet Button for Twitter. It’s actually super easy to implement.

One of the things you might also do is to specify “related Twitter accounts” that a user might be interested in. You would normally include your account in the “via” tag but you can give Twitter the chance to suggest additional users for a person to follow whenever they share some of your account. In my case, I may want to give people a chance to follow the account for Imaginet, the company I work for, @justimaginet. You do this by specifying the “data-related” tag in your hyperlink. You can specify as many accounts as you want but they are really just suggestions to Twitter. Take a look at the documentation mentioned below about if you want to specify multiple accounts.

Here’s an example of what I used to update the itemTemplate.blogtemplate file for my dasBlog site.

<div class="twitter-badge">
    <a href="https://twitter.com/share" class="twitter-share-button" 
        data-url="<%PermalinkUrl()|edsquared%>"
        data-text="<%ItemTitleText()|edsquared%>" data-count="horizontal" 
        data-via="<%ItemAuthorTwitterAccount()|edsquared%>"
        data-related="justimaginet:Imaginet - Microsoft ALM Partner of the Year">Tweet</a>
</div>

Give it a try out by visiting our blog site and using one of the Tweet buttons to share the content to your followers: http://www.edsquared.com

If you are wanting to research this a little more, here’s the official documentation from Twitter:

Related accounts

Using the related field you can suggest accounts for a user to follow once they have sent a Tweet using your Tweet Button. These suggested accounts and their basic information are shown on the last page of the Share Box flow.

Only two accounts are displayed and by default the via user is shown first with the first related account shown afterwards. If the user is a follower of the via user the Share Box will instead show the first two related accounts the user isn't a follower of. No accounts are displayed if the user follows all of the suggested accounts (via and related).

You can add your own summary of a related user by adding some text after their screen name, separated using a colon. For example, to add a summary The Javascript API to the related user @anywhere you would use:
data-related="anywhere:The Javascript API"
The summary is shown above the related user and is in addition to the default information like the bio and verified status. Summaries should not include commas or colons and can only be added to related accounts.

You can provide multiple related accounts by comma separating entries in the data-related value:
data-related="anywhere:The Javascript API,sitestreams,twitter:The official account"

You learn something every day…

Ed Blankenship

Brought to you by Ed Blankenship and Ed Kisinger at EdSquared.com

Awarded as Microsoft MVP for 2012

Ed Blankenship (EdSquared.com) — Wed, 04 Jan 2012 16:31:19 GMT

I’m really happy to have been awarded again for 2012 as a Microsoft Most Valuable Professional in Visual Studio ALM & TFS! This will be my fifth year as a Microsoft MVP and it’s always an honor to work with each of my colleagues in the MVP community. Very much looking forward to the MVP Summit coming up next month and continuing to help out where I can in the ALM community. Thanks to everyone who have helped me in the past few years and congratulations to all of the other new & repeat awardees of the Microsoft MVP award for this year.

I wish everyone a great new year in 2012!

Ed Blankenship

Brought to you by Ed Blankenship and Ed Kisinger at EdSquared.com

Integrating Red Gate SmartAssembly Into TFS 2010 Build

Ed Blankenship (EdSquared.com) — Tue, 27 Dec 2011 18:20:31 GMT

Updates – I plan on making updates to this blog article from time to time as I learn more and changes are made to TFS & SmartAssembly to smooth out some of the rough edges. Come back again for the latest & greatest!

I really like tools that provide assistance with the release management & maintenance cycles of ALM. I think some of the features really add a particular shine to your application. It’s something that I’m currently writing an article about but I wanted to share how to integrate one of those tools into your Team Foundation Server 2010 Build Process. This first tool to be reviewed is Red Gate’s SmartAssembly product.

SmartAssembly is a product that can help you out with obfuscation if you need it but I primarily want to focus on two of its other major features:

Automated Error Reporting – When an exception occurs, the end user can be prompted to send back the exception details so that the development team can review those details. This can also work with server-side & web applications without requiring end user prompting.
Feature Usage Reporting – This is essentially telemetry for your application to figure out how your users are using the application so that you can make good decisions in the future about where to invest for future releases. It does this by sending back anonymous data for users who opt-in at runtime. It will even automatically send back data about the machine the software is being run like the operating system. This can be extremely useful data to product managers.

You don’t have to worry about any of the details because once you run your assemblies through SmartAssembly, it instruments all of the necessary functionality automatically for you. If you acquire the Professional edition, you can customize the reporting experience including the ability to host your own web server to accept the error & feature usage reports.

Aside : Too many teams & companies have blindly adopted obfuscation for their assemblies in the past without taking into consideration the true “total cost” of obfuscating your applications. I’m all for obfuscation where it makes sense to protect IP as long as the value of the protection of that IP is worth more than the extra cost, resources, and maintenance complexity to truly support an obfuscated product. Each team & company is going to have to make that decision based on the resources available and the value of the IP to be protected – just don’t go into it blindly.

FYI – PreEmptive’s Dotfuscator tool is a competing product line with a similar feature set that I hope to be covering in a future blog post.

Ignoring obfuscation, these two features are absolutely great for gaining visibility about your application once it has been released. For all of those teams that aren’t traditional software vendors but building applications for internal use, these are great features for those applications as well. Software engineering teams building internal applications are very much in need of the same type of information as ISVs about how their internal “customers” are interacting with their applications. Internal applications don’t necessarily need obfuscation but they can definitely benefit from automated error & feature usage reporting!

One part that I absolutely love about SmartAssembly is that even though the tool instruments and changes your assembly, it also provides the ability to produce a set of matching symbols (.PDBs) that are extremely important for several scenarios in TFS, the Visual Studio ALM family of tools, as well as basic debugging.

I am going to be spending some time in this blog article to walkthrough how to integrate SmartAssembly into your automated TFS build process so that your teams can take advantage of these features. I am going to take the approach of not creating any custom workflow activities for this particular effort. Jim Lamb has a good discussion about when to make customizations to the MSBuild file (essentially the Visual Studio project file) and when to make your customizations in the Windows Workflow-based build process template. As much as I very much prefer customizing my build process templates using custom workflow activities, in this case I choose to do a little customization of both without using any custom workflow activities. I would much rather have done this using only native Windows Workflow activities but I’ll talk more about that a little later.

Disclaimer: As a Microsoft MVP, I have been a part of the Friends of Red Gate group for the last four years and I have been provided Not For Resale licenses of the Red Gate family of products though I reserve the right to offer unbiased opinions and criticisms. I was not paid for these contributions. However, I may or may not get a complimentary round the next time I see the Red Gaters at the pub in Cambridge.

Works on My Machine Disclaimer: Everything in this blog article works on my machine when I wrote it. I have the latest version of SmartAssembly and TFS 2010 installed & configured correctly. I’ve done my best to make this as reusable as possible for most team’s scenarios but I can’t tell you that it will work for you. Hopefully it gets you started on the right path though! Please don’t contact me and let me know that my code killed your cat. I feel for you… I do – I just can’t do anything about it. You’ve been warned. I take the same approach that Scott does with blog contributions.

Configuring SmartAssembly for Team Use

SmartAssembly has actually been designed out of the box to handle the single-developer team scenario. If you are using TFS, you are likely not a single-developer team so you’ll want to a few things to get SmartAssembly setup for use with a team. The architecture for SmartAssembly can best be described with this architecture diagram:

Source: http://www.red-gate.com/products/dotnet-development/smartassembly/team-package

You’ll need to get the Professional edition of SmartAssembly since it allows you to store everything in a shared SQL Server database. One nice thing is that each developer who will need to interact with error & feature usage reports only needs a Developer edition license instead of a full Professional edition license. You’ll need to install & configure the Professional edition on each of your build servers. You might as well go ahead and create a build agent tag called “SmartAssembly” to indicate which build agents in your build farm are hosted on servers that have SmartAssembly installed.

When you first start SmartAssembly, you will want to setup the desktop machines & build servers to use the same SQL connection settings for the shared SmartAssembly database. I even like to use the friendly TFS DNS names that I already have setup for my particular TFS environment. Remember that if you are using the limited use license of SQL that is included with TFS, you won’t be able to house the SmartAssembly database on that instance. You’ll need to purchase a legitimate SQL Server license. It’s a great time to upgrade to the SQL Enterprise edition if you can for TFS! TFS will definitely take advantage of several of the features.

It is pretty easy to setup from there:

Be sure to also indicate that you want to use relative paths. Relative paths will be very important when you are using it in a team environment with Team Foundation Server.

BTW, if you need to setup SmartAssembly to use SQL Authentication instead of Windows Authentication, you can do that using this particular article. You do this by basically updating the settings configuration file available on a Windows 7 machine at C:\ProgramData\Red Gate\SmartAssembly\SmartAssembly.settings.

Creating & Storing the SmartAssembly Configuration File in Version Control

I am going to make this easy by just using a quick Windows Forms application however you are able to process any type of assembly including Silverlight apps, ASP.NET web applications, class libraries, etc. using SmartAssembly.

You will want to compile your assembly at least once and then start a new SmartAssembly project. It actually doesn’t matter where the source & destination location of the assembly is set to in the configuration but you might want to pick a location that all of the developers will be using. Don’t worry about the build server locations because we will override those later in the build process! To keep it simple, I’m only going to enable the following features in my SmartAssembly configuration file:

Automated Error Reporting,
Feature Usage Reporting, and
Generate Debugging Information

You can research more on the other options that are available but I am going to keep this walkthrough very simple. Once you are satisfied with your settings, click the “Save As…” button and save the configuration file in the same folder as your Visual Studio project file. I even like to include the file in my Visual Studio project so that I can work with it and check it into the version control repository along with the rest of my project. The SmartAssembly configuration file has a “.saproj” file extension.

The next thing you might want to do is open the configuration file using the XML Editor in Visual Studio to verify all of the settings look correct. You can use the “Open With…” context menu command from the Solution Explorer window to help you out.

The main thing you want to do is be very mindful of using relative file paths everywhere in the configuration file since the location of the source code location changes on the build server & developer machines. For example, TFS Build allows you to have multiple build agents running on any build server. I might have three build agents on a build server which means three builds could be running at any given time on the build server. You isolate each build agent on a build server by setting the working directory to something that will be a unique value. The default setting is $(SystemDrive)\Builds\$(BuildAgentId)\$(BuildDefinitionName) but I usually change it to $(SystemDrive)\Builds\$(BuildAgentId)\$(BuildDefinitionId) to give me a few extra characters since we also have path length limitations to go up against.

Defining Custom MSBuild Properties

At this point, we are going to define a few custom MSBuild properties that we are going to use to trigger the SmartAssembly functionality. The table lists the properties I am going to define in this process.

Property Name	Value(s)	Description
TfsBuild	True, False	Indicates whether this build is occurring using TFS.
RunSmartAssembly	True, False	Indicates whether the SmartAssembly processing should occur after compilation.
SmartAssemblyConfigurationFileRelativePath	<Relative File Path>	Stores the relative path location to the .saproj configuration file for the project.

Modifying the Visual Studio Project Files

For many of the common project types, Visual Studio project files are in fact actually MSBuild scripts under the covers. What we are going to do is add some custom functionality at the end of the project file that we will later “turn on” during the build process. You could modify this so that you could “turn on” the functionality at development time locally but this additional script excerpt will leave it turned off during normal development.

To edit a Visual Studio Project file, you can “unload” the project from the context menu in Solution Explorer and then double-click it to open it in a new editor document window. You will add the following excerpt close to the bottom of your Visual Studio project file just before the final </Project> ending tag. In my case it is a .csproj file.

<!-- Red Gate SmartAssembly Custom Post-Compile Processing for TFS Builds -->
<UsingTask TaskName="SmartAssembly.MSBuild.Tasks.Build" AssemblyName="SmartAssembly.MSBuild.Tasks, Version=6.0.0.0, Culture=neutral, PublicKeyToken=7f465a1c156d4d57" Condition="'$(TfsBuild)' == 'True' and '$(RunSmartAssembly)' == 'True'" />
<PropertyGroup Condition="'$(TfsBuild)' == 'True' and '$(RunSmartAssembly)' == 'True'">
  <!-- Uncomment this next line if the configuration file is not located in the same directory and uses the same name as the project. -->
  <!--<SmartAssemblyConfigurationFileRelativePath>SmartAssemblyConfigurationFileName.saproj</SmartAssemblyConfigurationFileRelativePath>-->
  <!-- This will set the default name of the configuration file to the same name as the project name if the property is not defined elsewhere. -->
  <SmartAssemblyConfigurationFileRelativePath Condition="'$(SmartAssemblyConfigurationFileRelativePath)' == ''">$(ProjectName).saproj</SmartAssemblyConfigurationFileRelativePath>
</PropertyGroup>
<Target Name="AfterBuild" Condition="'$(TfsBuild)' == 'True' and '$(RunSmartAssembly)' == 'True'">
  <!-- Archiving the original compiled assembly and matching debugging symbols file. -->
  <Message Text="Archiving the original compiled assembly and matching debugging symbols file." />
  <Copy SourceFiles="@(_DebugSymbolsOutputPath)" DestinationFolder="$(OutDir)Original" Condition="'$(_DebugSymbolsProduced)' == 'true' and '$(CopyBuildOutputToOutputDirectory)' == 'true' and '$(SkipCopyBuildProduct)' != 'true'" />
  <Copy SourceFiles="@(MainAssembly)" DestinationFolder="$(OutDir)Original" Condition="'$(CopyBuildOutputToOutputDirectory)' == 'true' and '$(SkipCopyBuildProduct)' != 'true'" />
  <!-- Process Assembly through SmartAssembly -->
  <SmartAssembly.MSBuild.Tasks.Build ProjectFile="$(SmartAssemblyConfigurationFileRelativePath)" Input="@(MainAssembly)" Output="@(MainAssembly)" OverwriteAssembly="True" />
</Target>

It is a modified version of the snippet from the SmartAssembly help documentation for integrating with MSBuild: http://www.red-gate.com/supportcenter/Content/SmartAssembly/help/6.5/SA_UsingSmartAssemblyWithMSBuild. You’ll see a little later where we are going to “turn on” the functionality by editing the TFS build process template. If you named your configuration file the same name as the project name and stored it in the same location in version control you actually don’t need to modify anything in the snippet at all.

Notice that the snippet keeps the original copies of the assemblies and matching symbols (.PDB) file so that they later get copied to the TFS build’s drop folder. It is copying the original assembly and matching symbols into another subdirectory named “Original” instead of just outputting the SmartAssembly instrumented assembly & matching symbols to a subfolder called “Obfuscated”, “Instrumented”, or “Protected.” I used to use the latter approach (as some people suggest) but if you are also compiling installers, it is useful to create an installer during specific builds that include the original assemblies instead of the instrumented ones. In my installer definition (like a WiX file) I’ll just refer to the regular location and it will pickup whatever version the build process created. If I want an installer to have the original assemblies then I just queue a new build and will set the SmartAssembly process parameter to false for that build. I don’t have to do anything additional in my WiX definition files to handle this scenario.

Another side effect you get by using this approach is that if your build process runs any automated tests, static code analysis, test impact analysis, etc., then it will use the instrumented versions of the assemblies as the target of the tests and other post-processing tools! There are several ways to skin this particular cat but I have fallen back to this approach after a few years of dealing with these issues.

Modifying the Build Process Template in Windows Workflow Foundation

Technically, we could just hard-code the extra MSBuild process parameters that we need using the default TFS build process template on the Process tab of the build definition editor window:

If you are okay with this approach then you don’t really need to go any further. However, we could make this a richer experience for people who will edit and queue these builds from day to day. This is where we can go through and create a custom process template.

The first thing you will want to do is create a new build process template to start your customizations. I have included mine for download at the end of this blog post but you may want to walk along. I usually start by creating a copy of the default build process template available from TFS. If you aren’t familiar with the basics of this particular process, I would highly suggest going through the walkthrough in either of these books:

Chapter 16 – “Customizing the Build Process” - from Professional Team Foundation Server 2010 by Wrox (Wiley) – Authors: Ed Blankenship, Martin Woodward, Grant Holliday, and Brian Keller
Chapter 16 – “Process Template Customization” – from Inside the Microsoft Build Engine: Using MSBuild and Team Foundation Build - Second Edition by Microsoft Press – Authors: Sayed Hashimi and William Bartholomew

You can then change your build definition over to the newly copied build process template using the following combo box.

If you click on the hyperlink, it will take you to the location in Source Control Explorer where you can get the latest version into your workspace and then open the build process template file for editing in the Windows Workflow Foundation Designer.

Defining Build Definition Process Parameters

The first thing we can do is specify a new build process parameter that is exposed to the end user of the builds by going to the “Arguments” tab in the lower left-hand corner of the Workflow designer.

I am going to create a Boolean process parameter simply named “RunSmartAssembly” and set the default value to False. This isn’t an MSBuild property but a workflow process parameter that will be exposed to the end user when they are queuing a new build or when editing the build definition.

This next step is just to make things that much nicer. We can give the TFS Build system some additional metadata to make sure the parameter is exposed to the end user in a nice fashion. There are more details about the process parameter metadata field in either of the book chapters mentioned above in case you would like to learn more! You edit the collection information for the Metadata parameter that is already defined in the default build process template. (It’s two above the parameter we created in the previous screenshot.) Just click the ellipsis button in the default value field column to open up the metadata editor window.

Fill out the details as indicated above and save your build process template. You won’t see the changes immediately if you were to go back to the build definition editor because we haven’t checked-in the build process template back to the version control repository yet.

Verify SmartAssembly is Installed on Build Server

Whenever I architect a build that requires the use of a custom tool and it isn’t stored in version control (or even if it is but someone forgot to add that workspace mapping) I usually want to add a check in the build process to make sure that the tools are actually available to the build server. If the check doesn’t locate the tool I have it give a nice build error.

Add an If workflow activity inside the Build Agent Scope activity (labeled “Run on Agent”) but before the section that starts the compilation. It doesn’t exactly matter where as long as you get them in the agent scope but before any type of compilation begins. I am going to set my condition to something like the following:

RunSmartAssembly AndAlso Not System.IO.File.Exists(String.Format("{0}\{1}\{2}", Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "Red Gate\SmartAssembly 6", "SmartAssembly.exe"))

You can then add a Write Build Error activity with an appropriate message to indicate that SmartAssembly was not found. It should look something along the lines of this following example.

Appending Additional MSBuild Properties

We can now work on passing in the additional MSBuild properties. I’m going to do this in two steps. The first step is to append the TfsBuild MSBuild property to the pre-defined workflow variable that is used for this purpose named MSBuildArguments. I’m going to do this immediately after the workflow activities we added for the previous step using another native primitive workflow activity: Assign. It’s a super simple activity that is great for this particular purpose. The assignment expression that I am going to use for the Value parameter is:

String.Format("{0} {1}", MSBuildArguments, " /p:TfsBuild=True")

After that, we will add another If activity where the conditional will be set to the RunSmartAssembly workflow parameter we created earlier. We will also add add another Assign activity and append our remaining MSBuild property to pass into the compilation process. You can use this assignment expression for the Value parameter of the Assign activity:

String.Format("{0} {1}", MSBuildArguments, " /p:RunSmartAssembly=True")

The final sequence looks similar to the following screenshot.

You may be asking “Why did we define the $(TfsBuild) MSBuild property when we could have just used the $(RunSmartAssembly) property?” That’s a great question… You don’t need it if you aren’t going to do any additional customization. However, in general, I like to always define the $(TfsBuild) MSBuild property so that you could customize the project files to modify the conditions based on whether it is occurring during a TFS Build or if it’s occurring on a developer’s machine. It’s quite handy when you need it.

Notice that we are also performing all of the SmartAssembly processing steps before the Source Server Indexing and Symbol Server Publishing phase of the build process so that both the original symbols and the symbols that match the instrumented assemblies are published correctly to Symbol Server and have the appropriate indexing for Source Server support included in those symbols. That will be extremely useful later whenever you need to debug against either the original or instrumented assemblies in the future. You can also open IntelliTrace log files & take advantage of Test Impact Analysis if you keep obfuscation turned off in the SmartAssembly configuration.

Finale

That’s it! Just save the changes to your build process template and check the file into the version control repository so it can now be used by your build definitions. Be sure to set your new custom workflow parameter to True and then queue a new build!

You’ll now notice that it runs correctly even if you have defined for your build process to compile multiple build configurations (i.e. Debug | x86, Release | AnyCPU, etc.)

Potential Improvement Areas

Licensing & Activation for Build Servers – Unfortunately, the way SmartAssembly is licensed you have to purchase a license for each of the build servers you might have and activate the software on those build servers. The accompanying side effect is that the developer licenses are cheaper.
This can be problematic in a TFS environment where you might have a build farm that has one build controller with 20 build servers that have three agents on each of those build servers. It’s not that SmartAssembly would be used at the same time on all 60 of those build agents but you also don’t know which build agent will be reserved for a particular build at any given time. I have resorted to using the build agent tagging feature of TFS Build to handle making sure particular builds only reserve an agent with SmartAssembly configured & activated. However, this causes a complete underuse of the hardware resources available in a build farm.
I would rather tool vendors achieve their revenue targets by increasing the per-user license fee because and specifically for users who benefit from the advantages that the particular tool brings to them. This licensing model if very similar to how the Visual Studio & third-party components licensing model works. Microsoft and other third-party component vendors give you the ability to install and use the their tools on a build server without charge.
I consider build agent machines throw-away machines. They should remain completely clean but don’t need to be backed up or monitored. I usually will have a virtual machine base image that has everything already installed & ready to go so that I can add/remove to the build farm “pool” as needed. I even prefer to throw away machines after 30 days and bring new build agents online to ensure the whole build farm is kept as clean as possible. When you have tools that require activation & licensing, this scenario quickly becomes problematic. This leads me to another potential area for improvement.
Installation on Build Servers – If you know me well, this is a slightly less critical criticism than the first bullet point but also a pretty big pet peeve of mine. If you make tools, please don’t require them to be installed on the build server. It’s another thing that has to be kept up to date on potentially many machines and in a base system image. I would rather be able to check them into a known version control folder and then have the build servers download the latest version during the build process. There is even a supported mechanism in TFS Build that allows the build controllers & agents to watch for custom assemblies & tools and whenever it notices a new version of those assemblies then it gracefully updates all of the machines in the build farm automatically. This allows team members to focus & introduce changes to the tools using version control instead of having to update the base image of the build server every time there is a new update.
You also benefit from having full auditing of what exact tools version were used to produce a specific set of assemblies. That allows you to potentially recreate a build you created a year ago by simply specifying what version of the source code (including build tools) to use during that build process.
Native Workflow Activity for TFS 2010 Build Process Templates - The process I described in this blog article is definitely much more difficult than what it could be. Instead of introducing customizations in the MSBuild-portion of the TFS build process, I much rather prefer dropping in a native workflow activity after the compilation process. SmartAssembly unfortunately doesn’t have a custom TFS build workflow activity at this time. I would love to see one that allowed me to specify multiple assembly inputs for each build configuration that occurs in the build process and then the appropriate SmartAssembly configuration file for each of the assemblies. You can do some nice things with it to really make this process super easy.
Database Endpoint Instead of a Web Service Layer – SmartAssembly requires the entire team to have access to the centralized database to manage the automated error & feature usage reports. The software makes direct database calls instead of going through a service layer is which is very different from the way that tools built for TFS are designed in general. This can be problematic especially if you have TFS setup for your team to be able to access remotely over HTTPS (port 443) without the use of a VPN. Several IT organizations,really don’t want to open their database ports or even give access to production database instances. My suggestion would be to have an intermediate service layer that can “integrate” with the existing TFS IIS web sites. This allows the tool’s service layer to piggy back on the existing infrastructure already setup for TFS. If you have an SSL certificate and HTTPS configured, then you can take advantage of it. If you have load balancing setup for scalability, then you could potentially leverage that as well! We did this with our Notion Timesheet for TFS tools and one of the benefits we end up getting is that we are able to access the service layer from anywhere we can access TFS including over the Public Internet. No worries about giving people access to the SQL Server instance as well.
Source Server Support – This isn’t necessarily a TFS-specific topic but really something for anyone using build servers & Source Server indexing. When you compile on a build server, the location of the source code is included in the symbol information. Your developers will normally not download the source code to the same location as other developers and particularly not the same location that the build server does since that changes depending on what TFS build agent is used on a build server for any particular TFS build. Source Server Indexing helps to combat this particular problem by replacing the physical location with the location in the version control repository including the branch and version of the code used. SmartAssembly has a feature that allows you to review details of stack trace, object values, etc. when you open an error report. However, it doesn’t use the Source Server information even if it is stored in the symbol files. This is particularly a problem when you are in a TFS environment and using automated builds. SmartAssembly just ignores those additional streams in the symbols file. SmartAssembly should use the Source Server information if it exists in the symbols to pull the appropriate version of source code from the version control repository. (Red Gate Support Ticket Number: F0041570)
Additional ALM Integration with TFS – There are so many different areas where SmartAssembly could shine if it had some additional ALM-specific integration with TFS!

Download Process Template

If you are interested in downloading the completely customized version of the build process template, I have included a link to it below.

Download SmartAssembly Process Template

Take care,

Ed Blankenship

Brought to you by Ed Blankenship and Ed Kisinger at EdSquared.com

Blog Site Theme Update

Ed Blankenship (EdSquared.com) — Thu, 17 Nov 2011 19:37:05 GMT

For the folks that are using an RSS reader, you might not have noticed the quiet update on the EdSquared.com site’s blog theme. It sure does make your day that much better when things are feeling a lot better on your site. A fresh & new blog design is one way you can brighten your day!

I just wanted to mention that Jeremy Kratz does some really great work and was very much a pleasure to work with. His portfolio includes some other great work like Stack Overflow and Scott Hanselman’s blog site.

Some of the large goals I had were mainly around:

Great Reading Experience for Mobile Devices
New Standards-Compliance
Looking the Same Across All Modern Browsers & Versions
Ability to Easily Make Modifications for Static Content in the Future

One of the side effects of this work is that those heading to the site using Internet Explorer 6 have a horrible experience. I’m okay with that. IE6 users probably know that they need to be getting over to a modern browser already. Thankfully – I don’t have that many folks using IE6 so thank you for making that decision easy. According to recent metrics, it’s not even in the top 10 and it’s only 0.66% of page views.

Hope you end up liking it!

Ed Blankenship

Brought to you by Ed Blankenship and Ed Kisinger at EdSquared.com

Deploying Visual Studio 2008 ClickOnce Projects in TFS 2010 Build

Ed Blankenship (EdSquared.com) — Thu, 27 Oct 2011 15:55:01 GMT

I wanted to wring my hair on this one… but it was actually rather simple to get solved. I’m helping a customer this week upgrading their server to TFS 2010 from TFS 2008. They had TFS 2008 builds compiling & publishing Visual Studio 2008 solutions & builds. When you upgrade to TFS 2010, those existing build definitions will end up using the UpgradeTemplate.xaml build process template in TFS 2010. Not a problem there. This customer was not able to upgrade their solutions & projects immediately to Visual Studio 2010 in tandem with the TFS 2010 upgrade. That should normally not be a problem but having done a few of these upgrades, I know that I usually need to set out some time just to get the existing builds working again. There’s always something wrong. Never huge but enough to irritate you after an upgrade.

We went through a few hurdles to get those solutions & projects compiling and then we moved on to the deployment builds. They seemed to just work which was great! In their legacy TFSBuild.proj files, they had an entry in the AfterCompile MSBuild target essentially like this:


            <
            MSBuild Projects="$(SolutionRoot)\Branch\ClickOnceProject.csproj" 
Properties="PublishDir=\\FILESERVER\ClickOncePublishPath\;ApplicationVersion=$(VersionNumber);"
Targets="Publish" />

It was great until we went to go actually fire up the app… CRASH! It is complaining in the ClickOnce deployment log that the deployment manifest wasn’t semantically valid and that the deployment manifest was missing the <compatibleFrameworks> node. Here’s the full (redcated) log: (emphasis mine)

PLATFORM VERSION INFO
    Windows             : 6.1.7601.65536 (Win32NT)
    Common Language Runtime     : 4.0.30319.239
    System.Deployment.dll         : 4.0.30319.1 (RTMRel.030319-0100)
    clr.dll             : 4.0.30319.239 (RTMGDR.030319-2300)
    dfdll.dll             : 4.0.30319.1 (RTMRel.030319-0100)
    dfshim.dll             : 4.0.31106.0 (Main.031106-0000)

SOURCES
    Deployment url            : http://webserver/ClickOnceProject.application
                        Server        : Microsoft-IIS/6.0
                        X-Powered-By    : ASP.NET
    Application url            : http://webserver/Application%20Files/ClickOnceProject_1_1_1_1/ClickOnceProject.exe.manifest
                        Server        : Microsoft-IIS/6.0
                        X-Powered-By    : ASP.NET

IDENTITIES
    Deployment Identity        : PolicyManagement.application, Version=1.11.1026.3, Culture=neutral, PublicKeyToken=3801d6f74f2e8cd7, processorArchitecture=x86
    Application Identity        : PolicyManagement.exe, Version=1.11.1026.3, Culture=neutral, PublicKeyToken=3801d6f74f2e8cd7, processorArchitecture=x86, type=win32

APPLICATION SUMMARY
    * Online only application.
    * Trust url parameter is set.
ERROR SUMMARY
    Below is a summary of the errors, details of these errors are listed later in the log.
    * Activation of http://webserver/ClickOnceProject.application resulted in exception. Following failure messages were detected:
        + Deployment manifest is not semantically valid.
        + Deployment manifest is missing <compatibleFrameworks>.

COMPONENT STORE TRANSACTION FAILURE SUMMARY
    No transaction error was detected.

WARNINGS
    There were no warnings during this operation.

OPERATION PROGRESS STATUS
    * [10/26/2011 1:49:41 PM] : Activation of http://webserver/ClickOnceProject.application has started.
    * [10/26/2011 1:49:42 PM] : Processing of deployment manifest has successfully completed.
    * [10/26/2011 1:49:42 PM] : Installation of the application has started.
    * [10/26/2011 1:49:42 PM] : Processing of application manifest has successfully completed.

ERROR DETAILS
    Following errors were detected during this operation.
    * [10/26/2011 1:49:43 PM] System.Deployment.Application.InvalidDeploymentException (ManifestSemanticValidation)
        - Deployment manifest is not semantically valid.
        - Source: System.Deployment
        - Stack trace:
            at System.Deployment.Application.PlatformDetector.VerifyPlatformDependencies(AssemblyManifest appManifest, AssemblyManifest deployManifest, String tempDir)
            at System.Deployment.Application.ApplicationActivator.DownloadApplication(SubscriptionState subState, ActivationDescription actDesc, Int64 transactionId, TempDirectory& downloadTemp)
            at System.Deployment.Application.ApplicationActivator.InstallApplication(SubscriptionState& subState, ActivationDescription actDesc)
            at System.Deployment.Application.ApplicationActivator.PerformDeploymentActivation(Uri activationUri, Boolean isShortcut, String textualSubId, String deploymentProviderUrlFromExtension, BrowserSettings browserSettings, String& errorPageUrl)
            at System.Deployment.Application.ApplicationActivator.ActivateDeploymentWorker(Object state)
        --- Inner Exception ---
        System.Deployment.Application.InvalidDeploymentException (InvalidManifest)
        - Deployment manifest is missing <compatibleFrameworks>.
        - Source:
        - Stack trace:

COMPONENT STORE TRANSACTION DETAILS
    No transaction information is available.

Now what I remember is that the <compatibleFrameworks> node was actually introduced in the deployment manifests for .NET / ClickOnce 4.0 in Visual Studio 2010 and we shouldn’t be expecting them for Visual Studio 2008 ClickOnce projects. Sounds like the build process is not picking up the right version. In the TFS 2010 version of the TeamFoundationBuild.targets file, it handles compilation correctly by setting the appropriate MSBuild tools version number. Why wasn’t it picking that up for our publish?

Oh yeah… since TFS 2010 build had to specify it for the legacy UpgradeTemplate.xaml and TeamFoundationBuild.targets files, we have to do the same thing. Duh. It ended up being an easy fix and we just updated that portion of the legacy TFSBuild.proj build script to explicitly set the MSBuild tools version and pass in the framework version as well for the ClickOnce project.


            <
            MSBuild ToolsVersion="3.5" Projects="$(SolutionRoot)\Branch\ClickOnceProject.csproj"
 Properties="ClrVersion=2.0.50727.0;PublishDir=\\FILESERVER\ClickOncePublishPath\;ApplicationVersion=$(VersionNumber);"
 Targets="Publish" =""/>

BTW – you can do this in the new Windows Workflow-based build process templates as well but instead you would use the MSBuild workflow activity.

However, I would highly suggest upgrading to Visual Studio 2010 when you get a chance since it will handle ClickOnce projects that target .NET 2.0, .NET 3.0, .NET 3.5, and .NET 4.0 seamlessly.

Now that all of the legacy TFS 2008 builds are working in TFS 2010, it’s time to start helping my current customer get their Visual Studio 2008 solutions & projects upgraded to Visual Studio 2010 and leverage the new Windows Workflow-based build process template!

Ed Blankenship

Many thanks to Josh Winfree for helping out with the discover of this one!

Brought to you by Ed Blankenship and Ed Kisinger at EdSquared.com

Free ALM Roadshow Events in 2011

Ed Blankenship (EdSquared.com) — Wed, 26 Oct 2011 20:56:00 GMT

I’m pretty happy to be heading out in a few weeks to lead a few ALM Road Show Events around the US. There’s actually several more that are going to be led by others on the Imaginet ALM team (Dave McKinstry & Anna Russo) so find one that’s close to you and bring your questions! I’ll be leading the ALM Road Show events in:

Boston, MA
Atlanta, GA
Dallas, TX
Houston, TX

Here’s the full list of the Roadshow Events:

Visual Studio 2010 ALM Tools Live Roadshow
October 27,2011
Microsoft Corporation
St.Louis, MO

Visual Studio 2010 ALM Tools Live Roadshow
October 28, 2011
Microsoft Corporation
Columbus, OH

Visual Studio 2010 ALM Tools Live Roadshow
November 2, 2011
Microsoft Corporation
Salt Lake City/Lehi, UT

Visual Studio 2010 ALM Tools Live Roadshow
November 3, 2011
Microsoft Corporation
Irvine, CA

Visual Studio 2010 ALM Tools Live Roadshow
November 8, 2011
Microsoft Corporation
Presenter: Ed Blankenship
Waltham, MA

Visual Studio 2010 ALM Tools Live Roadshow
November 9, 2011
Microsoft Corporation
Presenter: Ed Blankenship
Alpharetta, GA

Visual Studio 2010 ALM Tools Live Roadshow
November 29, 2011
Microsoft Corporation
Presenter: Ed Blankenship
Dallas/Irving, TX

Visual Studio 2010 ALM Tools Live Roadshow
November 30, 2011
Microsoft Corporation
Denver, CO

Visual Studio 2010 ALM Tools Live Roadshow
December 1, 2011
Microsoft Corporation
Presenter: Ed Blankenship
Houston, TX

If you can’t visit us at the local ALM Roadshow events, try out some of the ALM Webcasts we are doing! Dave McKinstry has a full write up of each of them available here: http://weblogs.asp.net/dmckinstry/archive/2011/10/13/upcoming-free-vs-alm-webcasts.aspx

Test Management in Agile Teams
October 24, 2011
Free Online Workshop
1:00-2:00pm (CST)

Manual Testing in Agile Teams
October 26, 2011
Free Online Workshop
1:00-2:30 (CST)

Testing in an Agile Team
November 1, 2011
Free Online Workshop
1:00-2:30pm (CST)
Automated Load and UI Testing for SharePoint Projects
December 6, 2011
Free Online Workshop
1:00-2:30pm (CST)

Testing with SharePoint Projects
December 12, 2011
Free Online Workshop
1:00-2:30pm (CST)

Using Lab Management with SharePoint Development
December 13, 2011
Free Online Workshop
1:00-2:00pm (CST)
Automated Load and UI Testing for SharePoint Projects
December 20, 2011
Free Online Workshop
1:00-2:30pm (CST)

Take care and hope to see you there!

Ed Blankenship

Brought to you by Ed Blankenship and Ed Kisinger at EdSquared.com

August 2011 – New TFS 2010 Power Tools Released

Ed Blankenship (EdSquared.com) — Fri, 19 Aug 2011 15:34:39 GMT

A new TFS 2010 Power Tools release is now available! As always, I recommend that all team members (including those with only Team Explorer installed) to have the latest version of the TFS 2010 Power Tools installed.

I won’t go into too many details about all of the new features since Brian Harry has done a great job of explaining each of the new features in the release on his blog. There are a few that are worth noting though!

One of the new features is “Rollback of a Changeset” in the Team Explorer UI. You have been able to rollback a changeset in TFS 2010 without the Power Tools but it was something that you had to do from the command-line. Another handy feature is comparing two build definition’s using the tfpt.exe builddefinition /diff tool that is now available. You can also use tfpt.exe builddefinition /dumpto give you a nice listing of all of a build definition’s details.

If you hated having to uninstall a Power Tools release before you could install a new version in the past, we don’t have to worry about it any longer! You can now fire up the installer for newer versions and it will upgrade the previous version appropriately. No excuses now for not having the latest version installed.

For all of those that wished they could just search through some work items, we finally have “the search box” that we have all been waiting for! Look at the help file (C:\Program Files (x86)\Microsoft Team Foundation Server 2010 Power Tools\Help\WorkItemSearch.mht) for some interesting tricks & tips you can use to make searching for work items quicker for you.

Ed Blankenship

Brought to you by Ed Blankenship and Ed Kisinger at EdSquared.com

Speaking at Austin TFS User Group – Customizing TFS Builds

Ed Blankenship (EdSquared.com) — Tue, 02 Aug 2011 22:41:26 GMT

I’m pretty excited about being in Austin this week (one of my favorite cities) and while I’m here, I’m going to be speaking at the Austin TFS User Group this Thursday night. Here are some more details:

Special Event: TFS 2010 Build Customization with Ed Blankenship

Date: Thursday, August 4th, 6:30 to 8 PM at Overwatch Systems, 5301 SW Parkway

To attend please register at: http://tfsaustinbuild.eventbrite.com/

Don't miss this one-time event and deep dive on "Customizing the Build Process with TFS 2010 Build and Workflow Foundation." In TFS 2010, the automated build infrastructure has been revamped to use Windows Workflow Foundation (WF) instead of MSBuild. Ed will present and answer questions on how to customize the default build process template and how to leverage multiple aspects of the workflow implementation for TFS 2010 Build.

Location:

Overwatch Systems, 6:30 to 8 PM

NOTE: park in the parking garage, signs will direct you to the meeting

5301 Southwest Parkway

Austin, TX 78735

Looking forward to seeing everywhere in the area there!

Ed Blankenship

Brought to you by Ed Blankenship and Ed Kisinger at EdSquared.com

First Release of Community TFS Build Extensions

Ed Blankenship (EdSquared.com) — Wed, 06 Jul 2011 16:48:52 GMT

Wow – I’ve been seeing the discussions in the last few weeks from the team members but I’m happy to announce that they have done a great job and released the first release of the Community TFS Build Extensions on CodePlex! There have been several months of effort put into putting this collection together and you’ll see some of the best contributors that are available. You’ll find all sorts of custom build activities and there are many more included on the backlog. Be sure to vote for you favorite. The best part of this CodePlex project is that the source code is fully available for your use internally.

Release Notes

This is our first Stable release providing in the region of 100 Activities / Actions

This release contains assemblies and a CHM file.

We anticipate shipping every 2 to 3 months with ad-hoc updates provided to the documentation.

We welcome your candid and constructive feedback and look forward to improving the quality with and for you.

Please use the Discussion and Issue Tracker tabs for providing feedback.

The Visual Studio ALM Rangers have also released a set of guidance documents for customizing builds in TFS 2010 including the use of the Community TFS Build Extensions. Check out more details here: http://blogs.msdn.com/b/willy-peter_schaub/archive/2011/06/17/toc-build-customization-guide-blog-posts-and-reference-sites.aspx

If you are looking for a book with information about how to customize build definitions, check out Professional Team Foundation Server 2010 as well which goes through one example which uses an activity from the Community TFS Build Extensions to stamp the version number on assemblies.

Ed Blankenship

Brought to you by Ed Blankenship and Ed Kisinger at EdSquared.com

Visual Studio ALM and TFS vNext Announcements at TechEd 2011

Ed Blankenship (EdSquared.com) — Mon, 16 May 2011 14:45:42 GMT

I’m here at Microsoft TechEd 2011 North America and just wanted to fill you in on some of the news coming about in the TFS and Visual Studio ALM space for the next major release.

Stakeholder Feedback Tools

Storyboarding Assistant – Add-In for PowerPoint that allows for rich storyboarding
“Feedback Tool” – Very similar to Microsoft Test Runner in Microsoft Test Manager and allows for stakeholders to perform feedback sessions and collect rich data. Easy to provide rich feedback including creating bugs in the Feedback Session

Collects Audio & Video Recording
Action Step

Microsoft Test Manager – “Create Test Case from Bug”

Additional Agile Planning Tools

New Team Web Access (TWA) for TFS (Metro UI)
“Teams”
Product Backlogs in New Team Web Access – Re-prioritizing quickly and live updates
Sprint Backlogs in New Team Web Access

Capacity Planning (by Team and Person)
Work Breakdown into Tasks
Moving Backlog Items to New Sprints (Drag & Drop)

New Task Board

State Changes Using Drag & Drop (Cameron even showed a touch-enabled monitor)

Iteration/Sprint Burndown Charts in New Team Web Access

New “Team Navigator” Window in Visual Studio

“Pause” Working with Visual Context Saving
“Start” Working on New Task

Tracks individually edited files with pending changes. Allows checking-in just those files that were edited for that new work session.

“Resume” Working on Previous Task and Resets Visual Studio Context

Code Review Tools (Just Mentioned by Cameron)
Tools for Interacting with the Operations Team

Based on System Center
“TFS Connector”
Escalate Monitoring Issues to Engineering Team in TFS
Create Rich Work Item in TFS with Collected Information from Production
Shows TFS Work Item ID in System Center
Full Call Stack, Parameters, Navigate to Source Code
IntelliTrace Logs from Production!

Rich Text in Work Items Including Screenshots & Pictures (Shown with Feedback Collection Tool)

More information about each of them coming soon! I’ll update as more information is publicly announced.

If you are in town for the conference and want to learn more, there are several great sessions that you can attend as well as meeting up with several of the MVPs and Microsoft product team members at the TFS and Visual Studio ALM booths in the Exhibition Hall. Come find us and we’ll be happy to chat!

Ed Blankenship

Brought to you by Ed Blankenship and Ed Kisinger at EdSquared.com

Project Server 2010 and TFS 2010 Integration VM with Labs

Ed Blankenship (EdSquared.com) — Thu, 21 Apr 2011 13:22:47 GMT

I’m pretty excited that a new virtual machine is now available that has everything you need to start working with the integration between Project Server 2010 and Team Foundation Server 2010 SP1. A lot of work by a good group of people has gone in to get this VM out and now it should be super easy to learn & play with the integration. Not only is everything setup and configured already (which is half the battle when trying out new things) but you also get:

Four hands on labs that walk through the main scenarios that are supported by the integration.

One of them that is particular interesting is how to give visibility to the Project Management Office (PMO) when you have development teams practicing one of the many Agile methodologies. Those two concepts can come at odds with one another and I think the integration plays nicely with that scenario if your company finds itself in this position.

Tons of sample active directory users that are available in both Team Foundation Server and the Project Server Enterprise Resource Pool that allow you to setup lots of different scenarios.
Sample data, team projects, and enterprise project plans to get you started.

If you are interested more about this topic and are attending TechEd North America, be sure to catch our talk: Application Lifecycle Management: Microsoft Project Server 2010 and Microsoft Team Foundation Server 2010, Better Together

Both Brian Keller and Christophe Fiessinger have some additional information available on their blogs:

Virtual Machine Download Details

Download for the Virtual Machine

Here’s some other resources if you are interesting in learning more:

Have fun!

Ed Blankenship

Brought to you by Ed Blankenship and Ed Kisinger at EdSquared.com

Speaking at TechEd North America 2011 - TFS and Project Server ALM Integration

Ed Blankenship (EdSquared.com) — Thu, 17 Mar 2011 04:16:26 GMT

Really excited to announce that Christophe Fiessinger and I will be speaking at TechEd North America 2011 about the new ALM integration between Team Foundation Server and Project Server! Here is the session details so be sure to add it to your conference schedule: http://northamerica.msteched.com/topic/details/OSP203?fbid=8_iz7QOIYNT#showdetails

OSP203 Application Lifecycle Management: Microsoft Project Server 2010 and Microsoft Team Foundation Server 2010, Better Together

Session Type: Breakout Session

Level: 200 – Intermediate

Track: Office & SharePoint

Speakers: Christophe Fiessinger, Ed Blankenship

The Microsoft Visual Studio Team Foundation Server 2010 and Project Server Integration Feature Pack further strengthens the Microsoft Application Lifecycle Management Solution by bridging the gap between Project Portfolio Management and Application Development. By bringing the best of these two worlds together, it creates a win-win situation that enables developers and project managers to use the tools and processes of their choice and collaborate at the granularity they desire. Bi-directional data synchronization between Team Foundation Server and Project Server allows the PMO and Development teams to share project information transparently and provide management with insight into resource utilization, portfolio execution and alignment with strategic objectives. This session provides an overview and demonstrates the Team Foundation Server and Project Server Integration feature pack.

Product/Technology: Microsoft® Visual Studio® Team Foundation Server

Key Learning: How to bridge the gap between agil/scrum and waterfall teams by facilitating better coordination

Ed Blankenship

Brought to you by Ed Blankenship and Ed Kisinger at EdSquared.com

Book – Professional Team Foundation Server 2010 from Wrox

Ed Blankenship (EdSquared.com) — Sat, 05 Mar 2011 17:04:04 GMT

I am really pleased to announce that we have finished our new book for Team Foundation Server 2010! I really want to thank all of the authors (Martin Woodward, Grant Holliday, and Brian Keller) as well as all of the technical editors (Mickey Gousset and Steve St. Jean) for all of their hard work that was put into this book over the past ten months. I also wanted to thank Brian Harry for his help by writing a great foreword for the book. We would love for you to get a copy and let us know what you think! It’s really not so much for the royalties but more to let our publisher know that you are interested in future books about Team Foundation Server.

I have some additional information below about the book and I’ll come back and update this blog post as I get even more information.

ISBN: 978-0470943328

Availability

Paperback	http://bit.ly/TFS2010Book	Now!
DRM-Free PDF	http://bit.ly/TFS2010BookPDF	Now!
Amazon Kindle	http://bit.ly/TFS2010BookKindle	Now!
Apple iBooks	TBD	TBD
Google Books	http://bit.ly/TFS2010BookGoogle	Now!

Promotional Code

We are also pretty excited to announce that Wiley has put together a promo code that will allow you to order either the printed copy or the DRM-free PDF copy of the book for 40% off. Here are the details for that promo code: To purchase, call 1-877-762-2974 and mention promo code WPTFS, or go to www.wrox.com (http://bit.ly/gwnw9G) and upon checkout, enter WPTFS in the Promotion Code field. Click the “apply discount” button and finish the checkout process. Offer valid until May 31^st, 2011.

Source Code Downloads

We have put together a source code download package and it is available from here: http://www.wrox.com/WileyCDA/WroxTitle/Professional-Team-Foundation-Server-2010.productCd-0470943327,descCd-DOWNLOAD.html

Sample Chapters

Wrox will have two chapters available to download for free.

Chapter 6 – Using Team Foundation Version Control (60 pages)
Chapter 17 – Introduction to Team Foundation Server Administration (34 pages)

Book Description

Authoritative guide to TFS 2010 from a dream team of Microsoft insiders and MVPs!

Microsoft Visual Studio Team Foundation Server (TFS) has evolved until it is now an essential tool for Microsoft s Application Lifestyle Management suite of productivity tools, enabling collaboration within and among software development teams. By 2011, TFS will replace Microsoft s leading source control system, Visual SourceSafe (VSS), resulting in an even greater demand for information about it. Professional Team Foundation Server 2010, written by an accomplished team of Microsoft insiders and Microsoft MVPs, provides the thorough, step-by-step instruction you need to use TFS 2010 efficiently so you can more effectively manage and deliver software products in an enterprise.

Provides a broad overview of Team Foundation Server for developers, software project managers, testers, business analysts, and others wanting to learn how to use TFS

Gives TFS administrators the tools they need to efficiently monitor and manage the TFS environment

Covers core TFS functions including project management, work item tracking, version control, test case management, build automation, reporting, and more

Explains extensibility options and how to write extensions for TFS 2010

Helps certification candidates prepare for the Microsoft Team Foundation Server 2010 certification exam (Exam 70-512)

The clear, programmer-to-programmer Wrox style of Professional Team Foundation Server 2010 will soon have you thoroughly up to speed.

Authors

Ed Blankenship is an ALM consultant with Notion Solutions and the Microsoft MVP of the Year (Visual Studio ALM & Team Foundation Server)
Martin Woodward is a program manager on the Microsoft Visual Studio Team Foundation Server product team and a former Microsoft MVP of the Year (Visual Studio Team System & Team Foundation Server)
Grant Holliday is a program manager on the Microsoft Visual Studio Team Foundation Server product team and a former Microsoft MVP (Visual Studio Team System & Team Foundation Server)
Brian Keller is a senior technical evangelist for Microsoft, specializing in Visual Studio, ALM, and Team Foundation Server

Foreword by Brian Harry
Introduction
Part I: Getting Started
- Chapter 1: Introducing Team Foundation Server 2010
- Chapter 2: Planning a Deployment
- Chapter 3: Installation and Configuration
- Chapter 4: Connecting to Team Foundation Server
Part II: Version Control
- Chapter 5: Overview of Version Control
- Chapter 6: Using Team Foundation Version Control
- Chapter 7: Ensuring Code Quality
- Chapter 8: Migration from Legacy Version Control Systems
- Chapter 9: Branching and Merging
- Chapter 10: Common Version Control Scenarios
Part III: Project Management
- Chapter 11: Introducing Work Item Tracking
- Chapter 12: Customizing Process Templates
- Chapter 13: Reporting and SharePoint Dashboards
Part IV: Team Foundation Build
- Chapter 14: Overview of Build Automation
- Chapter 15: Using Team Foundation Build
- Chapter 16: Customizing the Build Process
Part V: Administration
- Chapter 17: Introduction to Team Foundation Server Administration
- Chapter 18: Scalability and High Availability
- Chapter 19: Disaster Recovery
- Chapter 20: Security and Privileges
- Chapter 21: Monitoring Server Health and Performance
- Chapter 22: Testing and Lab Management
- Chapter 23: Upgrading from Earlier Versions
- Chapter 24: Working with Geographically Distributed Teams
- Chapter 25: Extending Team Foundation Server

Bulk Orders

If you are purchasing in bulk, feel free to contact me using the Contact Me link on my blog and I can get you the details for purchasing bulk orders directly from Wiley.

Ed Blankenship

Brought to you by Ed Blankenship and Ed Kisinger at EdSquared.com

Lab Management Deploy TFS Build Process Process Template for Physical Environments

Ed Blankenship (EdSquared.com) — Sat, 19 Feb 2011 13:19:30 GMT

With the Lab Management features of Visual Studio 2010 and Team Foundation Server 2010, you can create a build definition that deploys a build to a virtual environment being managed by Lab Management. However, it doesn’t work if you have setup a physical environment that is being managed by Lab Management.

FYI – If you don’t have servers to host Hyper-V machines you can create “physical environments” and register them for use with Lab Management. This allows testers to run tests and collect information coming from those physical environments just as they would from the virtual environments. This is a good intermediate step for those organizations wanting to take advantage of Lab Management, haven’t invested in the virtual infrastructure necessary, and want to leverage existing physical environments (like QA, DEV, Staging, etc.).

Darshan, from the Lab Management product team at Microsoft, released a new build process template (XAML) file that adds limited support for deploying to physical environments and is similar to the standard deploy build process template available out of the box. However, there are some shortcomings in that implementation including not being as rich of an experience since it doesn’t use a custom designer.

Not a problem… Colin Dembovsky who is one of our newer ALM/TFS Consultants at Notion Solutions helping customers in South Africa has put together a Lab Management deploy build process template for physical environments that attempts to address those shortcomings and provides for a rich experience that is similar to the experience that is used for deploying to virtual environments.

Check it out! http://colinsalmcorner.blogspot.com/2011/02/build-deploy-test-workflow-for-physical.html

Ed Blankenship

Brought to you by Ed Blankenship and Ed Kisinger at EdSquared.com

Source Server and Symbol Server Support in TFS 2010

Ed Blankenship (EdSquared.com) — Sat, 12 Feb 2011 00:40:56 GMT

As Jim Lamb announced in June 2009, TFS 2010 introduces support for Source Server and Symbol Server as part of the default automated build process template. This is a really key feature addition but I have found that many developers ask about why it would be so important and why it would help them. Ultimately, we are starting to have more and more tools that need access to the symbol file information and the original source code that was used for compilation. For example, some of the tools that come to mind are:

Visual Studio Debugging including the Remote Debugger
IntelliTrace
Visual Studio Profiler
WinDBG

By setting up Source Server and Symbol Server support during your build process, you’ll be able to work with assemblies & executables that come from the build servers and still use tools that need information from them.

What are Symbols?

John Robbins has an excellent blog post to get started about learning what symbols are titled: “PDB Files: What Every Developer Must Know.” I highly recommend you take a moment to read through it.

So to summarize from John’s article, the symbol files are the .PDB files that match a particular assembly and contain important information that’s necessary for debugging tools. Specifically for .NET assemblies, the symbol files include:

Source File Names and Line Numbers
Local Variable Names

He also reminds us one very important statement about symbol files: “PDB files are as important as source code!” That is absolutely true! I cringe any time I hear from a developer that says “oh, those .PDB files take up so much space so I’m going to delete them.” Ouch – The sad thing is those are developers that keep people like John in business whenever they run into problems in production. Save yourself some time, money, and effort and keep your symbol files around. Not to say that John doesn’t earn every penny but I’m sure his life is much better whenever you do have your symbols!

This is exactly where Symbol Server helps out. Essentially, the Symbol Server is a central location for your company that keeps the .PDB files for you. Therefore, you can install your application (without symbols) that was compiled from a build server and whenever you want to use a debugging tool like Visual Studio, it will know how to contact the Symbol Server location to get the matching set of symbols. More about how to configure Visual Studio to look for a Symbol Server further down in this blog post.

John also mentions how to manually perform the steps necessary for completing the loop with Source Server and Symbol Server. Thankfully, since you are using TFS 2010 Build, you don’t have to go through those steps. The functionality is included in the default build build process template (but not the Upgrade Template).

Aside: If you are performing obfuscation using your favorite .NET obfuscation utility, you will want to make sure you produce symbol files that match the newly created assemblies. This is because the variable names and other information change by the obfuscator. What I will normally do will do is keep both the original assemblies with their matching symbol files in addition to the obfuscated assemblies with match symbol files. I store the artifacts for the obfuscated assemblies in a sub-folder called “Obfuscated.”

How to Setup Symbol Server

A common misconception about Symbol Server is that you actually have to set up a server and install the Symbol Server software. Not at all! All you have to do is setup a file share on another server. If you are using my suggestion about using friendly DNS names with TFS, you might extend that for the symbol server as well:

\\symbols.contoso.local\Symbols

On my particular demonstration machine, I have a local file share that contains some of the symbols that were published from my TFS 2010 Builds:

How to Configure Build to Index for Source Server and Publish to Symbol Server

Configuring the build definition to use the new Symbol Server location, couldn’t be easier. Open up the build definition editor and navigate to the Process tab. There, you will see all of the process parameters. If you are using the default build process template then you will find the Source Server and Symbol Server settings underneath the “2. Basic” category as shown below.

The build process will then do all the work for you!

Source Server Indexing

What actually happens when the build process is actually running it’s Source Server indexing? Let me first start by discussing the problems with symbols that come from a build server (or another machine.) One of the pieces of information that is stored inside of the symbol file is the location of the original source file that was used for compilation into the assembly you are debugging. This can be a problem because for my particular case, the local location of the source code file on the build server is:

C:\LocalBuilds\1\2\Sources\Source\Calculator\Calculator\Form1.cs at version 32 from the MAIN branch

Not only do you to have put all of the source files in the same exact spot but you would have to get it from the right branch and even the exact same changeset version from the TFS version control repository. That’s a lot of manual work… This is where the indexing for Source Server helps you out. You’ll also notice that if you are producing symbols from your obfuscation utility, those can indexed for Source Server support as well.

When the TFS 2010 Build runs the source indexing for Source Server, it writes an alternate stream of information in the symbol files that will provide the following information for each source file:

Source Control provider’s information and the command-line utility to use to get the file (In our case that would be using tf.exe)
Full TFS Version Control Repository Server Path including the branch name
Version

The default build process template uses the srctool.exe command-line utility first to list all of the local source file locations that are stored in the symbol file. Then, it generates a temporary file that contains the exact alternate stream information for Source Server. The Source Server stream is named srcsrv. Finally, the build process uses the pdbstr.exe command-utility to add that stream information to write the relevant information. If you are ever curious about what that srcsrv stream actually contains, you can run this command-line utility:

C:\Builds\Calculator MAIN\Calculator MAIN_11.02.11.06\Debug\Obfuscated>pdbstr.exe –r -p:Calculator.pdb -s:srcsrv
SRCSRV: ini ------------------------------------------------
VERSION=3
INDEXVERSION=2
VERCTRL=Team Foundation Server
DATETIME=Fri Feb 11 00:41:58 2011
INDEXER=TFSTB
SRCSRV: variables ------------------------------------------
TFS_EXTRACT_CMD=tf.exe view /version:%var4% /noprompt "$%var3%" /server:%fnvar%( %var2%) /console >%srcsrvtrg%
TFS_EXTRACT_TARGET=%targ%\%var2%%fnbksl%(%var3%)\%fnfile%(%var5%)
SRCSRVVERCTRL=tfs
SRCSRVERRDESC=access
SRCSRVERRVAR=var2
VSTFSSERVER=http://localhost:8080/tfs/DefaultCollection
SRCSRVTRG=%TFS_extract_target%
SRCSRVCMD=%TFS_extract_cmd%
SRCSRV: source files ---------------------------------------
C:\LocalBuilds\1\2\Sources\Source\Calculator\Calculator\Form1.cs*VSTFSSERVER*/Ca lculator/MAIN/Source/Calculator/Calculator/Form1.cs*32*Form1;C32.cs
C:\LocalBuilds\1\2\Sources\Source\Calculator\Calculator\Form1.Designer.cs*VSTFSS ERVER*/Calculator/MAIN/Source/Calculator/Calculator/Form1.Designer.cs*30*Form1.Designer;C30.cs
C:\LocalBuilds\1\2\Sources\Source\Calculator\Calculator\Program.cs*VSTFSSERVER*/ Calculator/MAIN/Source/Calculator/Calculator/Program.cs*30*Program;C30.cs
C:\LocalBuilds\1\2\Sources\Source\Calculator\Calculator\Properties\Settings.Designer.cs*VSTFSSERVER*/Calculator/MAIN/Source/Calculator/Calculator/Properties/Settings.Designer.cs*11*Settings.Designer;C11.cs
SRCSRV: end ------------------------------------------------

Publishing to Symbol Server

Publishing the symbols is the easier part of it. Essentially, the default build process template calls the symstore.exe add utility to publish the symbol files to the specified symbol server path. Additionally, there is some metadata added for the build information in TFS that will specify that symbols were published. This will be useful whenever the build retention policies kick in which we’ll cover further down.

Configuring Visual Studio to Use Symbol Server and Enabling Source Server Support

The next step is for each of the developers to configure Visual Studio 2010 to look for symbols if they aren’t found in the symbol server location for the company. You can get to it by going to Tools –> Options and then the Debugging –> Symbols options pages as shown below. Other debugging tools have similar options.

The next thing you will want to do is to enable source server support in Visual Studio. You can do that by going to the Debugging –> General options tab as shown below.

Now, just start using your debugging tool and in my case I have attached my Visual Studio Debugger to the process of my application that came from the build drop folder. Visual Studio gives me a small warning before it attempts to grab the source code from the TFS Version Control repository as shown below. You can see the exact command-line utility including arguments that is used by the debugger to retrieve the correct version of the file. Pure magic…

Update : (2/14/2011) John Robbins has helped out by letting us know how we can disable this really annoying Source Server security dialog any time the debugger wants to get something from Source Server. Thanks John!

Aside: If you notice, in my situation I have a particular problem. Since the TFS 2010 Build services are installed on the same machine as my application tier on my laptop, the default configuration for the build service to connect to TFS used http://localhost. That’s not going to be good whenever I have another developer start debugging using the assembly from my build server and the symbols. Their Visual Studio Debugger instance will try to hit localhost on their machine (where the source doesn’t exist).

For this reason, it’s important to make sure when you are configuring the build service to use the fully-qualified friendly DNS name for your application tier server. (Check out the blog post that’s linked to find out more information about this topic).

How Does Visual Studio Know Which Symbols Match for the Executable?

You have to always have symbol files that exactly match the assemblies you are debugging. How does Visual Studio know this though? There is actually a GUID that is embedded to both the assembly and the symbol file. You can find out what that GUID is by running the DUMPBIN command-line utility as shown below.

C:\Builds\Calculator MAIN\Calculator MAIN_11.02.11.06\Debug>dumpbin Calculator.exe /HEADERS

Microsoft (R) COFF/PE Dumper Version 10.00.31118.01
Copyright (C) Microsoft Corporation. All rights reserved.

Dump of file Calculator.exe

Debug Directories

Time Type Size RVA Pointer
-------- ------ -------- -------- --------
4D54CC09 cv 69 00003864 1A64 Format: RSDS, {B7C62014-02BD-4F35-9718-104CE8CFB14C}, 1, c:\LocalBuilds\1\2\Sources\Source\Calculator\Calculator\obj\Debug\Calculator.pdb

You can see the GUID highlighted above. If you were to go check out the Symbol Server file share, you can also find the GUID used to differentiate between all of the different versions of the symbol files that are stored for a particular assembly.

Update : (2/15/2011) I learned something new from Chris Schmich from the Visual Studio Diagnostics team. He indicated that the PDB age (which is highlighted above in green) is also used to match the symbols. You’ll notice that the PDB age for all of my symbols is 1 and is appended to the end of the GUID when stored in Symbol Server. Thanks Chris for the extra information!

IntelliTrace Files and Symbol Server

I also wanted to mention that when testers use Microsoft Test Manager and run manual test cases where they have collected IntelliTrace logs, you’ll notice that when you open one of those IntelliTrace logs (for example attached to a bug work item) you will see the Symbol Server location that was collected from the assembly being tested as well:

This green-light should be awesome for you as a developer now because you can connect to the Symbol Server location and start debugging using the IntelliTrace log and the Source Server information contained inside of the symbols.

Retention Policies

One other thing to consider: as you have more and more builds performed using TFS 2010 Build, you’ll want to set up your retention policies. The Symbol Server file share can start to go up in size pretty quickly so you can have the retention policies also delete the corresponding symbols from Symbol Server if you choose by setting the “What to Delete” option.

You want to also make sure, however, that any “Released” builds should be marked as “Retain Indefinitely” to ensure that the retention policies never delete the symbols (or anything else about the build for that matter!)

Summary

There you go! Your developers will be very appreciative whenever all of this is setup. You’ll have a system that stores your symbols for whenever you need them and those symbols will have information to let the debugging utilities know where to grab the original source code from the TFS version control repository.

Ed Blankenship

Brought to you by Ed Blankenship and Ed Kisinger at EdSquared.com

Replying to TFS E-Mail Alerts

Ed Blankenship (EdSquared.com) — Wed, 09 Feb 2011 20:37:37 GMT

If you have been using the Alerts Editor that is part of the TFS Power Tools, you will notice that you can get e-mail alerts from the TFS server based on subscriptions that you create. You may not have noticed but there is a subtle feature that allows you to easily reply to the person who made the change (such as creating a new work item).

I just got a notification that my colleague Chris at Notion has just confirmed a task for me to go to the ALM Roadshow in Dallas next month. I have a few questions about the assignment so if I click “Reply” in my e-mail program, you’ll notice that the new e-mail doesn’t reply to the TFS Service Account but instead to the person who made the change that triggered the e-mail. Quite handy.

Ed Blankenship

Brought to you by Ed Blankenship and Ed Kisinger at EdSquared.com

Red Gate to Monetize .NET Reflector

Ed Blankenship (EdSquared.com) — Wed, 02 Feb 2011 15:21:22 GMT

Wow! – If you are waking up this morning you might have noticed some news in the .NET community. Red Gate has announced (official press release) that they will no longer be offering a free version of .NET Reflector after February 2011.

Red Gate mentioned when it acquired .NET Reflector from Lutz Roeder that they intended to keep it as a free tool for use by the entire .NET community. At the time, I was (and still am) a Friend of Red Gate and I couldn’t really figure out how they would go about making that commercially viable. I figured it had something to do with driving folks to their site and then being able to monetize by making those visitors aware of their other great products. (BTW – Truly great products. Quite polished as in they work correctly, easily updatable, sends error reports back to the developers, etc. You know what I’m talking about…) From what it sounds like, whichever approach they originally intended to make, it didn’t pan out in the past 2.5 years. That’s really unfortunate and leaves the company with the choice that they announced today. Looks like their co-CEO has a quick question & answer video response on YouTube available now as well.

I’m not too upset about it though. At times we have the best of intentions, but when those intentions are met with the realities of business and they become untenable, you have to find a different route. Ultimately, Red Gate needs to make money. There aren’t many companies who have extra budget to maintain, support, and invest in a free product unless it is driving revenue into other parts of the business. I see .NET Reflector as one of the key tools in a .NET Developer’s toolkit and that requires recurring love & attention as the .NET Framework changes. That’s good and very much needed for the .NET community.

At the end of the day, it looks like Red Gate is making the right decision however difficult it is to some developers. I can only imagine the uproar that may come out of this decision but personally, I have wanted to see a good amount of investment in such a great tool and since there is so much that can be done with it. I’m sure we have a ton of ideas of things we would do to improve Reflector. By monetizing it, I think the development team at Red Gate will have the resources and continued interest from the .NET community to be able to do just that. I’m pretty impressed with the new features that they have already announced for the next major version. This is a step in the right direction and I have a feeling we will start to see more features that make us more productive and ultimately makes the ROI on such an inexpensive ($35) product worth it. It’s reasonable and totally worth it.

I would be interested to hear your thoughts…

Ed Blankenship

Brought to you by Ed Blankenship and Ed Kisinger at EdSquared.com

Third-Party Support for Visual Studio Coded UI Testing

Ed Blankenship (EdSquared.com) — Tue, 01 Feb 2011 19:50:06 GMT

Bookmark this page! I’ll be updating this blog post article as I am informed of support for Coded UI testing in each of the products. Let me know if I’m missing any that should be in the list!

If you have been using Visual Studio 2010 and Microsoft Test Manager for automated UI testing, you may have experienced some issues with building the Coded UI tests if your application is using third-party components. It has been quite frustrating having been to several customer sites over the past year and running into this issue. My suggestion for anyone that has run into these issues is to open a support case with the component vendor and request that they add the necessary accessibility support to their component libraries. This will allow each of them to track the interest for this type of support in their products and then also provide a way to inform you whenever it is supported.

FYI – This is also the necessary implementation to get the “Fast-Forward” functionality from Microsoft Test Manager to work to record the actions of manual test cases.

There doesn’t seem to be a definitive list of the third-party controls that do or don’t support Coded UI testing at the moment. I have attempted to gather all of the information to provide a one-stop shop for this support. I’ll include links to updates, add-ons, etc. as I receive them.

Product	Infragistics	DevExpress	Telerik	ComponentOne	Xceed
ASP.NET Controls					N/A
Windows Forms Controls			³		²
Windows Presentation Foundation (WPF)Controls					¹
Silverlight Controls					²

Notes

Added support Xceed WPF Controls: http://twitter.com/#!/Kosmatos/status/32527169318027264
Added updates for other products for Xceed: http://twitter.com/#!/Kosmatos/status/32527901526065153
Added update for Telerik Windows Forms controls. Now available in each release of Windows Forms after 2011 Q1. http://www.telerik.com/products/winforms/whats-new-full-story.aspx

Updates

2/1/2011: Updates for Xceed.
2/1/2011: Added some links for implementing the appropriate accessibility hooks. Thanks to Jeff Levinson!
2/16/2011: Added additional information about the Accessibility Checker. Thanks to Vinod Malhotra!
3/24/2011: Update for Telerik Windows Forms controls.

Accessibility Support for Custom Controls

If you are building custom controls that are for internal use in your organization, you’ll want to make sure you implement the appropriate accessibility hooks to get full support from the Visual Studio Coded UI testing platform. Here are some links for you to get started:

Microsoft Active Accessibility (MSAA): http://en.wikipedia.org/wiki/Microsoft_Active_Accessibility
MSAA MSDN Library Home Page: http://msdn.microsoft.com/en-us/library/ms697707.aspx (Used by Windows Forms and native controls)
UI Automation (UIA) MSDN Home Page: http://msdn.microsoft.com/en-us/windows/bb735024.aspx (Used primarily by Windows Presentation Foundation controls)
UI Automation for Managed Controls: http://msdn.microsoft.com/library/ms753388.aspx
Additional Resources for Accessibility: http://msdn.microsoft.com/en-us/windows/bb735024

Additionally, there is a tool called the UI Accessiblity Checker (also known as AccChecker) that is available to help you check your controls to make sure that the necessary accessibility implementation is correct. The tool can check for both MSAA and UIA implementations. It even has a plug-in architecture so that third parties can add additional verifications to the tool. All the source code and the binaries are available on the CodePlex site.

Ed Blankenship

Brought to you by Ed Blankenship and Ed Kisinger at EdSquared.com

Ed Squared

Creating E-Mail Alerts for Team Members in TFS

Replacing Compare and Diff Tools for TFS Version Control

Using the Related Twitter Accounts Tag in the Tweet Button

Awarded as Microsoft MVP for 2012

Integrating Red Gate SmartAssembly Into TFS 2010 Build

Configuring SmartAssembly for Team Use

Creating & Storing the SmartAssembly Configuration File in Version Control

Defining Custom MSBuild Properties

Modifying the Visual Studio Project Files

Modifying the Build Process Template in Windows Workflow Foundation

Defining Build Definition Process Parameters

Verify SmartAssembly is Installed on Build Server

Appending Additional MSBuild Properties

Finale

Potential Improvement Areas

Download Process Template

Blog Site Theme Update

Deploying Visual Studio 2008 ClickOnce Projects in TFS 2010 Build

Free ALM Roadshow Events in 2011

August 2011 – New TFS 2010 Power Tools Released

Speaking at Austin TFS User Group – Customizing TFS Builds

I’m pretty excited about being in Austin this week (one of my favorite cities) and while I’m here, I’m going to be speaking at the Austin TFS User Group this Thursday night. Here are some more details:

Special Event: TFS 2010 Build Customization with Ed Blankenship

First Release of Community TFS Build Extensions

Visual Studio ALM and TFS vNext Announcements at TechEd 2011

Project Server 2010 and TFS 2010 Integration VM with Labs

Virtual Machine Download Details

Speaking at TechEd North America 2011 - TFS and Project Server ALM Integration

OSP203 Application Lifecycle Management: Microsoft Project Server 2010 and Microsoft Team Foundation Server 2010, Better Together

Book – Professional Team Foundation Server 2010 from Wrox

Availability

Promotional Code

Source Code Downloads

Sample Chapters

Book Description

Authors

Table of Contents

Bulk Orders

Lab Management Deploy TFS Build Process Process Template for Physical Environments

Source Server and Symbol Server Support in TFS 2010

What are Symbols?

How to Setup Symbol Server

How to Configure Build to Index for Source Server and Publish to Symbol Server

Source Server Indexing

Publishing to Symbol Server

Configuring Visual Studio to Use Symbol Server and Enabling Source Server Support

How Does Visual Studio Know Which Symbols Match for the Executable?

IntelliTrace Files and Symbol Server

Retention Policies

Summary

Replying to TFS E-Mail Alerts

Red Gate to Monetize .NET Reflector

Third-Party Support for Visual Studio Coded UI Testing

Notes

Updates

Accessibility Support for Custom Controls