I had a good time yesterday with Greg & Martin chatting about Lab Management in the latest episode of Radio TFS.  If you don’t subscribe to the Radio TFS podcast series, I would definitely recommend it.  They are roughly 30-minute episodes and are an easy listen that you can fit into your weekly routine.

Download Radio TFS Episode

Let me know if you have any questions about any of the topics we discussed during the episode!

Ed Blankenship

In this episode we chat with Ed Blankenship about his new job at Microsoft as a program manager on the Test & Lab Management product team.

Before recently joining Microsoft, Ed was a Microsoft MVP for TFS and Visual Studio ALM in which he has been involved & using since the very beginning of the products nearly seven years ago. He worked as the Practice Technical Lead for the ALM/TFS Consulting Practice as Imaginet (formerly Notion Solutions). Ed was also voted as the Visual Studio ALM & Team Foundation Server MVP of the Year for 2010 by his group of peers in the MVP Community.

He is also an author of the Wrox Professional Team Foundation Server 2012 and TFS 2010 books. You can follow Ed via is blog at http://www.edsquared.com/ or via twitter @edblankenship

Links from the show:

• TFS 2012 Power Tools are now available! [Brian Harry]
• Team Foundation Service Updates 9/17 [Aaron Bjork]
• Using a Lab Environment for Your Application Lifecycle [MSDN]
• Lab Management Overview Video
• TechEd Talk about Lab Management 2012
• Using CloudShare for Lab Management with TFS Preview
• Visual Studio ALM Rangers Lab Management Guidance

For feedback contact radiotfs@gmail.com or call +1 425 233-8379.

Jason Zander, the Corporate Vice President for Visual Studio, has tweeted that the Visual Studio 2012 will release to manufacturing (RTM) in early August which is the same time that Windows 8 will RTM as announced at the Microsoft Worldwide Partner’s Conference.

The Visual Studio 2012 release includes all of the individual components of the Visual Studio family including:

• .NET 4.5
• Visual Studio 2012 Ultimate, Premium, Test Professional, and Professional
• Team Foundation Server 2012
• Microsoft Test Manager 2012
• Lab Management components of Visual Studio, Microsoft Test Manager, and TFS
• Feedback Client
• Visual Studio Agents

It’s just around the corner now!  If you haven’t had a chance to Go-Live on the 2012 release, then start making plans to get upgraded at RTM!  Remember, if you don’t feel like setting up TFS 2012 internally, you can always use the Microsoft hosted version of TFS available at:  http://www.tfspreview.com/.

Ed Blankenship

Wow – I just wrapped up my first week at Microsoft and I’m amazed at a lot of the things that the Developer Division is doing.  Several things were announced this week while I was in Redmond for New Employee Orientation but I bet the keynotes will have more next week at TechEd North America 2012.

I hope you will be attending TechEd this year and if you are, there are some really great booths going to be available in the Expo hall.  I will be working at the Visual Studio ALM booth most of the week so stop by if you want to say hi & chat!  I would also love to setup side meetings so let me know.  Here’s my booth schedule:

• Monday, June 11, 2012
• 10:30 AM – 12:30 PM
• 5:30 PM – 9:00 PM
• Tuesday, June 12, 2012
• 10:30 AM – 1:00 PM
• Wednesday, June 13, 2012
• 10:30 AM – 1:00 PM
• Thursday, June 14, 2012
• 10:30 AM – 2:00 PM

Also be sure to add each of the Visual Studio ALM, Testing, and Team Foundation Server sessions to your TechEd Calendar.  There are some great speakers coming in both from the product group and the great group of Microsoft MVPs.

See you next week!

Ed Blankenship

I have decided to take a position as Program Manager at Microsoft to work on the Lab Management scenarios on the Visual Studio Testing & Lab Management team.  This product team owns Microsoft Test Manager (which you can acquire in many editions including Visual Studio Test Professional, Visual Studio Premium, and Visual Studio Ultimate) as well as the testing & Lab Management scenarios of Team Foundation Server.  Today is my first day at Microsoft and will be attending New Employee Orientation (NEO).

If you are not familiar with Lab Management, in a word – it is awesome for development and test teams.  You can provision developer & test environments for use as you need them with tight integration back into the rest of Visual Studio and Team Foundation Server.  It is a feature of Team Foundation Server and you likely have all of the licenses that you need if you have MSDN subscriptions!  That means no additional license costs to take advantage of this functionality as opposed to some other solutions on the market.

Here is a high-level diagram of how it works and I have a slide deck from my 4-hour end to end Testing Workshop which includes a section on Lab Management and how it fits into the overall picture available here:  https://skydrive.live.com/redir?resid=77DB794C0A4DFE0!23778 

FYI – For those that may not understand the reference, I previously had a purple Microsoft badge (or a b-dash) as a Microsoft MVP and Microsoft Partner working closely with the product team.  One receives a blue badge whenever they start on as a full-time employee.

Microsoft MVP

Having been part of the Visual Studio ALM & TFS Microsoft MVP group for the last five years, I can honestly say that it is the best group of ALM colleagues in the world.  They have been awesome to work with and I’m really excited about continuing to work with this same group.  Each one of my MVP colleagues brings something different to the table but the one thing in common is that everyone has been an awesome advocate for customers of TFS and Visual Studio ALM products around the world.  There is a deep interest in making things succeed and I know that I am better for it having been a part of the group.

Imaginet

I have enjoyed my time at Imaginet (and formerly Notion Solutions) as the ALM Practice Technical Lead along with Dave McKinstry.  It’s all because of all of the great people that I have worked with.  Last year, Imaginet was honored with the Microsoft Partner of the Year award for Application Lifecycle Management.  It was just a formal indication about how awesome the ALM group of colleagues is to work with but it is something I already knew.

I am extremely fortunate to have been able to reach so many Visual Studio ALM & TFS customers while I have have been in my consulting role.  I am excited about taking that front-line experience and using it to drive further improvements into the product line.  Lately, I have been leading our Build Center of Excellence (CoE) team as well and have learned a lot about providing builds as a service and virtual environments (Lab Management) as a service to internal engineering teams for customers.  The team is doing some amazing stuff!

TechEd North America 2012

After my New Employee Orientation, my first trip as a Visual Studio ALM Program Manager is heading down to Orlando this year to work as a Microsoft booth staff member at TechEd North America 2012!  I had already been planning to work at the booth as a Microsoft MVP.  I won’t be speaking like I did last year with Christophe but that makes it less stressful for me!    I would love to meet up with you so please come by and we can talk about the product.  I’m looking forward to hearing about what’s working really well and what doesn’t work very well for your team.  I will be staffing the booth quite a bit over the week but feel free to get in touch with me if you would like my schedule closer to the event!

Take care!

Ed Blankenship

Wow!  The Release Candidate for Visual Studio 2012 and Team Foundation Server 2012 are now available on MSDN Subscriber Downloads!  The final marketing names for the former Visual Studio “11” and TFS “11” (as codenames) have been announced with this announcement as well!

• Visual Studio 2012
• Team Foundation Server 2012

As Jason Zander mentioned, that means that the final RTM release will be sometime this calendar year!  Check out the new logo too!

Visual Studio 2012 also received a face lift with added “energy” when compared to the Beta release.  I think it is looking pretty sharp now!

I won’t go into all of the details of each of the new features introduced in the Release Candidate since there are several folks that have done a great job.  What I am a fan of that I’m super glad made it into the release is a new feature of Team Foundation Server 2012 when upgrading for enabling new features in team projects without having to immediately upgrade process templates for each existing team project.  Ewald Hofman (former Microsoft MVP in Visual Studio ALM) was able to document this new feature in two great new blog posts:

• Deep Dive on Configure Features
• How to Configure Features for Dozens of Team Projects after Upgrade

Check out more coverage here:

• Brian Harry
• Visual Studio Product website
• Eclipse update site for the latest Team Explorer Everywhere preview or the download page
• Overall summary of changes since the Beta
• For filing bugs: Visual Studio and TFS, LightSwitch, or Blend Connect sites
• For asking questions:Visual Studio and TFS or Windows forums
• Jason Zander
• S. Somasegar
• Scott Hanselman

There will not be an RC-specific version of the TFS 2012 Power Tools but the Beta release will continue to work with the new version.

Enjoy!

Ed Blankenship

I love learning new things and today I learned something new for Team Foundation Server.  This one has perplexed me in the past and it’s one of the areas that I just never dived down deep enough to try out.  I’m more writing this blog post so I can search for this again when I come to this situation in the future!

Essentially, I wanted to remove some users from the built-in “Team Foundation Service Accounts” security group at the server-instance level.  They are added whenever you add them in the “Administration Console Users” group in the TFS Administration Console.  However, when you look at the built-in service accounts group using Team Explorer or the Administration Console, you’ll notice that the dialog commands are disabled.

There are some side-effects for having real users in this security group so I wanted to remove them completely and leave only the actual TFS Service Account user.  Some of those side effects are more pronounced in Team Foundation Server “11.”  No worries though – because a colleague tipped me at using the command-line tool for managing security, TFSSecurity.exe.  It’s a command-line tool that I actually rarely use and completely forget is available but it’s super powerful.  In our case, it was pretty easy for me to use the /g- switch which allows for removing a member from any security group including this built-in one.

>tfssecurity /g- "Team Foundation Service Accounts" n:DOMAIN\username /server:https://tfs.mycompanydomain.com/tfs

It works!

Ed Blankenship

I’m absolutely a fan of SnagIt.  It has a low cost and works super well for what it does!  If you want to use SnagIt with Microsoft Test Manager and the new Feedback Client for Visual Studio “11” and Team Foundation Server “11” then you are in luck!  By default, they both use MSPaint for editing screenshots but if you have SnagIt, you definitely want to use something more powerful to help you provide even better screenshots.

Configuring the TFS Feedback Client to Use SnagIt

This one is easy.  You’ll want to open up the client (even if you aren’t currently giving feedback) and then click the little gear icon at the top.

Next, you’ll want to provide the path to the SnagIt Editor and then provide the command-line arguments which is just the filename placeholder for the screenshot.  If you don’t enable the checkbox for automatically opening the screenshot each time, don’t worry because you can always double-click any screenshot in the feedback client to open the SnagIt Editor.

Configuring Microsoft Test Manager to Use SnagIt

Whether you want to walk through the manual execution of a test case or use the new Exploratory Testing features of Microsoft Test Manager, you can use SnagIt to help you annotate screenshots here as well.  It’s a very similar and easy process as well.  In this case, the gear icon is available at the bottom-right corner of the test runner window.

You’ll then see a familiar dialog window to set the screenshot annotation options to SnagIt here as well.

Why use SnagIt with Screenshots?

The value propositions to me for being able to use SnagIt are the following.

• Annotations – I can add arrows, highlights, text bubbles, etc. really easily.  Those can make a big difference for someone looking at screenshots.
• Blurring Personally Identifying or Sensitive Information – This is a key one for me at times.  It is really easy to select an area of the screenshot and apply a blur effect

Ed Blankenship

I was reminded by someone that this is huge.  It’s something that hasn’t really sunk-in for people following the new release of the Visual Studio family of products.  It is a subtle thing that will really help people with adopting Visual Studio “11” without making the rest of the team adopt it -- even while it is in Beta & RC.  Because we now have “round-tripping” of Visual Studio solutions & projects, we no longer need to “upgrade” a vast majority of the VS project types when you open a solution in Visual Studio “11.”  That means that a few people can install Visual Studio “11” Beta/RC/RTM without interfering with everyone else on the team.  It allows for a rolling adoption across teams as each team member is ready which is a key adoption feature for this release.

• Most solutions and projects can be opened in Visual Studio 2010 SP1 and Visual Studio “11” without requiring upgrades of the solutions.  There is a constantly updating list of the project types that aren’t currently supported available on MSDN but again, most of the ones that people interact with every day are supported.
• Visual Studio “11” can be installed side by side with Visual Studio 2010 SP1.
• You do not need to adopt .NET 4.5 for your applications if you want to start using Visual Studio “11”.  Visual Studio “11” targets .NET 2.0, .NET 3.0, .NET 3.5, .NET 4.0, and .NET 4.5.
• You do not need to upgrade to Team Foundation Server “11”.  Visual Studio “11” will connect with a TFS 2010 server and work similar (but better) than the Team Explorer 2010 client.
• The opposite of the previous bullet point is true as well.  If you do upgrade to Team Foundation Server “11”, you do not need to also upgrade your Visual Studio edition.  You can connect from Visual Studio 2008 and Visual Studio 2010 to a TFS “11” server instance.  You’ll want to install the forward-compatibility update for earlier editions:  http://www.microsoft.com/download/en/details.aspx?id=29082

This is a subtle but huge change in this next release that we need to stress with all development teams.  It will help increase the speed at which teams will adopt Visual Studio “11” and future releases.

Ed Blankenship

When talking with our consulting customers and leading our 4-Hour Testing Workshops across North America, there is some common confusion about what exactly the differences are between Microsoft Test Manager and Visual Studio Test Professional.  It’s a pretty simple difference that I’ll see if I can help clarify and share some additional news for the vNext release of the Visual Studio family of products at the same time.  Once you get the difference, it will make perfect sense!

Visual Studio Test Professional

Visual Studio Test Professional is one of the different SKUs that you can purchase from the Visual Studio family of products.  What this means is that this is the “box” that you buy.  You can’t buy Microsoft Test Manager.  You buy an edition of Visual Studio that includes Microsoft Test Manager.  Visual Studio Test Professional happens to be the edition that many people will get when they are looking only to get Microsoft Test Manager (in addition to a TFS CAL and MSDN Subscription).

Microsoft Test Manager

Microsoft Test Manager is the application you use to interact with Team Foundation Server to:

• Create and manage test plans
• Create, author, and maintain manual and automated test cases
• Manage association of automation for test case artifacts
• Run exploratory tests
• Analyze previous manual, automated, or exploratory test runs
• File rich actionable bugs while executing manual test runs or from automated test runs
• Create and provision individual or shared lab environments with multiple machines for development or testing with Lab Management
• Connect to physical or virtual lab environments for development or testing with Lab Management
• Facilitate structured User Acceptance Testing (UAT) from business users
• And lots more…

Microsoft Test Manager actually is included with two of the different SKUs or Visual Studio editions in the Visual Studio 2010 release.  You can acquire either Visual Studio 2010 Ultimate or Visual Studio 2010 Test Professional to receive Microsoft Test Manager.

Visual Studio “11” Release Changes – So Far

(Written for Beta) Microsoft has announced that Microsoft Test Manager will now be included in the Visual Studio Premium edition in addition to Visual Studio Ultimate and Visual Studio Test Professional.  That’s a great change and brings a lot of value to the Visual Studio Premium SKU!  You can find out some additional comparisons (that have been publicly announced so far) here on the Microsoft site:  http://www.microsoft.com/visualstudio/11/en-us/products/compare

Need Help?

Let me know if you have any additional questions!  We help customers all the time figure out what types of licenses they should get, advocate to get the best pricing for their company, and sort through all of the licensing details to come up with the best scenario.  Contact me and I’ll be happy to get you started down the right path.  BTW – if there is also one thing to remember, don’t pay retail prices for any Visual Studio licenses before you come talk to us!

Ed Blankenship

Effective for Team Foundation Server 2010 users and assumingly going forward for Team Foundation Server 11, users who view read-only data for reporting purposes no longer need a TFS Client Access License (CAL).  More information about the announcement from Brian Harry is available here:  http://blogs.msdn.com/b/bharry/archive/2012/03/08/even-better-access-to-team-foundation-server.aspx

The definition of “reporting data” is not defined completely but the spirit of the licensing change is to address a challenge the Microsoft MVPs and other customer channels have brought up:  occasional stakeholders who are looking at reporting data should not be required to be licensed fully with a TFS CAL as other team members who contribute regularly to a software release.  They traditionally want to view progress or see potential issues.

Reporting data is exposed in several different places in Team Foundation Server:

• Excel Workbooks
• SQL Reporting Services Reports
• Rich Dashboards with SharePoint Team Portals (using SharePoint 2010 Enterprise)
• Custom Applications Displaying Read-Only Reporting Data
• Other Self-Service Business Intelligence Tools

You may need other types of CALs depending on the particular scenario but thankfully you won’t need a TFS CAL.  Also, if these users are “writing” or “updating” information back to TFS, then that wouldn’t be considered viewing reporting data.  You’ll likely need a TFS CAL for those scenarios.  Remember though that users have always been able to create new bugs & feature requests without needing a TFS 2010 CAL as well using Work Item Only View.  This is a great improvement with this new addition to the CAL exclusions for TFS.

This licensing change is retroactive and in addition to the announcement that the Visual Studio Team Explorer Everywhere client for Eclipse-based IDEs is now free!

Ed Blankenship

The cross-platform (Windows, Linux, and Apple Mac OS) Eclipse-based Team Explorer, Visual Studio Team Explorer Everywhere, is now available without any costs!  The free version will continue to not include a TFS Client Access License (CAL) so just be sure you are covered elsewhere for CALs if you happen to need one in your environment!

It’s really great news for all those software engineers not using Visual Studio for building applications or for those using Linux or Mac OS and want to interact with the rest of the software engineering teams using Team Foundation Server.

Additional Information

Announcement Details

Previously sold as a separate product, Visual Studio Team Explorer Everywhere 2010 works with your favorite Eclipse-based IDE, in the operating system of your choice, and helps you collaborate across your .NET and Java development teams using Team Foundation Server 2010. It’s an easy-to-install standalone plug-in that's now a free download. A Team Foundation Server CAL may be required. See Visual Studio 2010 and MSDN Licensing for details.

Download Here

Ed Blankenship

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

I have run into a new situation more often that caused a few concerns for me that I thought I would discuss it some here.  Let’s face it:  there are bugs in the Visual Studio family of products.  People have reported performance problems (and thankfully PerfWatson has been helping out tremendously with rich actionable data for the Visual Studio product teams.)  However, did  you know that a ton of these bugs are resolved & released after initial release?  There are been great stability and performance improvements that have been released since the initial RTM of each of the Visual Studio versions.

Starting with the Visual Studio 2010 and Team Foundation Server 2010 release cycle, Microsoft has started to put more and more of these updates through the Windows Updates distribution system.  It’s great!  They are easily discoverable and can be part of your regular updating schedule.  However, this only works if they are actually available to you.

I have found more and more that people aren’t actually seeing these Windows Updates for Visual Studio and TFS in corporate environments.  When I started looking into this with a few companies, I discovered that IT departments are purposely either ignoring anything “developer” related in the Windows Updates system or rejecting them completely.  What?!  There were some that didn’t even know to look at these important categories. 

If they do see them but have been ignoring them, the reasoning has typically been because IT groups don’t understand the impact of those changes so they just would rather ignore them until they understand them more.  I think that’s fair but there didn’t seem to be any drive for already over-burdened IT teams to actually figure out those impacts.  IT departments are not traditionally using Visual Studio from day to day and don’t typically have the right expertise to understand the impacts.  There has traditionally been a gap between Software Engineering groups and IT departments at companies.  That’s a bigger problem to tackle for a different day.   However, this is where a software engineering team can collaborate and help IT departments out.

Distributed Updates in Corporate Environments

You may have been asking, “why would my IT department have anything to do with the Windows Updates on my development or testing machines?”  That’s a great question.  In some corporate environments, you can actually setup internal servers to act as an intermediary between the machines on the internal network and the central Windows Update system.  IT departments do this for many reasons including making sure that certain updates won’t impact existing applications on business users machines.  Let’s face it – your VB6 invoicing & order processing app that you built 15 years ago that is still limping along but vitally important to your business may or may not get impacted by a new update that’s available for Windows 7.  It happens, right?

To help you feel better about the updates we’re discussing in this blog article: there is a very high cost internally for anyone on the Visual Studio product teams to push an update through the Windows Updates system.  There’s a very high quality bar before they are approved internally.  They also wait for several weeks to a couple of months to make sure that no critical issues are reported from early adopters of those updates.  Not every update is sent through the Windows Updates system so the ones that do really are important.  There are many updates that are beneficial that never get released through Windows Updates.

There are many commercially available tools for “pushing” updates to customers.  Off the top of my head, Microsoft has a high-end version called System Center Configuration Manager and a free version included with Windows called Windows Server Update Services (WSUS).  Additionally, there are group policies in Active Directory that IT Administrators can apply to have machines in the domain talk back to one of these servers for their updates.  You can usually tell if you are in this situation by heading to Windows Updates from your Control Panel and checking to see if it says something like “Managed by your system administrator.”

Check out the Best Practices for Group Policies when using WSUS

You could click the link that says “Check online for updates from Microsoft Update” but some IT departments have even disabled that link from working through Global Policy.  If any of this is setup internally, it means that all updates basically go through a gatekeeper which is someone who is actively (or inactively) managing the updates in your IT department in one of these internal update servers.  This can be a good thing or a bad thing from what I am seeing more often.

Approve the Visual Studio Family Updates

This is the time when you might want to setup a meeting with your IT department to indicate that your software engineering teams actually do care about these updates and want them approved or even delivered automatically.  They may not even know that they even exist now with this new release.  Here are the categories that the teams should think about covering:

• Visual Studio (including Agents)
• Team Foundation Server
• Expression
• .NET Framework

There was improvements that helped performance in the Workflow Designer when editing TFS Build process templates in Visual Studio 2010.  These improvements were actually delivered as a .NET Framework QFE.  BTW, There are also additional steps that you could take that I have discussed previously on my blog.  My point by mentioning this is that IT Departments still need to monitor for even .NET Framework updates to help improve the stability and performance for the development environment for software engineering teams.

Enabling Microsoft Update

If your machine isn’t dictated by an internal Windows Updates server by global policy (or if you use check for updates online using the central Windows/Microsoft Updates infrastructure) you may still not see the Visual Studio updates.  This is because by default Windows only checks for Windows Updates.  If you want to check for updates for all Microsoft software then you actually need to enable Microsoft Update.  There is a small distinction but has a large impact on what’s available for your machine. 

Product Updates Improvements in Visual Studio vNext

For those that seem to still have issues with Windows Updates internally, you’ll like seeing that Visual Studio “11” now has Product Updates shown with other types of tools & extensions updates in the Extension Manager.  I doubt that this will include Microsoft Test Manager or Team Foundation Server updates though.   I hope I am very wrong about it though and would be very happy if they do send those types of updates down through this new mechanism!

You can see these by heading to Tools –> Extension Manager and then look at the Updates section of the window as shown below.  I can imagine us seeing all sorts of new updates that will come through this system including feature packs, power tools, cumulative updates, etc.  I would imagine that there will be quite a few more updates then would even traditionally be sent through Windows Updates.  That’s a big win for us especially when you want to have the latest features & stability improvements available for your development environment.

Go have that discussion with your IT department now and if you can see what might be missing by checking for updates from Microsoft’s centralized Windows or Microsoft Update.

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

If you haven’t talked to me before, I am a serious fan of the Symbol Server and Source Integration in Team Foundation Server.  Recently, I thought about reducing the complexity of the entire story especially for those using Team Foundation Server.  You still have to have a file share available for symbols which is just something else to have to request, manage, deal with for disaster recovery, and is particularly problematic when users are in geographically remote offices.  Individual developers also have to manually register the symbol server in the Visual Studio options for each of the development machines they ever use.  Why though?  It shouldn’t be this difficult especially when you have already adopted TFS.

I submitted a new feature request on the Visual Studio Team Foundation Server product team’s User Voice site specifically for assisting with this complexity.  I would like TFS just to be treated like an enterprise symbol server and Visual Studio can just take advantage.  My good friend and colleague, Adam Cogan, encouraged me to share with my blog readers more details about this feature request.

I would also like to ask for your help with voting on the feature request if you like the idea and would be important for your team & organization.

VOTE HERE

Additional Details for the Feature Request

Version Control Folder to Hold Symbol Server Files

The main part of this would be something like a version control folder to hold the symbol server files such as $/Symbols.  This would be a special folder that would only be used for Symbols.  You would then be able to have a URL endpoint that TFS recognizes and handles appropriately (i.e. https://tfs.myserver.com/tfs/DefaultCollection/Symbols).

With this type of feature in TFS you can take advantage of many side benefits including:

· No file share to worry about getting provisioned by IT or backed up

· Takes advantage of TFS Proxy caching for geographically distributed locations

· This could be a special version control folder type where it doesn’t have to keep history – only the latest version (T)

· Would work out really well for those using TFS on Azure (especially with on-premises build servers)

· Potentially Symbol Server for CodePlex projects!

· IntelliTrace & the VS Profiler benefits greatly from this as well!

Automatic TFS Build Configuration

If this feature is setup & configured, then why not just go ahead and auto-configure new TFS build definitions as well?  Pop it right in there…

Automatic Client-Side Configuration

If I connect to a Team Project Collection, I want my Visual Studio (and other clients that use symbol server) to be auto-configured for the symbol server to be used.  It should just be automatic!  This would be very similar to how the client auto-configuration for TFS Proxy just works for anyone doing a version control get.

Build Retention Policies

If you have symbols turned on for TFS builds to handle when retention policies are run, you could configure it to either destroy or delete the symbols from the special version control folder.  As an administrator, I may want to actually destroy the symbols with retention policies for some of my build definitions just to save on space.

Help me everyone out with your votes!

Ed Blankenship

Team Foundation Server has the ability to deliver e-mail alerts.  I have talked about this feature a few times (like here, here,  and here) and it’s a very handy feature of any work item tracking system let alone version control, automated builds, test case management, etc.  In the TFS Administration Console window, you just need to enable and specify the e-mail alert settings from the Application Tier node.

Here’s the one caveat about this functionality:  TFS needs the SMTP server to allow unauthenticated requests.  Notice that TFS doesn’t allow you to specify a user name and password.  Other applications do allow this -- for example, my Windows Home Server 2011 instance at home asks for additional information.

Several e-mail servers on the market, including Microsoft Exchange Server, do not allow unauthenticated SMTP requests by default.  In general, you actually don’t want to open up your SMTP server for unauthenticated requests or have an open SMTP server on your network.  This can open you up to security issues and would allow malware or compromised servers to use it as a relay.  Not fun stuff at all.

The preferred approach would be to let your e-mail server know to allow unauthenticated e-mails from each of your TFS application tier servers.  (Note:  You may have multiple application tier servers if you have setup your TFS environment to be highly available using network load balancing and created an AT web farm.)  Since most of the customers I visit have adopted Microsoft Exchange Server, here are the steps for you to pass on to your Exchange Administrator to take to “trust” TFS to deliver e-mail alerts.  As a TFS Administrator, you will not like have the permissions necessary to make these changes in your internal Exchange environment.

Thanks to the Imaginet Infrastructure team (specifically Kelsey Epps)  for help with these instructions!

Configuring the Exchange Hub Transport for TFS E-Mail Delivery

Your first step is to open the Exchange Management Console and head to the Hub Transport node underneath Server Configuration.  This will show you all of the receive connectors that are currently defined when you select the appropriate hub transport server from this list.

What we will end up doing is creating a new receive connector specifically for use by each of the TFS application tier servers.  In the Actions pane for the Exchange Management Console, choose “New Receive Connector…”

On the Introduction page for the New Receive Connector wizard, enter a friendly name to help other Exchange Administrators understand the purpose of this receive connector and choose “Custom” for the intended use.

On the next page for specifying the Local Network Settings, you’ll likely just want to leave the defaults and specify the fully-qualified DNS entry that will be used in the SMTP response when a client like TFS connects to it.

The next screen for specifying the Remote Network Settings is the important one.  This tells Exchange server which IP addresses should be allowed to use this receive connector.  You’ll want to remove the default entry that exists in the list and then add each of the IP addresses of each of the TFS application tier servers.  (Remember from above, you might have multiple application tier servers in your TFS environment.)

At this point, you are ready to complete the wizard and it will create the new custom receive connector to be used by the TFS application tier servers.  Once the wizard has completed and created the new receive connector, you’ll want to open the properties dialog window for the new receive connector and enable “Anonymous Users” on the Permissions Group tab.

Now, give the fully-qualified DNS name for the Exchange hub transport server to the TFS Administration and they will be able to enter it in the TFS Administration Console in the appropriate spot.  The TFS Administrator will want to monitor the event logs for any error messages after this has been enabled in TFS to make sure that the e-mail delivery TFS jobs that run periodically when there are new e-mail alerts complete successfully.

Using an Office 365 Hosted Exchange Instance

If you happen to be using Office 365 for your Exchange instance, then you will have to setup a local SMTP Relay.  Here are a few online resources for how to do that:

• How to Configure an SMTP Relay for Office 365 – Microsoft Support KB
• Configure Office 365 SMTP Relay – ConfigureOffice365.com
• Office 365 and SMTP Relay – Office 365 Community Forums

Ed Blankenship

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

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

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

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

Ed Blankenship

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

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

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

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

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

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

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

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

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

COMPONENT STORE TRANSACTION FAILURE SUMMARY
    No transaction error was detected.

WARNINGS
    There were no warnings during this operation.

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

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

COMPONENT STORE TRANSACTION DETAILS
    No transaction information is available.

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

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

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

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

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

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

Ed Blankenship

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

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

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

Here’s the full list of the Roadshow Events:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Take care and hope to see you there!

Ed Blankenship

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

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

Special Event: TFS 2010 Build Customization with Ed Blankenship

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

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

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

Location:

Overwatch Systems, 6:30 to 8 PM

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

5301 Southwest Parkway

Austin, TX 78735

Looking forward to seeing everywhere in the area there!

Ed Blankenship

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

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

• Stakeholder Feedback Tools
• Storyboarding Assistant – Add-In for PowerPoint that allows for rich storyboarding
• “Feedback Tool” – Very similar to Microsoft Test Runner in Microsoft Test Manager and allows for stakeholders to perform feedback sessions and collect rich data.  Easy to provide rich feedback including creating bugs in the Feedback Session
• Collects Audio & Video Recording
• Action Step
• Microsoft Test Manager – “Create Test Case from Bug”
• Additional Agile Planning Tools
• New Team Web Access (TWA) for TFS  (Metro UI)
• “Teams”
• Product Backlogs in New Team Web Access – Re-prioritizing quickly and live updates
• Sprint Backlogs in New Team Web Access
• Capacity Planning (by Team and Person)
• Work Breakdown into Tasks
• Moving Backlog Items to New Sprints (Drag & Drop)
• New Task Board
• State Changes Using Drag & Drop  (Cameron even showed a touch-enabled monitor)
• Iteration/Sprint Burndown Charts in New Team Web Access
• New “Team Navigator” Window in Visual Studio
• “Pause” Working with Visual Context Saving
• “Start” Working on New Task
• Tracks individually edited files with pending changes.  Allows checking-in just those files that were edited for that new work session.
• “Resume” Working on Previous Task and Resets Visual Studio Context
• Code Review Tools  (Just Mentioned by Cameron)
• Tools for Interacting with the Operations Team
• Based on System Center
• “TFS Connector”
• Escalate Monitoring Issues to Engineering Team in TFS
• Create Rich Work Item in TFS with Collected Information from Production
• Shows TFS Work Item ID in System Center
• Full Call Stack, Parameters, Navigate to Source Code
• IntelliTrace Logs from Production!
• Rich Text in Work Items Including Screenshots & Pictures (Shown with Feedback Collection Tool)

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

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

Ed Blankenship

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

• Four hands on labs that walk through the main scenarios that are supported by the integration.
• One of them that is particular interesting is how to give visibility to the Project Management Office (PMO) when you have development teams practicing one of the many Agile methodologies.  Those two concepts can come at odds with one another and I think the integration plays nicely with that scenario if your company finds itself in this position.
• Tons of sample active directory users that are available in both Team Foundation Server and the Project Server Enterprise Resource Pool that allow you to setup lots of different scenarios.
• Sample data, team projects, and enterprise project plans to get you started.

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

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

• http://blogs.msdn.com/b/project/archive/2011/04/20/visual-studio-team-foundation-server-2010-and-project-server-demo-virtual-machine.aspx
• http://blogs.msdn.com/b/briankel/archive/2011/04/15/getting-started-with-the-team-foundation-server-2010-and-project-server-2010-integration-virtual-machine.aspx

Virtual Machine Download Details

Download for the Virtual Machine

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

• Demo VM download
• Solutions For Application Lifecycle Management:
• Customer Case Studies - Team Foundation Server 2010 and Project Server Integration Feature Pack
• MSDN Product documentation
• MSDN Public Forums - Team Foundation Server and Project Server Integration

Have fun!

Ed Blankenship

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

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

Session Type:  Breakout Session

Level:  200 – Intermediate

Track:  Office & SharePoint

Speakers:  Christophe Fiessinger, Ed Blankenship

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

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

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

Ed Blankenship

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

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

ISBN: 978-0470943328

Availability

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

Promotional Code

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

Source Code Downloads

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

Sample Chapters

Wrox will have two chapters available to download for free.

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

Book Description

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

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

• Provides a broad overview of Team Foundation Server for developers, software project managers, testers, business analysts, and others wanting to learn how to use TFS
• Gives TFS administrators the tools they need to efficiently monitor and manage the TFS environment
• Covers core TFS functions including project management, work item tracking, version control, test case management, build automation, reporting, and more
• Explains extensibility options and how to write extensions for TFS 2010
• Helps certification candidates prepare for the Microsoft Team Foundation Server 2010 certification exam (Exam 70-512)

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

Authors

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

Table of Contents

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

Bulk Orders

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

Ed Blankenship

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

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

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

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

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

Ed Blankenship

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

Thankfully, the business at Notion Solutions and Imaginet has just been booming for the last couple of years with Visual Studio Application Lifecycle Management, Team Foundation Server, and the legacy Visual Studio Team System products.  We have been hiring left and right over the past few months and still looking for plenty more ALM Consultants in the United States and Canada.  If you are interested, just shoot an e-mail over my way and I’ll be happy to answer any questions:  edb AT notionsolutions.com.

Here’s the official posting…

Application Lifecycle Management (ALM) Consultant

Notion Solutions, Inc. is looking for a dynamic individual to join our team. For the past six years, Notion Solutions has been leading the way in implementing Team Foundation Server and the Microsoft ALM tools at companies across the country. We work with our clients to help them to define an improved software development processes for their organization and then help them implement that software process using the Microsoft tools and follow that up with mentoring on how to use their process.

We are looking for someone that enjoys a challenge and adapts to working in a rapidly changing environment. All applicants should have a strong interest in software development process and TFS. If you think of software development more as an engineering discipline, and less of an art - and would like to help companies become more successful at building software, then this could be the job for you. A knowledge of software process is a must, whether it's waterfall, SCRUM, Agile, CMMI, etc.  An understanding of Quality Assurance, Project Management, Business Analysis, and Development are all needed.

This position will work with clients nationally, your location is flexible.

Travel: Approximately 80%

Responsibilities:

• Software Development Process Consulting
  • Project management
  • Risk management
  • Change management
  • Defect tracking
  • Developer workflow
  • Automated build
  • Automated Testing
  • Release management
  • Database management

• Be self disciplined to learn new technology

Requirements:

• Knowledge of Visual Studio Premium and Ultimate features and Team Foundation Server

• Familiarity with a variety of software processes

• Experience with automated build, source control and testing tools

Helpful Skills

• Knowledge of .NET 2.0+ architecture and development practices

• Knowledge of C# and VB.NET

Ed Blankenship

By default, when you are setting up a new build definition in TFS 2010 that uses multiple Visual Studio solutions and projects, you end up with a drop folder with all of the compiled assemblies dropped in the root.  One notable exception to this is for web application projects where you will end up with a subfolder underneath the _PublishedWebsites folder for each of the web application projects.  You may not want everything to be in the root and instead want it organized.  There were several methods for how to do this using TFS 2005 or TFS 2008 but let me show you a way to do it for a TFS 2010 Build.

Create Workflow Parameter

Open up your build process template file and go to your “Arguments” tab (available in the lower-left hand corner of the workflow designer) to add a new workflow parameter.  My suggestion would be to use a new Boolean argument named “CustomizableOutputDirectory” as shown below.

Next, open up the Process Parameter Metadata Editor by clicking on the editor button for the Metadata workflow argument that is already defined.  Next, give your new process parameter some extra information so that someone editing the build definition will understand what this parameter is for.  You’ll notice that I’m also putting this parameter in the Advanced category since I don’t really need to create another category for only one new parameter.  Feel free to create a new grouping if you have more custom parameters in your build process template.

Once you finish these steps and check-in the file to version control, you’ll see your new parameter in the build definition editor as shown below.

Add Functionality to the Workflow

The next step is to add in the appropriate functionality for the customizable output directory.  What we will end up doing is adding an alternate path for when MSBuild is called to compile the Visual Studio solution or project each time.  I want to leave the default functionality though if the process parameter we created above is set to False.  So, the first step is to find the default functionality for compilation.  You can find it by navigating deep into the workflow and finding the “Compile the Project” sequence activity that contains the MSBuild activity that is used for compilation.  You can find it by navigating through these activities:

• Sequence
• Run on Agent (AgentScope)
• Type Compile, Test, and Associate Changesets and Work Items (TryCatch)
• Sequence
• Compile, Test, and Associate Changesets and Work Items (Parallel)
• Try Compile and Test (TryCatch)
• Compile and Test (Sequence)
• For Each Configuration in BuildSettings.PlatformConfigurations (ForEach<T>)
• Compile and Test for Configuration (Sequence)
• If BuildSettings.HasProjectsToBuild (If)
• For Each Project in BuildSettings.ProjectsToBuild (ForEach<T>)
• Try to Compile the Project (TryCatch)
• Compile the Project (Sequence)

The next step I would take is to drag and drop a new If activity and place the existing MSBuild activity in the Else container.  This allows for the default functionality to still continue if the value of the custom process parameter is False.  Set the Condition parameter for the If activity to the name of the custom process parameter that was defined earlier as shown below.

You will notice in the MSBuild activity that exists for default functionality, the CommandLineArguments workflow activity argument is set to the following.

String.Format("/p:SkipInvalidConfigurations=true {0}", MSBuildArguments)

To implement our custom output directory functionality, we are essentially going to modify this one activity parameter to pass in a new value.  This will be the new expression that we will use for the MSBuild activity parameter:

String.Format("/p:SkipInvalidConfigurations=true;TeamBuildOutDir=""{0}"" {1}", outputDirectory, MSBuildArguments)

The easiest way to do this would be to copy the existing MSBuild activity and paste it in the Then container for our If activity.  You can then set the CommandLineArguments parameter for the copied activity to the new value that defines the new MSBuild parameter.

Extra Credit Aside:  Anyone know why we used outputDirectory instead of BinariesDirectory?

Opt-In for Visual Studio Projects

Once you have done all of the steps, you’ll notice that it didn’t actually change anything .  For each of the Visual Studio projects that you want to use the new functionality, you will need to “opt-in” by editing the .csproj or .vbproj Visual Studio project files and adding the new MSBuild property group shown below.

            
              
                
                  <!--
                
              
              
                
                   Customizable
Output Directory Opt-In for TFS Build (non-web application projects) 
                
              
            
            
              
                
                  -->
                  

                  <
                
                
                  PropertyGroup
                
                
                   
                
                
                  Condition
                
                
                  =
                "$(TeamBuildOutDir)
!= '' "
              
                
                  >
                  

                    <
                
                
                  OutputPath
                
                
                  >
                $(TeamBuildOutDir)\$(SolutionName)\$(MSBuildProjectName)</OutputPath
            
            
              
                
                  >
                  

                  </
                
                
                  PropertyGroup
                
              
              
                >
              
            
          

The change does break the _PublishedWebsites functionality for any web application projects though and you will need to use a different opt-in below for every web application project that is included in the build.

            
              
                
                  <!--
                
              
              
                
                   Customizable
Output Directory Opt-In for TFS Build (web application projects) 
                
              
            
            
              
                
                  -->
                  

                  <
                
                
                  PropertyGroup
                
                
                   
                
                
                  Condition
                
                
                  =
                "$(TeamBuildOutDir)
!= '' "
              
                
                  >
                  

                    <
                
                
                  OutDir
                
                
                  >
                $(TeamBuildOutDir)</OutDir
            
            
              
                
                  >
                  

                  </
                
                
                  PropertyGroup
                
              
              
                >
              
            
          

There you go… Check those project file changes into version control and you can now queue a new build and the outputs for each of the projects that are opting-in to this new functionality are created in subfolders in the drop folder.  It was also still continue to put web application projects into the _PublishedWebsites folders.

Ed Blankenship

Over the past few years of dealing with plenty of TFS environments, one thing that I am glad to have done is setup friendly DNS names for TFS to use for it’s individual parts. This has helped extremely to make for a smooth transition for administrators & end users when needing to move TFS to a new hardware environment, upgrading TFS to a new version, or in several disaster recovery scenarios. Not to mention having to tell new users to connect to some odd server with a weird name like ADGKSDFU308234NT. You can obfuscate all of the connection points that TFS uses. The concept is easy and if you haven’t done it already, it’s never too late.

Why use Friendly DNS Names?

I mentioned a few examples above but let me expand on it a little further by presenting two scenarios that I have run across. There are plenty of other scenarios that have been handy in the past as well. You’ll be surprised the options you have for different types of changes to the infrastructure and topology that you’ll run across in the future by using friendly DNS names.

Hardware Migration Upgrade

During a future upgrade, it is decided that new hardware is to be used for scaling out to increase the availability and performance of the TFS environment. By using friendly DNS names, end users and custom tools can continue to point to the same address (tfs.contoso.local) without making any changes. This allows for having the old environment up at the same time as having the new upgraded environment up. This helps out with rollback plans in case the upgrade was not successful.

Scale Out Analysis Services

A company has noticed that heavy usage of the OLAP warehouse cube in SQL Analysis Services has started to use a lot of the RAM on the data tier server. They would like to separate SQL Analysis Services from the database services in SQL Server to a separate server. By changing the friendly DNS name (warehouse.tfs.contoso.local) to the new Analysis Services instance, end users who have created custom Excel pivot table reports in workbooks won’t have to update each workbook.

Any others you can think of?

DNS Entries

First, you will want to create either A or CNAME records in your DNS infrastructure. If you are using Active Directory then your DNS infrastructure will more than likely be managed by your domain controller(s).

This guide assumes that you are using the following friendly DNS names throughout the configuration. In this example, the internal network uses the DNS suffix of contoso.local. You could also have contoso.com addresses point to internal servers if they are setup appropriately in DNS. Check with your DNS administrator to discuss which format should be used. Be sure to use fully-qualified DNS names especially for those clients that use VPN or have remote offices. You will want to be sure to follow the guide in order since some steps are dependent on previous steps to have been performed.

In my particular example below, I have a single server that has both the application tier components and the data tier components. SQL Analysis Services is also installed on the same server. However, I am using a separate SharePoint server and a different server for TFS Lab Management.

Disable Loopback Check

Often when you are logging into a server and using a friendly DNS name that resolves back to itself (localhost) you will find that you end up having authentication issues because of a security feature in Windows Server. You can disable this security feature by following the directions in this KB support article: http://support.microsoft.com/kb/896861. You will want to do this for each of the servers that may resolve back to itself using the friendly DNS name. For example: application tier servers, data tier, Analysis Services server, SharePoint servers, etc.

To set the DisableLoopbackCheck registry key, follow these steps:

1. Click Start, click Run, type regedit, and then click OK.
2. In Registry Editor, locate and then click the following registry key:

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa

3. Right-click Lsa, point to New, and then click DWORD Value.
4. Type DisableLoopbackCheck, and then press ENTER.
5. Right-click DisableLoopbackCheck, and then click Modify.
6. In the Value data box, type 1, and then click OK.
7. Quit Registry Editor, and then restart your computer.

Installing TFS to use the Friendly DNS Name for the Data Tier

When initially configuring Team Foundation Server, use the fully-qualified friendly DNS name for the data tier server: data.tfs.contoso.local. If this is done correctly, then the Application Tier information page on the TFS Administration Console will show that friendly DNS name in the connection string.

Also use this location for each team project collection that is created as well. If it done correctly then you will see it shown for the connection string to the team project collection database.

If TFS has already been setup and configured not using the friendly DNS name, you can alternatively use the TFSConfig.exe RemapDBsand RegisterDB command on each application tier server to update its data tier server connection string to use the friendly DNS name.

tfsconfig.exe remapdbs /DatabaseName:data.tfs.contoso.local;Tfs_Configuration /SQLInstances:data.tfs.contoso.local

More information about the RemapDBs command can be found on MSDN: http://msdn.microsoft.com/en-us/library/ee349262.aspx

tfsconfig.exe registerDB/SQLInstance:data.tfs.contoso.local /DatabaseName:Tfs_Configuration

More information about the RegisterDB command can be found on MSDN: http://msdn.microsoft.com/en-us/library/ms252443.aspx

Configuring Reporting Services to Use Friendly DNS Name

1. Open the Reporting Services Configuration Manager by clicking Start –> All Programs –> Microsoft SQL Server 2008R2 –> Configuration Tools –> Reporting Services Configuration Manager
2. Connect to the appropriate SQL Reporting Services instance.
3. Click on Report Manager URL settings page.
4. Click on the Advanced button.

5. In the Advanced Multiple Web Site Configuration dialog click on the Add button.
6. Enter the fully-qualified DNS name: tfs.contoso.local. You can optionally remove the other entry if it is not needed.

7. Click OK and the URL should be reserved.

8. Go to the Web Service URL settings and repeat steps 4-7 and use the same fully-qualified friendly DNS name: tfs.contoso.local.

Configuring SharePoint to Use Friendly DNS Name

1. Open SharePoint Central Administration by clicking Start –> Administrative Tools –> SharePoint Central Administration
2. Click on the Configure alternate access mappings command under the System Settings section

3. Click on Edit Public URLs in the toolbar.

4. On the Edit Public Zone URLs page, enter the fully-qualified friendly DNS name into the Internet field for the separate SharePoint server or the friendly DNS name for the application tier server if it is installed there.

5. Click on Save
6. Verify that you are able to resolve the friendly DNS address and that the SharePoint web application recognizes it appropriately. You can do this by opening an Internet Explorer browser and navigating to http://tfs.contoso.local or http://sharepoint.tfs.contoso.local depending on your configuration.

You may want to also update the public URL for SharePoint to use for the Central Administration site as well. Perform the same steps except choose the SharePoint Central Administration in the Alternate Access Mapping Collection combo box.

Configuring TFS to Use Friendly DNS Name

1. Open the TFS Administration Console and navigate to the Application Tier settings page.
2. Click on the Change URLs action.

3. On the Change URLs dialog, enter the fully-qualified friendly DNS name: http://tfs.contoso.local:8080/tfs.

4. Don’t change the Server URL since it is used for intra-server communication (like warehouse adapter jobs, etc.)
5. Click OK. Verify that the TFS Administration Console page has been updated and that e-mail alerts now use the friendly DNS name in the URL links within the e-mail.

Configuring TFS Reporting to Use Friendly DNS Name

1. Open the TFS Administration Console and navigate to Application Tier –> Reporting.
2. Click the Stop Jobs action before editing the configuration.

3. Click OK on the warning dialog.

4. Click on the Edit action.
5. On the Warehouse tab, type the fully-qualified friendly DNS name for the data tier server that houses the relational warehouse database: data.tfs.contoso.local.

6. Click on the Analysis Services tab and enter the fully-qualified friendly DNS name for the Analysis Services server: warehouse.tfs.contoso.local.

7. Re-enter the password for the Account for accessing data sources.
8. Click on the Reports tab and click on the Populate URLs button.
9. In the URLs for Report Server group, select the URLs that were setup in the Reporting Services Configuration utility that were setup earlier.

10. Re-enter the password for the Account for accessing data sources.
11. Click OK.
12. Click the Start Jobs action.

The Team Foundation Server Administration Console should now display the appropriate information as shown below.

Configuring TFS SharePoint Integration to Use Friendly DNS Name

1. Open the TFS Administration Console and navigate to Application Tier –> SharePoint Web Applications.
2. Click on the SharePoint Web Application item in the list box and click Change.

3. On the SharePoint Web Application Settings dialog box, change the Web Application URL to the fully-qualified friendly DNS name you used earlier. (You can optionally set the Friendly Name to this address as well but this is more for a friendly label that distinguishes the SharePoint web application from multiple SharePoint web applications if configured.) Click OK.

4. You should receive an information dialog box. Click OK on that dialog.
5. The SharePoint Web Applications list should be updated with the entry that lists the friendly DNS name.

Build Servers & Proxy Servers

Be sure to also configure all of the build servers and proxy servers to point to the friendly DNS name when connecting to the application tier server(s). This will allow for the same type of flexibility whenever you need to make any TFS environment topology changes.

Let me know if you have any additional questions!

Ed Blankenship

I am really happy to announce that I received the Microsoft Most Valuable Professional award again for 2011!  The award is for the Visual Studio ALM products which includes Team Foundation Server.  This will be my fourth year as an MVP and it has been truly an honor working with all of the great colleagues and the product teams that I work with pretty much every day!  I’m r.ally looking forward to going to the MVP Summit next month and handing off the MVP of the Year award to the next new awardee and for another exciting year!

Thanks to everyone who has helped support me with my developer community contributions!

Ed Blankenship

One of the great new features of Visual Studio 2010  and Microsoft Test Manager is the ability to record action recordings and then covert them into automated UI tests called “Coded UI Tests.”  The recorded steps turn into a UI Map that is an XML-based file format that is used by Visual Studio to generate source code.  Editing the UIMap was pretty tedious before so Microsoft released a new UI Map Editor in the latest feature pack:  Visual Studio 2010 Feature Pack 2.  Feature Pack 2 is available to active MSDN Subscribers and contains the following additional features;

Cumulative feature pack that extends testing, code visualization and modeling capabilities in Visual Studio 2010.

Testing features:

• Use Microsoft Test Manager to capture and playback action recordings for Silverlight 4 applications.
• Create coded UI tests for Silverlight 4 applications with Visual Studio 2010 Premium or Visual Studio 2010 Ultimate.
• Edit coded UI tests using a graphical editor with Visual Studio 2010 Premium or Visual Studio 2010 Ultimate.
• Use action recordings to fast forward through manual tests that need to support Mozilla Firefox 3.5 and 3.6.
• Run coded UI tests for web applications using Mozilla Firefox 3.5 and 3.6 with Microsoft Visual Studio 2010 Premium or Visual Studio 2010 Ultimate.

Code visualization and modeling features (requires Visual Studio 2010 Ultimate):

• Use the Generate Code command to generate skeleton code from elements on UML class diagrams. You can use the default transformations, or you can write custom transformations to translate UML types into code.
• Create UML class diagrams from existing code.
• Explore the organization and relationships in C, C++, and ASP.NET projects by generating dependency graphs.
• Import elements from UML sequence diagrams, class diagrams, and use case diagrams as XMI 2.1 files that are exported from other modeling tools.
• Create links and view links from work items to model elements.
• Create layer diagrams from C or C++ code and validate dependencies.
• Write code to modify layer diagrams and to validate code against layer diagrams.

Once you get the Feature Pack installed, you will be able to open the UI Map and in a new editor as shown below.  It’s great because it allows you to see each of the methods that have been created and allows you to rename, remove, and edit the actions that have been recorded.  It even shows you all of the windows, controls, etc. that are included in the UI Map that describe the UI components in your application that are used by the Coded UI Tests.  You can also edit the properties for those so that you can maintain the automated tests to continue to work after UI changes are made in the application you are testing.

Some really cool features that I found today was the ability to locate a control on your application and also to verify that the UI Map is still correct by locating all of the controls.  First, you can find a specific UI control or element by choosing the “Locate the UI Control” toolbar button after you select the control you are interested.

You’ll want to have the particular application and window running before you do this (so it can find it) but it will put a little blue rectangle around the control as shown below.

Nice!  If you want to make sure that all of the UI control or elements on a window are still valid in the UI Map then you can select the window in the UI control’s tree and then choose the “Locate All” toolbar command.  You’ll see it go through each of the controls in the window and verify that it can still find it and mark it with a green check mark if it can be found.  How about that?

Have fun!

Ed Blankenship

In Team Foundation Server 2010, a new registry key was added to provide the ability to specify that “Associate” should be the default when associating work items to a changeset instead of the “Resolve” action.  This needs to be applied to each development machine that would like to change the default instead of editing the process template and work item type definitions.

All you have to do is set the ResolveAsDefaultCheckinAction value to False in this registry key:  HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\10.0\TeamFoundation\SourceControl\Behavior

Nice!

Ed Blankenship

Earlier this year following the Visual Studio 2010 release, I got a great package from Microsoft (MVP Program and Visual Studio Product Team) that included some complimentary Visual Studio 2010 Ultimate with MSDN Subscription activation cards to give away.  I hadn’t found the right opportunity but this Saturday I will be attending (and have submitted a session proposal) the Charleston Bar Camp.  This should be a very interesting experience since it will be my first bar camp.  Anyhow, I have been looking for ways to contribute and foster our local software development community in Charleston and decided I would like to give two MSDN subscriptions out during the event.

What is Included?

Two winners will receive a prize package that contains:

 Total Retail Value for Prize Packages: $24,007.96

Option 1 - Lab Management Session Attendees

Attendees to the Virtual Lab Management with Team Foundation Server 2010 session (if selected and scheduled) will have an opportunity to win one of the prize packages. Bring a business card with your name, company/occupation, city, e-mail address, and Twitter account. One lucky winner will be selected from the submitted business cards after the session has completed.

Option 2 - All Bar Camp Charleston Attendees

On the back of this page, write your “pitch” for why you think you should win one of the prize packages and what you would do with it if you were to win. The best pitch, as determined by the judge(s) will be selected to win the prize package. Bonus points are given for impactful local projects, giving back to the local developer community, or volunteering time & talents for a local non-profit organization.

Good luck!

Download Flyer

MSDN Subscriptions donated by the Microsoft MVP Program , Visual Studio Product Team , and...

Ed Blankenship Microsoft MVP of the Year, Visual Studio ALM Co-Author, Professional Team Foundation Server 2010 by Wrox   Application Lifecycle Management & Team Foundation Server Consultant Notion Solutions

Blog: http://www.edsquared.com Twitter: @EdBlankenship LinkedIn: http://www.linkedin.com/in/edblankenship E-Mail: edb@notionsolutions.com

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

I was looking through my blogging backlog and noticed that I never published this one!

I recently just finished up listening to the latest episode for the Radio TFS podcast and really enjoyed the discussion.  They had Jonathan Wanagel from the CodePlex team to talk about their use of TFS for the CodePlex site.  One interesting tidbit that I had never realized is that since they upgraded to TFS 2010, we all now have access to a load-balanced Team Web Access site as well!  Take a look below.

CodePlex Team Web Access Site:  https://tfs.codeplex.com/tfs/web

We haven’t ever really needed a web access site since the CodePlex web software does a lot what we would need but just in case you have a use for it then it is completely available for you.

Ed Blankenship

Awesome!    I found out over the weekend that the Developer Smackdown podcast show where I was a guest has been posted online!  Go check it out.  Clark Sell and Mark Nichols are the co-hosts for the show and it was a fun chat about migrating to Team Foundation Server from legacy systems.

Show: TFS Migrations with Ed Blankenship

Here is the list of sites and\or resources mentioned in this show:

• Team Foundation Server
• Timely Migration
• Team Foundation Server Power Tools
• Visual Studio Power Tools
• Scripting with Windows PowerShell
• MSBuild
• Windows Workflow
• TFS Integration Platform

When doing a TFS Migration make sure you think about some of the following items:

• Are you a big TFS project or little TFS Project kind of guy?  Think about your organization and their reporting structures when considering "the size" of your TFS projects.
• Think about how you would report on things?  What types of questions are you trying to answer with your reports?
• Did you know that Branch Visualization doesn't work across Team Projects ( at least as of the time of writing this )
• Treat the migration just like any other product development you would do.
• 1 GB of source typically takes 24 hours to migrate.  That is execution time.  (Conservative Estimate)
• How much history do you really need?  Was it worth the cost to migrate?

Follow Show On Twitter

Subscribe to Podcast in Zune

Subscribe to Podcast in iTunes

Ed Blankenship

For the longest time, opening a build process template (.xaml) file for TFS 2010 has been pretty painful.  It took a while for the workflow designer to eventually show up and the toolbox to be populated with the TFS Build Activities.  Nearly 30-45 seconds at times!

Recently, I applied a workaround that has dramatically reduced the time down to around 2 seconds!  Try it out:

1. Create a file called empty.xaml and place the following text in it:
   <Activity xmlns="http://schemas.microsoft.com/netfx/2009/xaml/activities">
   </Activity>
2. Open this file in Visual Studio.
3. In the toolbox panel, add a new tab called “Team Foundation Build Activities”.  Note that it is important to get the tab name correct because if it is not correct then the activities will be reloaded.
4. Inside the new tab, right click and select “Choose Items”
5. Click the Browse button
6. Load the file C:\Windows\Microsoft.NET\assembly\GAC_MSIL\Microsoft.TeamFoundation.Build.Workflow\v4.0_10.0.0.0__b03f5f7f11d50a3a\Microsoft.TeamFoundation.Build.Workflow.dll
7. Click OK to add the toolbox items to the tab.
8. Create another new tab called “Team Foundation LabManagement Activities”.
9. Inside the new tab, right click and select “Choose Items”
10. Click the Browse button
11. Load the file C:\Windows\Microsoft.NET\assembly\GAC_MSIL\Microsoft.TeamFoundation.Lab.Workflow.Activities\v4.0_10.0.0.0__b03f5f7f11d50a3a\Microsoft.TeamFoundation.Lab.Workflow.Activities.dll
12. Click OK to add the toolbox items to the tab.

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

Some of the Visual Studio ALM MVPs have gotten together to drive the creation of a new Stack Exchange site dedicated to the Visual Studio ALM family of products (which includes Team Foundation Server.)  We were able to get past the “Definition” phase and now need to enough people to “Commit” to using it so that we can get the site off the ground.  If you aren’t familiar with the Stack Exchange concept, it’s an interesting way to ask questions and help answer them as well.  One of the sites that has been around for a while that I have participated in from time to time is Stack Overflow.  You basically end up with high-quality answers because others can agree/disagree with the answer and provide feedback or more information.

Help us out by indicating that you are going to commit to contributing to the site whenever it gets created.  Thanks for all your help!

Link:  Commit to Visual Studio ALM at Stack Exchange

Ed Blankenship

There is a great article in the August 1, 2010 edition of the SD Times by Dave Worthington (@dcworthington) about the Visual Studio 2010 ALM tools including Team Foundation Server 2010.  It’s titled “Microsoft’s islands in the stream.”  Some really great colleagues in the ALM community have been interviewed and provided some pretty honest feedback from what we have been seeing over the last year or so.  Check it out!

Ed Blankenship