I have a new favorite tool for managing and administering a Team Foundation Server environment from day to day.  It has been so helpful both internally with administering our TFS environment but also as I go from site to site.  A great part about the tool is that the source code is completely available with an open license for use.  The product is maintained transparently and there have been a few occasions where I will request a feature and it’s literally done and released the next morning when I wake up.

Introducing the TFS Team Project Manager on CodePlex!  It’s a tool that helps you take care of common administration and maintenance tasks across lots of multiple team projects.  I have found it to be so useful in tons of different ways.  One of them is something that I’m particularly finding useful this week with a customer that is upgrading from Team Foundation Server 2008 to Team Foundation Server 2010.  They have 117 team projects on their instance and as you know, it can get tedious to manage that many team projects.  This tool helps out in scenarios like this.  We’ll talk with them later about potential consolidation of all of those team projects though!

One of the things I need to do is figure what’s the best course of action after upgrade for the work item type definitions (and other process template features) for all of the existing team projects.  Everyone will be functional if we don’t do anything but I wouldn’t mind giving the teams a few of the new features in TFS 2010.  The feature of TFS Team Project Manager that can let me get a good sense of where the team projects currently sit with their process template choice & customizations is a “Compare” feature for work item type definitions.

The way that it works is that you load up different sets of work item type definitions from a process template.  You can even use an existing team project’s work item type definitions as a base set as well.

Once you have defined a few different sets that you want to compare against, you just select the team projects that you want to compare and click “Compare Team Projects With Sources.”  The tool has a fairly rudimentary compare algorithm but the summary & detailed data you can get is very handy.  It’s pretty magical if you were to ask me.

The grid lists all of the results including:

• What is the best matching process template based on the source sets that are available?
• What is the best matching percentage?
• What were matching percentages for the other source sets of process templates?

Initially seeing the results may uncover a little chaos in your TFS environments. That’s okay because there are options. You might want to tame some of that chaos by moving your process templates and storing them in the version control repository. Once it is in version control, you can attempt to “merge” similar process templates together as best as you can and consolidate. You could then use my handy custom build process template for managing deployments of changes to the process templates to existing team projects on your system.

Shameless Plug: We end up talking about these concepts in our book, Professional Team Foundation Server 2010 by Wrox if you are interested in more information!

First, I like to sort by the “Best Matching Percentage” column in the results to see which team projects have attempted to go off the path and made individual customizations.  I don’t really need to worry about the other ones because I can take care of them in bulk.  The key in this particular case is to get them to same the base so that we can deal with them altogether in bulk after the upgrade.  (Customer’s Desire)

If you want to dive into a little more detail for any of the rows, you can choose “View Comparison Details” or double-click the row entry to pop up a great dialog that will help you with understanding the changes even more.  You can see which work item types are changed and if you can even open up the changes in a diff tool that is configurable.

There was even a new feature implemented last night that detects whether you have Visual Studio vNext (currently Visual Studio “11” Beta) and will use that nice new diff & compare experience in Team Explorer!

How about that?  This just makes things a ton easier for me!

This tool has a lot of other great features for TFS administration tasks across team projects.  that I’ll talk about in the future.  Just wanted to mention this one and how useful it can be!  Please make sure that you Donate to Jelle Druyts if you find the tool useful to you as well.  It’s absolutely free and he puts a lot of work into keeping the project going.  At least buy him a drink for his hard work!

Ed Blankenship

Now that the new Visual Studio and TFS “11” Beta release is available for you to use for evaluation or even “Go-Live” in production, you’ll likely find some bugs or suggestions for rough spots in the product that might be able to be addressed before the final release.  Even so that feedback can be acted on in a subsequent patch, feature pack, or service pack so it’s always good to at least put it on the product team’s backlog.

The traditional way to provide feedback in the past for the Visual Studio 2010 release and before was to use Microsoft Connect for Visual Studio to file your bugs for the .NET Framework, Visual Studio, Team Foundation Server, Microsoft Test Manager, etc.  It still is but now you have another tool in your tool belt to provide some great information for the product team that’s new for the Visual Studio “11” family release now in Beta.

Introducing the Microsoft Visual Studio “11” Feedback Tool available on the Visual Studio Extension Gallery.  It’s easy – after installing the extension you’ll get an option in the Help menu for “Report a Bug” which will start a nice wizard process that will create an awesome Connect bug for you.  You can use this wizard for anything you would normally create a bug for like the .NET framework, TFS, Visual Studio, Microsoft Test Manager, etc.

One of the awesome pieces of this tool and very important is that it captures all sorts of logs and valuable information to be used in helping reproduce the problem.  You can review all of those files before you submit the feedback to make sure you are comfortable with that data.  The Microsoft Connect item is also marked as “private” so that your details aren’t exposed to the public.  You can always go in to the Microsoft Connect site to change it to Public if you want it available for other people to vote it as something that is important to fix.  That’s not required though.

After you have started the tool, you can access it from the Windows Notification Area (aka System Tray) by clicking the tool’s icon.

Here are some things you can also do to make your bug reports super stellar and give it some traction whenever someone looks at it:

• What are the steps to reproduce your problem?  Be sure to give all the steps. Some things may seem extremely obvious to you but when you are looking at lots of bug reports, something obvious to you may not be obvious to them.  If the problem is intermittent, describe the best you can to provide what you can to help the person reading your bug report to attempt to reproduce it.
• Provide screenshots in a logical manner and show someone what’s going on with annotations like .
• Even better – you could always create a quick screen recording using a tool like Screenr (free) to show someone what’s going on.  Feel free to put the link inside your bug report.
• Help the team understand how many people or the types of customers you think this would impact.
• Are there any others with similar machine specs or environmental conditions that are experiencing this problem?
• Provide some information about your environment and computer.  What versions of Visual Studio do you have installed including older versions?  Did you have a previous pre-release edition on your computer?  How did you get that one removed from your machine?
• Is the bug preventing your business from functioning?  Honestly answer this.  Remember that not everything can be Priority 1.  If the bug is truly keeping your business from functioning, then I would file the Connect bug and note the ID number.  After that, pick up the phone for Microsoft Product Support Services and help them with understanding the severity.  You can provide the support technicians with the Connect ID and that can get them started with working through the issue.  Don’t file a Connect item though if it’s not a bug.  You can always call the Support team for non-bug issues to help you through your problems too so keep that in mind!
• Any others that I might have missed that would be important?

If you want to take a look at all the other details about using the Visual Studio Feedback Tool, check out the documentation here:  https://connect.microsoft.com/VisualStudio/content/content.aspx?ContentID=26698

If you have a feature request, instead of a bug report, then I would head on over to the Visual Studio User Voice site.  You’ll have the opportunity to create new feature requests and vote on those coming from other people.

Ed Blankenship

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

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.

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

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.

• TFS 2010 Power Tools
• MSSCCI Provider
• Build Extensions

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

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

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

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

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

I just noticed an interesting product that I could see used for those folks wanting to shine some light and transparency with their release status around the office.  You can use one of the many third-party products that show a “dashboard” of information, like TeamPulse or the TFS Project Dashboard,  from Team Foundation Server or you can always roll your own.  However, in several office layouts, I have always found it awkward to get a computer situated near enough the high traffic areas.  I didn’t realize it but they actually make VGA extenders that allow you to push a monitor signal across your Ethernet infrastructure (CAT5 or CAT6) up to 490 feet!  This particular one even splits the VGA and audio signals so that you can have two monitors with a duplicate signal at the receiving end.  Neat.

I’m wondering if you could couple it with a huge multi-touch monitor and then have an awesome Scrum or Kanban board?

Ed Blankenship

I recently re-discovered a feature of Office SharePoint Server 2010 and Office SharePoint Workspace 2010 that allows you to create local workspaces stored on your computer that syncs with a SharePoint site like the team portal site that gets associated with a Team Foundation Server project.  The nice thing about this is you can access synchronized SharePoint libraries and lists even when you are disconnected from the SharePoint server.  This allows you to read and edit content which become cached so that it will synchronize whenever you

You have access to this Office application if you have Office Professional Plus 2010.

History

The Office SharePoint Workspace product originally came out of Microsoft’s acquisition of a product formerly known as Groove back in around March 2005.  Groove was kind of neat because it essentially created these workspaces that could be shared across multiple computers and synced anytime you had an Internet connection.

Fast forward to Office 2010 and Microsoft has enabled synchronization with a SharePoint site!

Connecting to Your TFS Team Portal Site

First thing you will need to do is make sure you get to the team project’s portal site.  You can do this by opening Visual Studio 2010 and choosing “Show Project Portal…” on the context menu for the team project you are interested in.

Next, choose “Sync to SharePoint Workspace” from the Site Actions drop-down available in the top-right corner of your SharePoint 2010 team portal site.

Once you do that Office SharePoint Workspace 2010 will prompt you about whether you want to sync the site.  By default it will sync all document libraries and lists but if you choose “Configure…” then you can select the libraries and lists that you want to synchronize with your local SharePoint workspace.

After you confirm your configuration, the workspace will immediately begin to synchronize!

Quite a handy utility for users of SharePoint 2010 sites!

Ed Blankenship

We recently got awesome new laptops at work (which are just awesome BTW) and on the standard image included a Team Foundation Server tool that I haven’t used in a while:  TeamCompanion 3.0.  I had used earlier releases of the tool but always seem to forget to install it whenever I pave my machine as I do quite frequently.  It’s been a while and I must say… the 3.0 version is just awesome.  I’d like to go over a few things that I really like in the latest release.

Experience

The experience of connecting to TFS inside Outlook is just first-class.  The same icons that are used in Visual Studio Team Explorer are the ones that appear in Outlook.  That really does make a difference for me…  Notice that I can also add certain work item queries that I’m interested in to the Favorites area as well.

If you are using Outlook 2010, you’ll notice that TeamCompanion adds a handy ribbon tab:

Work Items Galore

There are so many things you can do whenever working with work items with TeamCompanion!  For instance, let’s say you get an e-mail for a customer of a great feature request.  It’s super quick to create a new feature request work item or attach the e-mail to an existing work item.

What’s even cooler is that if the e-mail refers to a specific work item in the content (i.e. “Bug 1234”) then TeamCompanion can let you open the rich work item form to look at the details or edit the work item.  This is especially helpful for alert e-mails that you may get from TFS.

Even cooler is that all of the normal Outlook features work like replying, forwarding, flagging, categorizing, setting alerts, etc.

Other Work Item Features:

• Offline Work Item Support
• Scheduling Work Item Queries to Run
• Great Rendering of a Work Item
• Creating Tasks/Meeting Requests from Work Items
• Printing
• Editing Areas & Iterations
• Bulk Editing
• Searching Work Items
• “Query By Example”

Reports

I think my favorite feature of TeamCompanion has to do with handling reports.  By default, the rich reports you get with TFS are all scoped at the Team Project level.  However, I find myself frequently needing to filter to a particular Area Path and Iteration Path.  TeamCompanion actually allows you to save those common filters that you perform every day and store them.  Allows you to have all of the presets that you want.

Another handy feature is the ability to send an e-mail with the report easily within Outlook.  Nice!

I’m certainly not doing the latest release of the product justice.  They did a great job with improvements and new features from previous versions that I have used.  I’d suggest you’d download the trial and kick the tires.

Ed Blankenship

This is some really exciting news for customers of Visual Studio 2010 and Team Foundation Server 2010!  Today, Microsoft has announced that customers who have purchased Visual Studio 2010 Ultimate with MSDN or Visual Studio 2010 Test Professional with MSDN now receive the Lab Management capabilities for Team Foundation Server!  That means no per-processor licensing fees for your physical host servers that will be hosting your virtual machines!

Earlier this year, I passed on Lab Management news that indicated that it would cost $1,599 per processor (retail.)  Microsoft has listened to the feedback and has also made it a “feature” in the Visual Studio family instead of a completely separate product.

Microsoft has also announced an update to the Lab Management functionality in the different products to bring it to full RTM/RTW status.  You’ll recall that when Visual Studio 2010 released earlier this year that the Lab Management features ended up still being released in a “Release Candidate” status.  The product team has spent the last few months gathering feedback and include updates to improve performance throughout the product.  The “patch” will be available later this month.  I highly recommend updating to the latest version by installing the patch as soon as it becomes available.

When it is released, you will see the following “extra” installation media become available in your MSDN Subscriber Download listings:

• System Center Virtual Machine Manager* (SCVMM)
• Visual Studio 2010 Agents

*A grant of “limited use” rights for SCVMM are included.  This means that you can only use SCVMM for your Visual Studio 2010 Lab Management test lab.

This is a great move for customers.  Creating a virtual lab management can be an expensive endeavor for business.  I recall visiting customers who have spent tens of thousands of dollars on competing products like VMWare Lab Manager.  This is really bringing virtual lab management to everyone!

If you are curious about more information, see Brian Harry’s announcement.

Ed Blankenship

One of my pet peeves is places who charge for Wi-Fi internet access.  Another pet peeve in the same basket is those who make me pay for each device that I want to connect.  Even though more and more locations are starting to offer free Wi-Fi access, I can’t solve the first one.  However, I can attempt to solve the second problem scenario and here’s how…

I pay for internet access on my Windows 7 laptop and then use Connectify to create a virtual Wi-Fi hotspot.  What is this Connectify, you ask?

A Windows 7 feature called Virtual Wi-Fi didn’t end up making the cut line for the final release.  We’ll see if it makes it into a future version of Windows.  The cool thing is that the plumbing for that feature did make it into Windows 7 and that’s where Connectify steps in.  You can basically use your Wi-Fi card to create another ad-hoc network that can then be used to share your internet connection.  This even works whenever you are connected to a wireless network for that internet access.  It’s super easy and it’s free.

The one catch is that you need to be running Windows 7 to make it all work.  It works perfectly for most internet connections.  I have noticed that it doesn’t work whenever I’m connected using my Verizon card but that’s the only time I’ve noticed an issue.

Ed Blankenship

I’ve had a few questions about the missing Alerts Editor node in Team Explorer after installing the TFS 2010 RC Power Tools so I thought I’d share with everyone.  First, Alerts Editor has been renamed to Alerts Explorer in the TFS 2010 Power Tools release.  Next, you’ll notice that in the TFS 2008 Power Tools, that a node existed underneath each Team Project shown below.

You’ll see that in the TFS 2010 Power Tools, it’s no longer available as a node under each team project but rather available from the context menu of the Team Project Collection node and named “Alerts Explorer.”

What is the Alerts Explorer?

There is a rich eventing & alerting system in TFS that allows end users to self-subscribe to alerts that meet different criteria.  These alerts can either be e-mail alerts or SOAP-based alerts to a web service URL.  (SOAP subscriptions can only be created by Team Foundation Server Administrators.)  By opening up the Alerts Explorer, you can see any of the subscriptions that you currently have created on the server.

Also, you can create new alerts based on some out of the box templates like “Work Items Assigned to Me” or “Failed Builds.”  This is a good starting off point for creating alerts and allows you to further customize the filter criteria to your specifications.

Tip:  As shown in the screenshot above, if you don’t want to receive an e-mail alert whenever you actually change something, be sure to include the “Authorized As <> Your Name” clause.

You also get some handy context menus around the Team Explorer UI to help you to easily create subscriptions.  For example, if there is a particular work item (like a bug) that you want to get e-mail alerts anytime someone changes it, just choose “Alert on Change..” from the context menu on that work item.  You’ll find some other context menu items for Alerts in other places so have fun finding them!

Ed Blankenship

Updated – 8/19/2011 – New Rollback Features Available in the UI with TFS 2010 Power Tools (See Below for More Details)

One of the new features for TFS 2010 Version Control is the ability to rollback or undo a changeset or check-in inside the product and see it as a new pending change type (and new change type in the history) inside Team Explorer. This feature has been available in TFS 2008 but you had to use the TFS Power Tools. The only gotcha for the TFS 2010 implementation is that you have to use the command-line application tf.exe to actually perform the rollback operation. More information about the tool is available here in the MSDN Library: http://msdn.microsoft.com/en-us/library/dd380776(VS.100).aspx

The syntax is:

tf rollback /changeset:changesetfrom~changesetto [itemspec] [/recursive]
[/lock:none|checkin|checkout] [/version:versionspec]
[/keepmergehistory] [/noprompt] [/login:username,[password]]

tf rollback /toversion:versionspec itemspec [/recursive]
[/lock:none|checkin|checkout] [/version:versionspec]
[/keepmergehistory] [/noprompt] [/login:username,[password]]

Versionspec:
Date/Time D"any .Net Framework-supported format"
or any of the date formats of the local machine
Changeset number Cnnnnnn
Label Llabelname
Latest version T
Workspace Wworkspacename;workspaceowner

Rollback Available in the UI Now

If you have the August 2011 or later version of the TFS 2010 Power Tools installed, you now have the ability to fire off a rollback straight from Team Explorer without having to use the command-line approach.  The main way would be to fire it off from the Source Control Explorer window.

However, you can start the rollback process from the Changeset History window as well.

Ed Blankenship

I really like to keep software on my computer up to date.  You never know when there are new features available, bugs fixed, or security vulnerabilities plugged unless you go out and look for them (and keep up to date with your Windows Updates.)  About a month or so ago I noticed that CNET had a new tool that I thought I’d try on my computers called TechTracker.  You can install it on up to three machines for free and it will just sit in your tray monitoring for updates.  I got a popup this morning letting me know there is a new version of Adobe Reader available and I was taken to this screen where I could download the new update from Adobe’s website.  Very handy!

Ed Blankenship

Surprisingly, I’ve heard from several people that they still want a hard-copy document form of artifacts that are getting stored in TFS like Test Plan documents or Requirements documents.  I can understand some situations like if you need to follow certain regulatory requirements as so forth but don’t really see the need beyond that why you would ever want a hard-copy :)  Help me understand more if you happen to be in that boat!

Anyhow, if you need a hard-copy test plan document then you are in luck!  Test Scribe has just been released which will take your test plan information, artifacts, and progress from TFS and generate a nice Word document.  Quite handy!  If only we can get the Requirements document power tool now then we’ll satisfy that other group of people!

I'd like to announce the beta availability of Team Test's first Power Tool release for Visual Studio 2010: Test Scribe.  This tool allows users of Visual Studio 2010 Ultimate Beta 2 to generate a Word 2007-compatible Test Plan Document from their plan, suites, test cases, and other artifacts.  Using the tool is a fairly straightforward process, including:

   1. Launch the Test Scribe tool.
   2. Enter your server/collection URL (e.g. http://myserver:8080/tfs/DefaultCollection)
   3. Select a Project.
   4. Select a Test Plan (previously created in MTM).
   5. Click the Generate button.

The resulting document will contain (among other things) a list suites with test cases and steps detail and pie charts detailing the overall progress of your Test Plan.  You can see a screenshot below showing several sections of a generated document.  Feedback is welcome and appreciated, and you can find the tool download at http://visualstudiogallery.msdn.microsoft.com/en-us/d18873c7-909d-4788-a56e-0c496a1d8bb9.

Many thanks and appreciation to everyone who helped get this tool out the door.

More information available here:  http://blogs.msdn.com/vstsqualitytools/archive/2010/01/11/test-scribe-test-plan-documentation-for-mtlm-plans.aspx

Ed Blankenship

I don’t know how many times I’ve heard this suggestion from people:  “Microsoft should just buy TeamPrise and make the Eclipse and non-Windows clients just part of the TFS product.”

That day is finally here.  Microsoft has purchased the TeamPrise-related assets from SourceGear.  More details about the acquisition announcement are available at Microsoft’s PressPass site and also the Pathways site for TeamPrise and Visual Studio.

Also, in addition to purchasing the TeamPrise assets, Microsoft has also hired a majority of the development team including, most notably, Martin Woodward who has been an absolutely fantastic part of the “Team System” MVP group.  It will be really sad to see Martin leave the group (as of today) but something tells me that he won’t be hiding :)  Congratulations to him and the entire team!

Now the one thing that i think people might be worried about will be what will happen to the future of the TeamPrise clients and will that development team be able to innovate as quickly as they had before?  I’m pretty sure the same “mission” will be in place and the team will be able to more closely leverage the other team members and assets within the Team Foundation Server product team.  As far as speed of innovation, that’s tough to tell.  Most other Microsoft products have tons of release requirements that slow them down such as localization, security reviews, etc.  All of which are great things but do end up slowing you down if you have to support those requirements.  Who knows if the TeamPrise development team will have to support them?  My guess is that if they’re going to be part of the “Visual Studio” product line that they will have the very similar if not the same requirements as the rest of the stack.  We will definitely see…  Another possible hang up is that Microsoft (specifically Developer Division) will have to learn how to sell & market a Java/non-Windows based product.  I can only imagine there will be some growing pains.

As far as licensing, right now you’ll need to still purchase the TeamPrise clients and get support from TeamPrise directly.  A Microsoft-branded “TeamPrise” client will become available with the 2010 release.  If you own a current license of the TeamPrise 3.3 software it looks like you’ll be upgraded to the new version when it is released.  Also, if you own a Visual Studio 2010 Ultimate with MSDN license at the time you’ll get access to download the new clients from MSDN Subscriber Downloads.  After the 2010 release, it looks like there will be a new SKU available to be able to purchase just the new clients that will also include a CAL for Team Foundation Server that will run somewhere around $799 retail.

I’m excited about the decision and it looks like both Martin and Brian Harry are as well.  I’m excited to see the platform broaden and truly support teams who have heterogeneous development environments!

Ed Blankenship

I’m up really early this morning.  I’m about to head to the airport to spend my Independence Day weekend in the Carolinas for some much needed beach vacation and visit with friends.  Thankfully, I didn’t miss Martin Woodward letting me know that the latest Radio TFS episode was made available just a few moments ago that includes my interview about our use of TFS and Visual Studio Team System at Infragistics.  It’s a longer episode than normal so it’s perfect if you’re going to be spending some time at the beach like me and listen to a fun talk.  We both really enjoyed chatting for this episode so we hope you enjoy it as well!

Using TFS with Ed Blankenship

In this episode we sit down and chat with Ed Blankenship about the use of Team Foundation Server at Infragistics. Ed has had some interesting challenges and experiences in running their TFS instance.  Additionally they have done some fairly advanced integration work which we discuss in detail.  This is a double-length show, so hopefully plenty of stuff to enjoy if you are sunning yourself on a beach somewhere.

Ed is the Release Engineering Manager at Infragistics, makers of the world's leading presentation layer tools and components.  He is also a Microsoft MVP in Visual Studio Team System.

     Play Now: Using TFS with Ed Blankenship

As the Release Engineering Manager, he leads the Release Engineering Department which is responsible for automated builds, creating product installers, packaging source code for customers, source configuration management/version control, metrics, release management, work item tracking, licensing enforcement, and development of internal productivity tools.  The department also is responsible for TFS Operations & Maintenance.

Ed has been a technical editor for the Wrox Silverlight 1.0, Silverlight 2 Developer's Guide, and Silverlight 2 Bible books, author of numerous articles, and has spoken at various user groups, events, and conferences.

Links from the show:

• Ed's Blog
• Microsoft Process Template
• Martin's Blog Post on Check-in Policies
• How to turn on Activity Logging with TFS 2005

As usual send any feedback to radiotfs@gmail.com.

Feel free to let me know if you have any questions based on the Radio TFS chat.  I’m more than happy to get them answered for you!

Take care,

Ed B.

I’ll have to admit, the Easy Assist feature is not very discoverable if you have a Live Meeting account but it’s really really really useful!  So imagine you have a coworker or a mother who needs help but they’re not where you’re at.  There are a lot of different ways for people to do remote assistance support but if you have a Live Meeting account there’s another way that I’ve been using:  Easy Assist.  It’s the same app that lots of support professionals at Microsoft Product Support & Services use to help customers remotely.

BTW:  If you’re an MVP, you have received a complimentary Live Meeting account as part of your benefits!

Downloads for End-users who need support

• Download the Microsoft Easy Assist support console for joining an Easy Assist session
• Download the Microsoft Easy Assist Safe Mode Client for troubleshooting within Windows Safe Mode

Downloads for Support Agent

• Download the Easy Assist Launchpad for setting up Easy Assist sessions
• Download the Microsoft Easy Assist support console for joining an Easy Assist session

Easy Assist Launchpad

So the first thing you should do to help create support sessions quickly as a “support agent” is get the Easy Assist Launchpad installed so it sits in your tray and waits for you.  When you launch it for the first time, it’ll ask you to put in your Live Meeting credentials.  These are the same that you would use when you setup & configure the Live Meeting client. 

After you have finished that, the Launchpad will sit in your system tray and has a few options available for you:

I’ve went ahead and chosen “Create Session” and I’m just going to put in something to let my Mom (and I) know this is for her session.

After, creating the session you’ll have the option to join the session yourself and also send the invite by e-mail (using your default e-mail application) to the person you’re trying to support.  Look at the URL… you’ll notice it’s very similar to a Live Meeting invite but instead it has the “joinEA?” inside of it.  This is important because this is what makes the end user experience better for the support agent and the person being supported because it will fire off the Easy Assist client instead of the full Live Meeting client.

Support Agent Features

Once you’ve fired off the Easy Assist support agent client, you’ll be able to see the other support agents that are attending as well as the person(s) you are trying to support.  You can request that they reboot, share their screen, share your screen, request to control their session, send files, and more.  Support agent screens:

All the end user sees is a small window that’s out of view.  After the session, it even asks the end user if they would like to uninstall the Easy Assist client since it’s not needed anymore!  How nice?!  It even works if the customer has booted in safe mode.  Very handy at times.

You can see how it’s super easy to escalate a support call from a family member, an IM/e-mail from a co-worker, or even setting up a session for you to get help from a support agent who doesn’t have remote assistance provided by their employer.  Hope this is helpful to you!

Ed B.

This has been out for a little while but wanted to make sure that you knew about it as well!

Our Director of Product Development here at Infragistics, Joe Croney, has been working on a personal side project of creating an iPhone app that will connect to Team Foundation Server.  He’s got a BETAposted in the Apple iTunes store now.  At the moment it only supports checking on Builds but I know he’s starting a backlog.

More screenshots and an FAQ are available at the website:  http://www.tfstogo.com/

Joe is looking for some feedback and any bugs so if you find some feel free to report them at support@tfstogo.com.  Congrats Joe!

FYI:  We’ve found that if you connect over VPN in the iPhone that sometimes a local DNS name isn’t resolved correctly.  You can correct this by putting in the hard-coded IP address of the TFS server instead.

Have fun and enjoy!

Ed B.

In December, I had the privilege to be the “MVP in Residence” with the Team System product group.  Chuck blogged about the experience at the beginning and end of the week.  I felt really good about the accomplishments at the end of the week.  The main project I worked on was packaging up the Microsoft Process Template (MPT) so that it could used by the public community.  I’m happy to announce that it is live on CodePlex now so feel free to download and use it!

Description

The Microsoft Process Template (MPT) is a Microsoft internal, end-to-end project management solution that maps to the Microsoft product development cycle and works with Visual Studio Team System 2008 (VSTS). The MPT offers an out-of-the-box solution and includes all the work item types (forms), queries, documentation, engineering best practices, and reports required for Microsoft development teams to get up and running on Visual Studio Team System. The Engineering Excellence* and Visual Studio Development teams worked together closely over the last year to create this template by compiling the lessons learned from other teams that have implemented similar templates, incorporating engineering best practices, widely socializing the concepts, and finally piloting this template with several product groups.
*The engineering excellence team is a Microsoft business unit that provides Microsoft business group employees with high-quality technical education, best practices and guidance.

Be sure to check out the Introduction and the Getting Started guides to dive in and get the background information for the process template.  One of the main things that people will notice is that the MPT simulates work item hierarchy through the the use of some daemon services.  There are several ways to simulate hierarchy in TFS 2008 so if you’re looking for a solution the MPT has the services source code and reports created for them.

Here is a sample report that uses the hierarchy to rollup the progress by Feature:

There are a few known issues with the process template which are listed in the Getting Started guide.  I’ll be sure to keep the guide updated if I hear of any other known issues.

Other MPT Resources

Gregg Boer, Principal Program Manager on the TFS product group, wrote an excellent series of blog posts of how Microsoft uses the MPT internally along with an overview of the process around tracking progress throughout the release.

· How Microsoft/DevDiv uses TFS - Chapter 1 (Our Process)

· How Microsoft/DevDiv uses TFS - Chapter 2 (Feature Crews)

· How Microsoft/DevDiv uses TFS - Chapter 3 (Implementing the Process)

· How Microsoft/DevDiv uses TFS - Chapter 3 (Addendum)

· How Microsoft/DevDiv uses TFS - Chapter 4

· How Microsoft/DevDiv uses TFS - Chapter 5 (Tracking Progress)

· How Microsoft/DevDiv uses TFS - Chapter 6 (Tracking multiple projects)

· How Microsoft/DevDiv uses TFS - Chapter 6 (Addendum)

· How Microsoft/DevDiv uses TFS-Chapter 7 (Tracking Risk)

· How Microsoft/DevDiv uses TFS-Chapter 8 (Tracking Quality Gates)

· How Microsoft/Dev Div uses TFS - Chapter 9 (Transparency in Reporting)

Jeff Beehler and Brian Keller also put together a video of how Jeff uses the MPT & TFS to monitor progress of the release cycle. Take a look on Channel 9: http://channel9.msdn.com/posts/briankel/Better-Project-Management-with-Team-Foundation-Server/

I really want to thank you to everyone that helped getting it packaged up for the public!  Also, thanks to Chuck for organizing the week, working logistics, and of course giving me a place to stay!

Ed B.

Fellow Team System MVP Mike Azocar has announced an awesome new contest to stir up the Team System tools ecoystem.  There are some really cool prizes so far including a free license for Microsoft Visual Studio Team Suite 2008 w/ MSDN Premium subscription and there are more donated prizes coming...  Get the full details at his blog post:  Want to be famous- Enter the Coolest Team System Gadget Contest!

Have you created a useful gadget for Team System? Do you have one in mind? I am looking for the coolest community built tool for VSTS. It can be something for TFS, for Visual Studio, or something that is stand alone. The winner will receive a one year subscription to MSDN with Team Suite!

To enter, submit a screen cast (up to 3 minutes long) which tells everyone why your gadget is the coolest and the source code. All submissions will be released to the public as free source to use and enjoy (with you getting all the credit of course). Videos will also be made available to the public to help make you famous! This should be something new (i.e. not on Codeplex or previously released) and not something repackaged. Submissions accepted up until August 31st 2008. Winner will be announced September 15th 2008.

Judges will be Mike Azocar, Martin Woodward, and I so this is going to be a lot of fun!

Ed B.

I'll be speaking on July 1, 2008 at the Dallas Visual Studio Team System User Group. Starts at 6 PM.  This is going to be a really exciting session for me personally and I love that we have a big block of time to get into some really fun Team Build details.  I think we are meeting at the Notion Solutions office in Irving for the July meeting but I'll double-check and update if there is a change.

Here are a few topics that I'll make sure we talk about:

• New Features for Team Build 2008
• Fun Stuff around Builds at Infragistics
• Build Notification Power Tool
• Building Java applications using Team Build & TeamPrise - (This blows people's minds away)
• Building Installers using Wix
• New Changes in TFS 2008 Service Pack 1 for Team Build
• If time, Extensibility with the Team Build API

Be sure to sign up on the user group website to get updates and the RSVP link whenever it gets sent out.

Ed B.

I'm excited to announce that we have finally released a free tool to help you visualize resource usage in your WPF applications.  Kudos to the team on a job well done!

Pistachio helps you by:

• Seeing what resources are being used.
• Finding unused resources.
• Displaying the types of resources being used.
• Filtering, Sorting, etc.
• Cool Visualizations of Usage

If you were at either of my talks at Boston ReMix or Tulsa Tech Fest you got a pre-release preview but now it's all ready for you to use!  Please let us know if you have any suggestions or problems while using.  There are several more features being planned so let us know what's important to you.

DOWNLOAD HERE:  Pistachio - WPF Resource Visualizer

Ed B.

This post actually applies to many different situations in which you would automate a build on a separate server.  I just happen to be familiar with Team Build.

Because of how NetAdvantage deals with licensing each build server will need a full copy of NetAdvantage installed.  Some build engineers have only copied the NetAdvantage assemblies over to their build server and will see LicenseException errors in their build reports.  Even copying them into the GAC isn't enough...  Just to save yourself a couple of headaches, take a few minutes to install using the product installer.  There is an option in the installer to install just the assemblies and licensing components.  I'd recommend deselecting all of the options if you don't need them installed on the build server.  Be sure to also apply any hot fixes that your application may use as well.

As an aside, according to Infragistics' current licensing agreement, each build server you install NetAdvantage on must have a separate license whoever creates the build script must be licensed.  If your team has separate build engineers, each of them should be licensed if they will be working on the build script.

Happy Building!

Ed B.

Microsoft has recently released a version of their application that generates the .NET Framework documentation that we see and love...  You can take a look at it and get more information about the project codename Sandcastle here:  Sandcastle Team Blog

Download the December 2006 CTP here:  Sandcastle - December 2006 CTP Download

Some of the high level features:

Sandcastle produces accurate, MSDN style, comprehensive documentation by reflecting over the source assemblies and optionally integrating XML Documentation Comments. Sandcastle has the following key features:

Works with or without authored comments

Supports Generics and .NET Framework 2.0

Sandcastle has 2 main components (MrefBuilder and Build Assembler)

MrefBuilder generates reflection XML file for Build Assembler

Build Assembler includes syntax generation, transformation..etc

Sandcastle is used internally to build .Net Framework documentation

Ed B.

Our new team at Infragistics, the User Experience (UX) Group, has come out with an article on Code Project about creating fantastic user interfaces using the NetAdvantage family of products. Kudos to several on the UX team who wrote and edited!

Be sure to check it out!  How to Make Users Happy Article

Ed B.

NOTE :  This is an unfinished article.  I have been working on this commentary for several weeks now but I felt I needed to post what I already have.  I will be adding sections over the next several days to complete everything so look for more links, screenshots, images, sections, and content.  I'll also watch for comments and post answers to really good questions or requests for more commentary.

I have been working on this post for several weeks now.  It's the "Toy Boy" in me that has been irking to talk about my experience with all of the .NET UI "toys" out there.  I am a huge fan and proponent of organizations choosing a third-party .NET component suite for purchase for their development team(s).  There are just so many reasons to have one chosen and used in all of an organization's applications.  The question that always pops up though is:  Which One?  In the last three years this question has come up for me from several different organizations including clients that I have consulted with.  Honestly, the best choice will always depend on the organization and its needs but I would like to go through a comparison of the major component vendor suites that are out today.  Even though I have my favorites, my goal was to be completely objective in my analysis and judging.  I will be comparing the following versions:

• Infragistics NetAdvantage 2006 Volume 3
• Telerik r.a.d. controls Q3 2006

I have further split my comparison into control groupings to ease the reading for major controls.

Grids

<Section Not Completed Yet - Update Soon>

I'd like to see the component vendors offer data bars support like in Microsoft Office Excel 2007... that would be way awesome!

ASP.NET AJAX(Atlas)

Now, for the longest time I have been a huge fan of Telerik ajax control because of how simple it was to "ajaxify" your current web apps.  You still can easily but now you can also do the same with the new Infragistics release.  I would suggest giving them both a try but both components compete extremely well with each other and are compatible with the latest beta release of Microsoft AJAX.

Something minor but worth saying:  I love the gallery of different "loading" animations that are available out-of-the-box with the Telerik r.a.d. ajax control.  Take a look at them:  http://www.telerik.com/demos/aspnet/Ajax/Examples/Common/LoadingImages/DefaultCS.aspx

Editors

<Section Not Completed Yet - Update Soon>

Charting

Anyone who knows me knows how much I LOVE charts.  Love them Love them Love them!  (I know... the look you are giving me now is the same look I get from many when I talk about charts.  But hey, I LOVE charts!)  Charts in my opinion are one of those most fundamental tools you can use to convey so much information to an end user.  Well-presented charts are a must-have for every application that deals with data and needs to convey useful information.  With that said:  Absolutely nothing else to say:  Infragistics has the best charting controls between the two comparison suites.  I love using them.  They are just too easy to learn.  Just figure out how you want to convey the information using the design-time designers and then data bind!  POOF! 

Aside:  There are some things that I wish Infragistics would include in their charting controls.  Best of breed in the charting control space would have to be Dundas.  If you haven't taken a look at them, they have great controls for charts, maps, and gauges.  (Something that I would like to see included in the other component suites.)  Beware though... Dundas charges a pretty penny for them, but if all you need is really good charting controls, Dundas is definitely the way to go.

XHTML/Accessibility

<Section Not Completed Yet - Update Soon>

Toolbars

If you think about it, toolbars and menus have been around for a very long time; way before I was even born.  I think since the 1970s!  Wow... and they have really been the way UI designers have presented commands and features to users in just about every application.  With the latest release of Microsoft Office, Microsoft has invested several years of R&D for a new concept to replace menus and toolbars.  I think they did a great job with the Ribbon with Galleries and the Quick Access Toolbar, and "Office Button."

Telerik and Infragistics along with other component vendors have jumped onboard to offer us the ability to easily use these new UI features in our own applications!  Both have done a great job.  I'm somewhat biased with the Infragistics toolbar managers controls (with run-time customization support for end users) because I think the architecture of this is great.  The only two things that they missed (and I'm sure they know about since everyone has brought it up already) is that the window frame that would normally be "glass" in Windows Vista is being drawn over and the missing support for ribbon command merging in an MDI application.  The MDI merging has been one of the great features that has allowed Infragistics to excel.  Between all of the different ribbon controls out there I also think that Infragistics has done the best job at making their ribbon implementation most look like Microsoft's ribbon implementation in Office 2007.

<I want to put an image of each of the component suite's version of the Ribbon for comparison against an actual image from the Word Ribbon>

Office 2007 Ribbon UI Licensing Information

Microsoft has recently released how it is going to allow ISV's to use the new Ribbon.  It's pretty simple and here's my summary: 

• Follow the Design Guidelines (Five years down the road we don't need to see a million different versions of the ribbon!  We want to keep it the same so that end users will be able to feel comfortable going from application to application
• Register your application on the Office UI Site
• Don't use the new UI in an application that competes with the core applications in Microsoft Office - (Sorry, you can't use the Ribbon if you are developing something like a commercial version of Open Office)

There is a great Channel 9 video available that even includes a Microsoft attorney in it (probably the only one that has a member of their counsel) that discusses this new licensing.  Both Infragistics and Telerik (and several other component vendors) are partners in offering controls that follow the design guidelines.  I am really happy that Microsoft has opened up I am proud to see the vendors stepping up and making this new UI revolution available to the masses for use in their own apps.  (They've even been released before the official release of Office 2007 to the public! CRAZY)  If you happen to have any more questions about the whole licensing thing you can always shoot a good question over to officeui@microsoft.com.

Scheduling

<Section Not Completed Yet - Update Soon>

Tablet PC

This is one area that Infragistics definitely wins over all component collections.  Coming from doing medical industry development, I have been able to leverage the Tablet PC features of the Infragistics NetAdvantage suite.  We were able to use the ink-enabled controls inside our Windows Forms medical records app and the physicians loved the ability to write with their Tablet PC into the patient's record.

Surprisingly, it is extremely easy too.  All you have to do is drag and drop the WinInkProvider on to your form and all of the Infragistics controls instantly show their Ink buttons on an Ink-enabled OS installation (if the Ink button display visible property is in its default state.)  You can force the display of the ink button as well for devices that aren't ink enabled so that you can draw ink with your mouse...  Not fun though :(

Composite UI Application Block (CAB) Support

Both suite's controls support the CAB framework.  If you haven't taken a look at this new application block it's actually quite handy for UI developers.  I really enjoyed learning about it and am looking forward to the opportunity to take advantage of it in my next app.  For more information on CAB:

• http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnpag2/html/cab.asp
• http://practices.gotdotnet.com/projects/cab
• http://www.infragistics.com/hot/cab.aspx

From what I heard, developers from Infragistics actually contributed greatly to the CAB project and were an instrumental piece of making it all happen... Kudos to them.

Miscellaneous

Support

I have very strong opinions about support with a product.  Let's face it, you will never everything about the control suite that is available.  I would be surprised if there is someone at each of the component vendors who knows EVERYTHING about their control suite.

The one thing that just drives me bonkers is the inability to be able to call somewhat up on the phone to get some support at Telerik.  The support tickets that I have submitted have gone great in solving the issue but you know how well e-mail correspondence can go for in a support situation.  Especially having to wait between responses.  (Can you tell that I can get impatient at times? :) )

I just want to pick up the phone sometimes and just get something resolved so I can keep trucking with my development.  That's the nice thing about purchasing Priority Support with an Infragistics subscription.  You got to do it, it's well worth it and the people on the other side have always been extremely courteous and knowledgeable.  Not to mention spend as much time as is needed getting the issue resolved.  You know how you call some support lines and you can just tell the person on the other end just wants to get you off the phone as quickly as possible?...  Completely irritating if you ask me!

Learning

If you are looking for a great suite that has tons of further reuse but will require an investment of learning ramp-up time then go with Infragistics.  I will describe the Telerik r.a.d. controls suite as "simple" in comparison but that's not always what you want out of a control suite that you will use again and again.  Plus, a good way to go is to make the investment of going through the offered training.  Infragistics has both a fundamentals and advanced course that can be taken in person or online.  You can't beat that.

Some amount of time is needed to sit down and learn the Presentation Layer Framework (PLF) and use the controls effectively.  But once you have made the investment, you don't have much to learn about the individual controls after that since the whole suite uses the PLF.  Infragistics even offers the ability to use the PLF in any components that you actually write.  (See specifics)

Documentation

This is one area in which Telerik is lacking tremendously.  I have found it really difficult to navigate through their documentation.  Over the past couple of releases I would have to say that Infragistics has been improving their documentation pretty much exponenentially.  Before selecting a component suite for your organization be sure to download the trials and check out the documentation and make sure your developers will be able to find the info that they need!

Source Code

Both Telerik and Infragistics offer you their source code as part of a subscription purchase.  Until recently, Telerik would require that you purchased more than five licenses to have access to the source control.  I'm glad they changed that licensing model.

Pricing

Here's what I found as of December 1, 2006:

Telerik:

r.a.d. controls for ASP.NET Subscription:  $999
r.a.d. controls for ASP.NET:  $799

r.a.d. controls for Windows Forms Subscription:  included with ASP.NET subscription until March 2007
r.a.d. controls for Windows Forms:  included with ASP.NET license until March 2007

Infragistics:

NetAdvantage .NET (ASP.NET, Win Forms, and AppStylist) Subscription with Priority Support:  $1,490
NetAdvantage .NET (ASP.NET, Win Forms, and AppStylist) Subscription:  $995

NetAdvantage ASP.NET Subscription with Priority Support:  $1,290
NetAdvantage ASP.NET Subscription:  $795

NetAdvantage for Windows Forms Subscription with Priority Support:  $1,290
NetAdvantage for Windows Forms Subscription:  $795

NetAdvantage AppStylist with Priority Support:  $1,195
NetAdvantage AppStylist:  $695

Value

Telerik has a total of 18 controls (36 including the Windows Forms suite.)

Infragistics has a total of 88 controls and in my opinion has more bang for the buck...

<Section Not Completed Yet - Update Soon>

Volume Discounts

Telerik:

3 to 4 licenses - 10%
5 to 9 licenses - 20% 
10 to 19 licenses - 30%
20 or more - 40%

Infragistics:

Member of Enterprise License Program (>25 Any Infragistics Licenses) - 15%

Licensing

Pretty much every company has had great licensing models to deal with.  Per-Developer and royalty-free for applications produced from the licenses is definitely the way to go.  One thing that I am disappointed with is that the big developers force you to purchase another license for a build machine.  I really don't agree with this model.  The ability to centralize team builds using a product like Microsoft Team Foundation Server is a great feature to have... but having to spend more money just to have the binaries to compile your app?  Not a good way to go.  I hope that each of the components vendors will address this issue soon and change their licensing models to allow for a build machine license.

Single Vendor Exclusives and Other Vendor Comments

I've made a couple of comments about what each of the vendors developer that is exclusive to the other component vendors.  Also, I wanted to take the opportunity to make some comments that don't necessarily fit in any other section of this article.

Telerik

r.a.d. Rotator, r.a.d. Window, r.a.d. Upload and more... 

<Section Not Completed Yet - Update Soon>

Infragistics

AppStylist, TestAdvantage, JSF, and more....

<Section Not Completed Yet - Update Soon>

Developer Express

<Section Not Completed Yet - Update Soon>

Component One

<Section Not Completed Yet - Update Soon>

ComponentArt

<Section Not Completed Yet - Update Soon>

Summary - Final Conclusion

Honestly, if your organization hasn't already chosen a component suite for regular daily use in your applications you absolutely will benefit so much by going out and getting one.

<Section Not Completed Yet - Update Soon>

Let me know what you think... I'd like to hear about other developer's opinions about what they like/don't like in the different component suites!  I hope that this helps you out in your product selections and feel free to let me know if you have any further questions about my experience with any of the component suites.

I will end with this:  I also know the other camp of developers who feel that only the controls that are in Visual Studio should be used.  The opinion I hear from that camp is that you get stuck down to a third-party when you begin to use outside controls.  Well, here's my opinion:  You can make a good UI with the out-of-the-box Visual Studio components but you can't make an AWESOME one without a lot of effort.  Imagine having to draw really good looking charts using only the System.Drawing namespace!  Now imagine just dropping a chart from the toolbox, using a designer, and then data binding...  That is what is in store for you!

Now Go Vote

There are several publications that are asking for your votes on the different component suites... So now is your chance to give your opinion for which one is your favorite:

• Sys-con's 2007 Readers' Choice Awards
  • http://java.sys-con.com/general/readerschoice.htm
  • http://soa.sys-con.com/general/readerschoice.htm
  • http://webddj.sys-con.com/general/readerschoice.htm
  • http://dotnet.sys-con.com/general/readerschoice.htm
  • http://ajax.sys-con.com/general/readerschoice.htm

Some legal disclaimer stuff:

This article expresses my personal views and opinions and are not the views of my employer, previous employers (or future employers for that matter.)  The information contained in this article is provided without any express, statutory, or implied warranties.  In addition, the respective companies, products, components, and other commercially available software suites are either registered trademarks or trademarks of the respective organizations in the United States and/or other countries.

Funny aside:  While I was in college, I would always complain about writing reports anything over 500 words... LOL  I just absolutely hated doing it.  Although, if you haven't seen one of the cool new features of Microsoft Office Word 2007... wait until my next post.  I sure would have loved to have that while I was doing research and stuff in school!  Kids these days...  They have everything handed to them :)

Ed B.

Update : If you are wanting to learn how to undo or rollback a changeset using TFS 2010, visit my new blog post about this topic here: http://www.edsquared.com/2010/02/02/Rollback+Or+Undo+A+Changeset+In+TFS+2010+Version+Control.aspx

So... I really needed to undo a changeset that was previously made by another user and started looking around for it. I knew you could do it but just hadn't ever had a need for it. I figure I start right-clicking different places in Source Control Explorer but that didn't lead me to anything :(

Until I remembered there were cool new features in the Team Foundation Server Power Toys. Once of which was an undo changeset command. Take a look at them because I know you will find several features handy. One of my favorites in there as well is Annotate. (Thanks to Dave McKinstry for previewing that one to us!) It's basically a solution to point-the-finger game for changes... It will show a bar on the side next to every line that shows who the last person was that edited it, date/time, and the changeset number. You can even double-click on the changeset number and the actual details of the changeset will pop-up. Very handy!

Other features in the power toys package: (taken from the documentation)

Unshelve Command

Rollback Command

Online Command

GetCS Command

UU Command

Annotate Command

Review Command

History Command

Workitem Command

Query Command

TreeDiff Command

Ed B.

So, Wow... All of y'all that happen to use Facebook they have released an initial API that you can use to make applications that will read data from it once Facebook users have logged in and approved to use either your web or desktop application.  Pretty cool I think!

http://developers.facebook.com/index.php

I haven't dived too much into it since I am getting ready to leave out of town for Labor Day Weekend but at first glance:

1. One thing I don't like is that it uses the REST protocol.  For more info about it check out the Wiki on it:  http://en.wikipedia.org/wiki/Representational_State_Transfer  It's pretty much making a POST of XML and then returning
2. They do say that they have plans on supporting SOAP:  http://developers.facebook.com/faq.php
3. I also noticed two guys have already made a VB.NET and a C# library to use.  I haven't looked at them yet and will take a look at them to see how well they did.  Obviously, I'll use the VB one :)  If I don't happen to think they will be useful for me, then I'll just create a Facebook.NET Library for it or just wait for them to implement SOAP so we can just use web services.
4. You can't get the entries of the logged in user's wall (or whichever user they choose to view.)  You can only get the wall count.  Boo!

Once again, it's a very early implementation.  I'm going to have to blame all those people who have nagged me for three years while I was in college about not having a MySpace and a Facebook because I broke in and now I'm glued on checking mine everyday.  I have gotten to meet up with a lot of people though that I haven't talked to in a long time.

Have a safe and fun Labor Day Weekend!  I'll be heading to Austin!

Ed B.

So many people think that I work for DevExpress because of how much I rant and rave about CodeRush and Refactor Pro!

I'm telling you... CodeRush and Refactor Pro are definitely two of my most favorite tools!  But I really don't work for DevExpress... I'll blog later on both of them and some of the tools that I use from day to day that are built upon DX Core which is the foundation for both of their products and many other small tools.  If you haven't looked in DX Core (which is free) and you build or will build a Visual Studio add-in then you should definitely give it a shot.

My next plan for a coding tool that I could use from day to day is adding comments to code files in the format that I always use.  There is actually a tool that uses DX Core that does this called CR_Commenter but the bad thing:  It's only for C# code.  I thought about rewriting it for VB developers (and myself.)

Ed B.

So this is the other Ed.  Ed B.  The Toy Boy as I am lovingly called.  I suppose I get my nickname because I like new gadgets and gizmos.  I also get my name from the constant search and discovery of new tools and components that make my life (and the rest of our lives) as developers better.

My professional objective in life is to provide more productivity and efficiency to people, developers, and processes.  I won't get all philisophical but I think that is how mankind will prosper :)

Enough of that!  From time to time, I'll add new commentary about new tools that I have found and ones that I use from daily in my developer life and in school.  There are some that I absolutely love more than anything else and just can't live without... some people even think I work for these companies since I am such a proponent! (I don't)

So until later, be more productive and efficient in your development!

Ed B.