My company Sparkles was also present with a conference booth and it has proven to be very valuable to listen to your feedback. Sparkles will continue to invest in offering the best advanced IT Training classes (Dev + IT Pro) with local and international experts.

Thank you all for attending one of the sessions and/or for showing up at the booth. Don’t forget to register for the Sparkles newsletter as you might still win free IT Training Vouchers.

Link to slides:

• Visual Studio Lab Management 2012
• Build & Test a Windows 8 App with Team Foundation Service [duo-session with Kevin DeRudder]

There are still a few seats left for the 3 day hands-on ALM training class in Ghent.

Anyway, it should be obvious for all people working in the IT business: if you don’t catch up from time to time on the new technology evolutions => soon or later it’s game over because your market value will decrease exponentially! And this doesn’t necessarily mean you are obliged to look for external (classroom) training or you need to attend specific software conferences. It only means you need to find the best way to update/upgrade/improve/broaden your skills. Some people are perfectly self-managing: they read books, articles, blogs, forums … and/or they simply experiment (hands-on) with new stuff in their spare time. But for the majority of people this isn’t a valid approach and learning everything by yourself may give you a very biased opinion.

Attending software conferences give you the advantage to easily grasp the bigger perspective of what’s going on in our industry and offer you the possibility to follow some side-tracks (consider it as off-road) which might be very interesting as well. And don’t forget the different networking opportunities which may lead to the best geek talk you ever experienced. Still, IMHO dedicated classroom training is the best choice to improve specific skills in a short period of time. This is only true if the (interactive) classroom training is led by an absolute expert in the field who has dealt with many different challenges in real-life projects. To learn something brand new or to switch to another (similar) technology, there are many courses/classes which might do initially, but to get you to the expert level of a specific topic, there are not that many options. Once you get past the junior/medior level, it’s a different game and you won’t benefit anymore from the default training classes!

It’s exactly that gap that I want to tackle in Belgium with the training offer (Master Classes) at Sparkles. In the past I partnered already with IDesign which has a unique position of software industry leadership and reputation. The team of Juval Löwy will continue in 2013 to deliver their famous and intensive Master Classes in Belgium. Next to that, I’m also looking to setup other training classes on various topics (dev & IT Pro) with local and international experts. The purpose is absolutely not to offer a typical 9-to-5 basic classroom training (which might be good for some people), but the goal is to create a unique intensive learning experience by selecting the best people – who are working in the trenches – to get you to that precious next level! Learn IT by the experts! Keep an eye on the upcoming training offering and I hope to add some extra confirmed classes before TechDays where Sparkles will be present with a partner booth.

A last note for companies freezing the training budget for their employees. I’m aware of the trade-offs which must be made, but in the end: not investing in the most appropriate training for your people is a double risk. One, you might lose your best talent who will take a job at the competition and your global knowledge level will stall which will lead to less attraction on the market to engage new talent. Mostly, the more well-spoken and brave employees are able to put some extra pressure on management to finally get registered for a software conference or a particular training class … but I do catalogue this outcome as a quick win and it will backfire soon or later. Treating your people as a cost will completely demoralize and demotivate your staff. I can already imagine some reactions: “but what if we train them and they leave the company”? OK, be sure to read this and let it sink. It depends of course greatly on the personal attitude of all individuals: basically they are in control of their continuous learning & career path. So, it’s your call to invest in training or not!

Many valuable attendee-years did follow after my first close encounter and 10 years later, there’s still so much more to learn … even more than ever before! Compared to roughly 10 years ago (seems Stone Age right now!), there are so many new releases of interesting tools, frameworks and products. Let aside the multitude of platforms we can develop for! In the early years, there was just a (beta) release of the .NET Framework and the Visual Studio IDE and that was practically it …

I had already the pleasure to present some sessions at earlier editions of TechDays and this year will definitely become a very special edition once again!

I will not only be presenting two sessions on ALM/TFS, but I will also have a booth with Sparkles (as a Silver Partner) to promote the upcoming training classes in Belgium.

So, be sure to check out the full agenda of TechDays Belgium, register and come to visit me at the Sparkles’ booth. I’m still pondering about some promo material at the booth, giveaways and the like … Do send me your (crazy) suggestions!

In the past, DevDays was a dedicated event for the dev community, but since a few years now the event has broadened its scope to be the meeting point for all Microsoft technology professionals (dev & IT Pro). One of the top speakers this year in the IT Pro track is Paula Januszkiewicz and she happens to teach a Master Class in Belgium (via Sparkles) on Windows Security. She will be manning the Sparkles booth together with me to promote her training class and the other IDesign training classes in 2013.

This year, there’s again a Deep Dive ALM Track on the first day of the conference and I feel lucky to be part of a great line-up:

• Application Lifecycle Management: It’s a Team Sport [Brian Keller]
• TFS in the cloud or TFS on premise, how do they compare and what are the benefits for my development team? [Marcel de Vries]
• Software Testing with Microsoft Test Manager 2012 and Lab Management 2012 [Brian Keller]
• How to create cross browser test automation using Coded UI Testing [Marcel de Vries]
• Bring it all together: Build, Deploy and Test with Visual Studio Lab Management [Pieter Gheysens]

Something to look forward to is also my duo-session with Kevin DeRudder where we will talk about how to build and test a Windows 8 app with TFS Service and Microsoft Test Manager 2012.

Hope to meet you at TechDays 2013 to share our passion!

Follow me on twitter (@pietergheysens) for the latest news.

It has been an interesting journey so far and along the way I got to know (a bit) how Dynamics CRM 2011 is working. Not to my surprise, I realized that it’s quite hard to push all source related items to TFS and to force ALL changes/updates to a CRM environment from a version controlled solution in TFS. Many things in the CRM environment are easily modified by the development team via the CRM UI web interface and as result, directly stored in the CRM database(s). So, the POC also required me to think about enforcing best practices for the CRM development team to avoid inconsistencies in the global deployment solution and I definitly wanted to end up with a build-once;deploy-many solution.

Anyway, I won’t talk about the entire scope of the POC, but I want to highlight the approach I took for automating the export & extract operation from the development CRM 2011 instance via a TFS build definition. The goal here was to automatically capture the daily changes which were published to deployed CRM development solutions.

EXPORT
The MSCRM 2011 Toolkit contains a Solution Export command line utility which enabled me to export one or multiple CRM solutions from an existing Solutions Export Profile into a single compressed solution file (.zip).

EXTRACT
The compressed solution file (zip-format) is of course not ideal to track the individual changes and to bind it to a version control repository. Luckily, with the latest release of the Dynamics CRM 2011 SDK, a new tool (SolutionPackager) was added to extract the different components into individual files.

The SolutionPackager tool, available in the Microsoft Dynamics CRM 2011 Update Rollup 10 version of the Microsoft Dynamics CRM SDK download, resolves the problem of source code control and team development of solution files. The tool identifies individual components in the compressed solution file and extracts them out to individual files. The tool can also re-create a solution file by packing the files that had been previously extracted. This enables multiple people to work independently on a single solution and extract their changes into a common location. Because each component in the solution file is broken into multiple files, it becomes possible to merge customizations without overwriting prior changes. A secondary use of the SolutionPackager tool is that it can be invoked from an automated build process to generate a compressed solution file from previously extracted component files without needing an active Microsoft Dynamics CRM server.

So, these tools opened the door for me to work out a custom build process (workflow) in TFS 2010 with the following sequential activities:

• Export CRM solution from dev environment (MSCRM 2011 Toolkit)
• Prepare TFS workspace before extract of solution file [Get Latest + Check-Out]
• Extract compressed solution file into TFS workspace (SolutionPackager)
• Scan TFS workspace for changes/additions/deletions
• Check-In pending changes of the TFS workspace as a single changeset

The scan of the TFS workspaces – to end up with all differences [changes/additions/deletions] – was a bit more complex than expected because I needed to use several TFS API Workspace calls like PendEdit, PendAdd, PendDelete, … I also made use of the EvaluateCheckin2 method to detect potential conflicts and to perform proper exception handling.

This process allows the development team to easily follow-up the incremental changes (via TFS changesets) which were applied to the dev CRM environment. Note that the SolutionPackager tool is also able to generate a compressed solution file from the individual component files.

On October 19, I’m booked for a full day session on Application Lifecycle Management for Microsoft Partners in Belgium and apparently the registration is now also open for other people who would be interested in learning how to use the latest release of Microsoft’s application lifecycle management suite to improve the software development process.

Recently I was informed that Jeff Beehler would also be in Belgium that day and quickly it was confirmed that Jeff would team up to deliver the keynote of the day. Jeff (Chief of Staff for Visual Studio at Microsoft) has already a long history in the Visual Studio product team and is the perfect speaker for setting the scene and to give the audience extra insight in the evolution of the product and where the product family is heading to. I’m very excited to have Jeff as a keynote speaker for this event in Belgium.

Here’s the final agenda for October 19:

• 09h00 – 10h15: Continuous Value Delivery with VS ALM 2012 (Jeff Beehler)
• 10h15 – 10h30: break
• 10h30 – 12h00: Agile Project Management with Team Web Access and TFS Preview
• 12h00 – 13h00: lunch
• 13h00 – 14h30: TFS 2012 Version Control improvements + the new Team Explorer experience
• 14h30 – 14h45: break
• 14h45 – 16h15: Exploratory Testing with Microsoft Test Manager 2012 + IntelliTrace in Production
• 16h15 – 16h30: break
• 16h30 – 17h00: Continuous Deployment to Windows Azure with TFS Preview

Note that this day is not scheduled as a hands-on workshop. I will only introduce and demo some new and powerful features inside the new release of Team Foundation Server.

Register at Microsoft World Wide Events.

Are you more looking for a deep-dive technical hands-on training on ALM with Visual Studio and Team Foundation Server? I’m organizing for the second time a public 3 day ALM training class on November 12, 13 & 14. Register your spot right now for the full track or choose your preferred training day à-la-carte.

Hope to see you on one of the upcoming events!

In some scenarios it will be required to avoid that individual changesets can be merged into another branch (for example configuration changes). Enter discarding candidate merges!

Using the Merge Wizard in TFS, you have the option to select the cherry-pick option to only see the changesets which haven’t been merged from Source to Target.

But, from the UI it’s unfortunately still not possible (TFS 2012) to discard a candidate merge changeset. I would just love to right-click on a changeset and discard it from there.

Up till now I always switched to the command-line to discard the changeset from there (tf merge /discard).

Recently I got a question at a customer to make this possible through the API. First of all I was a bit worried why on earth it would be necessary to automate this through the API because in the end this action should be quite exceptional. So, after going into more details it seemed that a background process was running which made a number of configuration changes to the branches, but those changesets were branch-specific and weren’t allowed to be merged into some other branch. These changesets were in fact seriously blocking the merge process due to the fact that only consecutive changesets can be merged from Source to Target and a number of these “configuration” changesets were sitting between other valid candidate merge changesets. Not good!

The solution for discarding changesets through the API is making use of the Merge method on the Workspace object. To discard, you must use the enumeration AlwaysAcceptMine as parameter for the MergeOptions. This will push the merge (without actual changes in the files) into the workspace after which the check-in can be executed. The check-in will make sure that the changeset won’t show up anymore in the candidate merge changesets.

Both times last week, I delivered a session on setting the context for the upcoming TFS 2012 release and added a number of demos to show some new and interesting ALM features.

90% of my time I’m active as an ALM consultant at different (small/big) companies in Belgium and I do identify a number of common trends across these companies. One very important thing for the business is time-to-market and they want to see a continuous flow of value. The current model of delivering features in big releases with long lead times – and only a few times a year – is under enormous  pressure. Development teams are getting pretty good at adopting agile and lean concepts in the technical development cycle, but the bottleneck is often the integration of the entire software value chain (stakeholders, development team, testing team and operations). Going for continuous value delivery really requires companies to improve the end-to-end value chain. What’s otherwise the value of having a top agile development team without the ability to frequently release new features in production? Delivering business value is all about optimizing the collaboration between different teams and software must be seen as a company-wide team sport.

Gartner has published a few weeks ago (June 5, 2012) an interesting report on Application Lifecycle Management. Microsoft has been identified as a leader in this area with the current TFS 2010 offering. So, this is already a clear indication that Microsoft has great tools for ALM, but I believe that the position of Microsoft will even be stronger with the new TFS 2012 release because they take care about the complete end-to-end value chain and they are creating the best tools for every individual stakeholder in the process.

Read the full Gartner report to find out more about the current ALM market situation..

Having only one hour to explain and demo the upcoming TFS 2012 release is just impossible. The goal was to give the audience an idea of what’s coming and the approach Microsoft is taking to tackle Application Lifecycle Management. Usually I spend three full days to get team members up-to-speed with all the new features of TFS 2012 during an on-site hands-on training.

My next public training on TFS 2012 is scheduled in the week of August 20, 2012. This intensive 3 day training will give students a detailed overview of the new ALM features that will be included inside the next release of Visual Studio and Team Foundation Server 2012. Attendees will experience how this new release might unblock the impediments in software development processes to deliver continuous value for the business. The full training consists of 3 days, but according to personal preferences, people can sign up for the individual days as well. On-site training sessions can also be planned.

Download slide-deck Community Day 2012: A lap around VS 2012 ALM RC.

Guess what?! The final decision was to move the entire Java development team to TFS 2010. During the evaluation process I had to cope with a lot of non-believers, but I’m pretty sure that a lot of Java people were quite impressed and unaware of the possibilities that the current and future ALM offering from Microsoft delivers. On the other hand, I was also surprised by some interesting features in the Atlassian product suite. Both solutions actually met the specific requirements, but in the end I strongly believe that the company made the correct decision to choose for TFS 2010 as a true cross-technology ALM platform. Ultimately this was an objective decision based on the facts and not a decision led by gut feeling or emotion.

First of all, there was already an existing and mature TFS 2010 infrastructure in place which served a .NET and SharePoint development team. Team Foundation Server 2010 introduced an evolved architecture built to scale to the most challenging of teams and scenarios. A high available multiple server environment was already set up to support a potential load of up to 400 developers. The architecture included two distinct TFS Application Tiers which sit behind a load balancer. The TFS Data Tier is running in a SQL Cluster for high availability. This architecture can easily be extended with an extra TFS Application Tier and an extra SQL Server instance for optimizing the load on multiple Team Project Collections.

More information on scalability for TFS 2010 can be found here.

Another explicit requirement was to easily cope with the most important version control operations and to be able to track and manage individual changes in parallel development scenarios. The Java team was still stuck with an older version control system which could not live up to the expectations of a modern version control system.

Switching to another version control system like TFS Version Control (or GIT) means that the involved stakeholders will need to be trained to make use of the new tool/system in an optimal way. While switching to another tool, there’s also an opportunity to adapt the existing way of working. Choosing for example a more appropriate branching & merging strategy is certainly recommended to simplify software configuration management. TFS 2010 introduced a number of excellent branching & merging features to fully support development teams (including configuration managers and release managers) in their day-to-day operations. Most actions can be easily triggered from the UI and don’t require complex command line operations:

• Branches are first class citizens in the version control repository
• Branch Hierarchy & Timeline View
• Tracking Individual Changesets across branches
• Drag And Drop Functionality to Merge Branches
• Cherry-pick merging
• Branching & Merging on Label or DateTime
• Full rollback functionality for individual changesets or set of changesets
• View hierarchical history of changes across branches
• Annotate feature to view history in source code
• Compare version control folders on branch/label/datetime
• Compare local workspaces with server version control folders
• Fine-grained permissions on version control folders and branches
• Associate a distinct file type with a specific merge tool

Needless to say that GIT as a DVCS also offers a powerful version control system and even offers better support for offline version control but these scenarios were not explicitly required.

Deep version control integration in a Java IDE was naturally another requirement. Visual Studio Team Explorer Everywhere 2010 helps .NET and Java development teams collaborate across platforms. It provides the tools and plug-ins to access Team Foundation Server 2010, so everyone can work together to achieve business goals. Team Explorer Everywhere 2010 works with the Eclipse-based IDE, in the operating system of choice and helps to collaborate across .NET and Java development teams. It’s an easy-to-install standalone plug-in which offers easy access to all possible version control operations. More information on Team Explorer Everywhere can be found here.

Of course, Team Foundation Server is a whole lot more than only version control. I will add a few other important integrated features that were important for the final decision.

The build services provided by TFS 2010 offer an enterprise-class, distributed build platform. Utilization of the build services is done inside the IDE (Team Explorer Everywhere plug-in in Eclipse) in which the code is being created. The build services provide notifications on build events using the standard TFS eventing mechanisms, which means that email alerts can easily be sent to the team regarding build status. Continuous Integration builds make sure that the individual developer can be identified who broke the build. There’s even a Gated Check-In trigger available that can prevent broken builds. The build process, based on Windows Workflow Foundation is highly extensible to adapt to the needs of complex business environment. The Team Foundation Build Architecture is also extremely scalable with the introduction of a Build Controller and a pool of Build Agents which can be spread across different machines.

As from the TFS 2010 release, the ALM offering also includes a full solution for managing test plans, designing test cases and test reporting. Microsoft Test Manager (part of the Test Professional Suite or Visual Studio Ultimate) is a tool for functional testers and connects to TFS for executing and recording manual/automated tests from dedicated test case work items. Creating bugs and follow-up has become convenient due to the excellent integration with the Build Automation system. Bug reports now include automatically (due to diagnostic data adapters) all important information the developers need to reproduce and fix the bug. Visual Studio Lab Management is an add-on for TFS that allows deploying and testing applications in virtual test environments and includes a framework to file rich actionable bugs due to the various data collectors (for example video recording). Automated UI tests can also be easily integrated in existing build definitions.

Reporting in TFS 2010 is one of the most powerful features. All possible data in TFS is stored in a SQL Server database where data is regularly processed in a data warehouse and in analytical cubes. For every created Team Project in TFS, you will automatically get a number of out-of-the-box SQL Reporting Services reports and a number of customizable reporting dashboards in the SharePoint team project portal. Existing reports can be easily customized or new reports can be easily added and shared for multiple stakeholders. Microsoft Excel can also be used to quickly define ad-hoc Pivot table reports based on the SQL Analysis cubes.

What about compliance (Sarbanes-Oxley Act)? Well, this requirement was probably very important in the final decision! Team Foundation Server provides three main pieces of functionality as it relates to SOx – Work Item Tracking, Version Control and Automated Build. These three features working together provide the capability to eliminate many of the risks associated with SOx 404 compliance. At the heart of SOx is the ability to know who made what change when, what requirement was the change made for and who authorized the change to be made. Was the requirement tested to make sure that it works correctly and who authorized the release of that requirement to production? Or, to state it another way, is the requirement traceable? Many technical solutions require multiple tools to provide this kind of traceability and generally they break the traceability chain at some point because they are not integrated at all required points. With Team Foundation Server 2010, full traceability is baked in. Team Foundation Server provides a comprehensive and flexible set of capabilities through traceability, test case management and automated builds. The rich extensibility of both the built-in features and a third-party ecosystem gives you the tools you need in order to meet the requirements of SOx.

Full article on Sox and TFS 2010 available at http://msdn.microsoft.com/en-us/library/gg983694.aspx.

GIT on the other hand was initially designed as a version control system for open source workflows and may have compliance issues inside strictly regulated (financial) institutions due to a number of reasons:

• User Auditing: a commit in GIT is associated with a simple string (any string but by convention a name and email address). This can be changed at any time and doesn’t offer full traceability to a controlled identity.
• Path based access control: TFS has very fine-grained control over permissions at any point in the repository. GIT (in common with other DVCS tools) has no way to do this.
• Administration: a centralized version control system life TFS provides a central place to perform and audit administration activities including security, access control, permissions management of user accounts, backup, et. DVCS tools like GIT don’t offer that out-of-the-box.

Conclusion

Team Foundation Server doesn’t only offer a solution for reliable version control, but offers a fully integrated Application Lifecycle Management (ALM) solution for the enterprise. The requested requirements for the entire Java development process could all be fulfilled with the existing high-available TFS 2010 setup that was currently in use for another existing development program. Against the global perception of Microsoft products, Team Foundation Server is really extensible on client- and server-side (http://msdn.microsoft.com/en-us/library/bb130146.aspx) and offers a lot of room for customization on all levels. From the early beginning, extensibility was a core design principle – both to enable great 3^rd party partners and because all development shops have a need to customize the tools they use. There’s also a public TFS 2010 SDK for Java which includes documentation, samples and redistributable components to help developing software products that integrate with TFS 2010.

A final big thank you to all the Microsoft involved people who helped to make this project a success. This was also a good demonstration of vendor commitment to the customer: support by local sales persons, together with product group people and partners. Up to me now to accompany the rollout in the field!

TFS v.Next has also an interesting roadmap and will even more become the default cross-technology ALM choice:

• New Team Explorer: http://blogs.msdn.com/b/bharry/archive/2011/09/19/the-new-team-explorer-in-tfs-11.aspx
• Version Control improvements/enhancements: http://blogs.msdn.com/b/bharry/archive/2011/08/02/version-control-model-enhancements-in-tfs-11.aspx + http://blogs.msdn.com/b/bharry/archive/2011/09/01/wrapping-up-tfs-11-version-control-improvements.aspx
• Agile Project Management: http://blogs.msdn.com/b/bharry/archive/2011/06/14/agile-project-management-in-visual-studio-alm-v-next.aspx

Note that TFS v.Next went into Beta last week and includes a go-live license. More information can be found at the blog of Jason Zander (corporate vice president for the Visual Studio team in the Developer Division at Microsoft).

Completed builds may sometimes be more valuable for the development team and only a few of them will eventually be published/deployed for (public) Testing. This means that Testers (in theory) should only be able to log bugs against these particular builds.

There are two important fields on a bug work item which may point to a build: “Found in Build” and “Integrated in Build”.

For both fields a value can be selected from a combobox. The values in the combobox are part of the global list for the builds in the active Team Project.

By default, ALL finished builds (failed + succeeded) will trigger the BuildCompletion event in the Team Project Collection and the accompanying Build Number will be appended to the existing global list for the builds in the Team Project. In Team Projects where a lot of builds are defined, this “Builds” global list will be flooded by superfluous builds which should never be selected for the above fields. CI builds for example should not be part of this global list. Only full builds which are deliberately transferred for testing should be searchable in the above comboboxes.

So, how to explicitly mark a build for “Testing”? This can be easily done with setting a Build Quality for a given build.

Note that people who want to modify the Build Quality should have the permission “Edit build quality”.

Build Quality values can also be managed in a dedicated list.

By using a specific Build Quality value, it’s also possible to create a TFS Server Plugin and to listen to a BuildQualityChangedNotification event and to only add the Build Number to the global list when the Build Quality is set to “Ready for Initial Test”. Of course, the default event-subscription for the BuildCompleted event must be disabled and the existing global list should be cleaned.

This is exactly what I did. Only the Build Numbers of the builds that get a desired Build Quality (“Ready For Initial Test”) will be pushed to the global list of the Builds in the Team Project.

When your team makes fully use of Microsoft Test Manager to file bugs, the “Found in build” field can be automatically set by associating particular builds to a Test Plan. Test execution can then be done against an approved build list. The “Integrated in build” field is normally automatically set by the build process which picks up a bug resolution through a changeset at check-in time.

Some more details how I did implement the customization of the global build list:

Delete the out-of-the-box event-subscription for the BuildCompleted event

The easiest way is actually to navigate to the event-subscription table via SQL Management Studio (tbl_EventSubscription in specific Team Project Collection database) and to delete the event-subscription row from there. But, that shortcut is not really recommended I’m afraid. A safer solution is to rely on the Bissubscribe command line tool ((executable can be found in :\Program Files\Microsoft Team Foundation Server 2010\Tools). Strange enough, there’s no option to list the existing event-subscriptions, but there certainly is an unsubscribe switch to unsubscribe from an event-subscription. You will need the ID of the event-subscription. The only way to get this ID without having to write custom code on the TFS API is to get the ID from looking into the tbl_EventSubscription table in SQL Management Studio. Note that it’s the Integer ID you will need instead of the GUID Subscriber ID.

Recreating this default event-subscription is possible through the command BisSubscribe /eventType BuildCompletionEvent /address http://:8080/tfs//WorkItemTracking/v1.0/Integration.asmx /collection http://:8080/tfs/.

Clean up the existing “Builds” global list

The global list of a Team Project Collection can be exported/imported with the witadmin command-line options or you can export/import a global list through the UI with the Process Editor from the TFS Power Tools.

You will be prompted to store the GlobalList.xml file after which you may edit the list. Delete as many ListItem entries as you want in order to clean up the Build list. This is the value list that will be used for the “Found in Build” and “Integrated in Build” fields.

Import the global list back to TFS via witadmin or the Process Editor.

To immediately witness the result, you may need to restart Visual Studio to clear the cache.

Activate the TFS Server Plugin for processing BuildQualityChangedNotification events

Since TFS 2010, it has become fairly easy to write custom event handlers that will run in the context of Team Foundation Server. It’s a plugin (dll) that needs to be deployed on the TFS Application Tier. How to accomplish this is not well documented, but your best starting point would be to read Chapter 25 of the book Professional Team Foundation Server 2010. Grant Holliday – one of the authors – explains how the ISubscriber interface can be used for extending Team Foundation Server.

For my purpose I implemented the ISubscriber interface in my BuildQualityChangedEventHandler class. The Build Quality I will use in my example is “Ready For Initial Test”. This action should append the Build Number to the Build global list of the Team Project.

Next task was to pick up the BuildQualityChangedNotificationEvent and to take action when the Build Quality was set to “Ready For Initial Test”: export global list, append the current Build Number and import the list back to TFS.

That’s it, build the assembly and drop it in the plug-in folder on all active TFS Application Tiers.

Setting the Build Quality to “Ready For Initial Test” does the trick and adds the Build Number to the Build global list for the appropriate Team Project.

As an extra, I also decided to keep the “Ready For Initial Test” builds indefinitely.

Controlling your builds with the Build Quality value in combination with a TFS Server plugin gives you a lot of power! The next step could be to trigger deployments off a Build Quality value …

Here’s my latest recommendation I have sent to the Ops Team. Note that all involved servers run Windows Server 2008 R2 (64 bit) and the software is installed on the C drive. The TFS Application Tier also has WSS 3.0 (SP2) installed. Use at your own risk and good luck to get this approved by your Ops Team. Traditionally they handle the presumption of innocence principle: the virus scan is innocent until proven guilty!

• TFS Application Tier
  • C:\Program Files\Microsoft Team Foundation Server 2010\Application Tier\Web Services\_tfs_data [TFS Version Control Cache folder]
  • C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions [SharePoint Portal]
  • C:\Windows\Microsoft.NET\Framework\v2.0.50727\Temporary ASP.NET Files [SharePoint Portal + Web Access]
  • C:\Users\TFSWSSAccount\AppData\Local\Temp [SharePoint Portal]
• TFS Build Server(s)
  • Build Agent(s) working directory: D:\Builds
  • TFS local cache folder for TFSBUILD account: C:\Users\TFSBUILDAccount\AppData\Local\Microsoft\Team Foundation
• TFS Data Tier
  • SQL Server data files: .mdf + .ldf
• Client DevSeat
  • TFS workspaces folder: D:\TFS

I did find some official references:

• http://support.microsoft.com/kb/2636507 [TFS 2010]
• http://support.microsoft.com/kb/309422 [SQL Server]
• http://support.microsoft.com/kb/952167 [SharePoint]