Title: Team Foundation Server 2015 Customization

Author(s): Gordon Beeming
Published Year: October 2015
ISBN: 9781785888199
Publisher: PACKTPub
Publisher Book URL:  
Pages: 208

About Review:

Review Date: May 2016
Reviewer’s Overall Rating: 4 Stars
Reviewer’s Name: Jason N. Haffey


Continuing my series on Team Foundation Server 2015 books, I decided to read them randomly.  The book, ‘Team Foundation Server 2015 Customization’ by Gordon Beeming was the next book.  This book’s chapters are broken into different areas or functions within TFS and some, but not all, of the customization you can do in each.  Also, this book is nothing but walk-throughs so if you plan to follow the book step by step, I highly recommend you create a new project in TFS before beginning any of the walk-throughs.  In a few walk-throughs, you may even want to back up your TFS before implementing them.

I was a bit concerned when I started reading as the first chapter and first few sections covered ‘customization’ that really was nothing special.  It was all about how to pin widgets to the dashboard and how to create some custom widgets (via backlog or build queries) so that the dashboard widgets display the results.  Now if you are brand new to TFS then maybe this would be somewhat new but considering Microsoft has added very large buttons on the dashboard to ‘add widget’ it’s not like its hidden or requires an advance knowledge of the system.  The second chapter continued to make me question if the book would actually get into something more complex.  While this chapter covered Team Board Customization, which provide a few bits of insight to things that I had not known, most of it is not hidden or even hard to find.  With a little effort (googling) most people would be able to figure these things out.  With all this said, the remaining chapters and their sections squashed any concerns I may have had.

The third chapter jumped right into what I had purchased the book for.  It covered the customization of the Process Templates.  Even in the default installation of TFS you are provided several options for your Process Template (Agile, CMMI, Scrum) but the Gordon just sticks with one for all of his walk-throughs as the templates structures are basically the same, just with different values of course.  Unless you have been working with customization of TFS Process Templates for a while, like me, you may have to read this chapter, then read it again, and very likely read it again.  The issue is not the way Gordon writes but in fact is that the Process Templates are very complex.  A lot of XML files that inter-relate to one another (~100 files spread across ~27 folders).  Some of the files are simple while others very lengthy and complex.  As I said, this chapter was one of the main reasons I purchased this book was because I wanted to have a good understanding of how to customize the Process Templates.  I would like to point out that even after reading this chapter over a few times, I have a ‘good basic’ understanding of the Process Templates but I still need to look things up.

The forth chapter goes into something I knew was possible but was not exactly sure how one went about doing it, adding custom controls into a Work Item.  Gordon does a good job of providing the basics you need to know to make this happen by doing a walk-through to make the title text field change its background color based on the length of the text value.  While this is something that may not be actually useful in the real world, it did illustrate key points.  The key points are that if you want to create custom controls, you need to create one for Visual Studio Team Explore, one for Team Foundation Server Web Portal, and configuring TFS to support the new control.

The fifth and sixth chapter cover the same thing but in two different ways, which some developers agree with and others hate, check-in policies.  The first method he covers is adding a custom control to Visual Studio’s itself, which prevents a developer from even checking in their changes unless they have an associated work item.  Even Gordon points out that this method has one major drawback, it has to be installed onto all the developer machines in a company, which can be hard to do depending on your company’s size.  The second method implements code into the pipeline of TFS itself.  This approach does not require any special code to be deployed to the developer machines but it does require changing the flow of on the server, which in itself can be dangerous unless done carefully.

The seventh chapter covers something close and dear to my heart, TFS Builds.  Gordon starts off by explaining the ‘old’ or XAML Build Definitions.  He walks-through customizing one, to a degree.  If you have ever created a XAML Build Definition, you will know that it is all customization, as the defaults rarely satisfy the needs of any project.  Since the XAML Build Definitions are customizable extensively, it’s almost impossible for anyone to cover it all, but Gordon does a good job of showing you some of the basics.  With that said, when he moved on to the ‘new’ Build Definitions in TFS 2015, I felt like he left the walk-through a bit too vague.  His walk through does a basic build definition.  Now like the XAML Build Definitions, the new Build Definitions are way to extensible to cover everything but what was covered is almost self-explanatory.

The eighth chapter went into a topic I did not even know existed, TFS Scheduled Jobs.  I am not sure that I did not know about them because no one uses them or if it’s because it is just something I never actually considered customizing.  Of course, TFS has scheduled jobs to do backups but I was not aware you could write a bit of code and then push it into TFS to run code against the repositories, like Gordon shows in the walk-through.  This would be one of the walk-throughs I warned you to do a TFS Backup prior to doing.  This walk-through does not work against a single Team Project but rather the whole collection in your system.  The walk-through he shows scans the last 25 check-ins using a regular expression to find a hash (#) followed by some numbers in the check-in description.  It then looks to see if the number following the has is actually a Work Item (could be a User Story or a Task or even a bug).  If it finds a Work Item matching that number, it looks to see if it’s already associated to the change set.  If it is, it moves on to the next check-in.  If it’s not, it associates the work item to the change set.  Now even Gordon points out that his walk-through is very basic and lacks many things that would improve it but oddly enough, if you had check-in policies in place that forced developers to associate a work item to a check-in then this scheduled job would never need to be run.  I have struggled to come up with useful reasons to even use scheduled jobs so maybe you will have better luck.

The ninth chapter covers Service Hooks.  This chapter is short and sweet and very to the point.  A service hook is exactly what its name implies, it’s a hook to allow another service to integrate with TFS.  Some examples are Slack (which we have played with) and Trello.  These hooks send information to these services when an event happens, such as a check-in or a build finishes, successful or not.

The tenth and final chapter was disappointing, to say the least.  The chapter is titled VSO Extensions and VSO stands for Visual Studio Online (or as it’s called now Visual Studio Team Services, or VSTS).  VSTS has the ability to allow you to install extensions that either you create yourself or you install from the Marketplace (some are free while others cost money).  Gordon does do a walk-through of how to create a basic extension, and this is where this chapter let me down.  At the time of the writing, VSTS Extensions were in ‘beta’ and did not even exist in TFS 2015 On-Premise yet.  Now VSTS Extensions and even TFS On-Premise Extensions are in full movement.  There are hundreds of extensions available but I must warn you, most are for VSTS.  The walk-through he provides is very basic and I am sure there is a lot more available now but being that a book is a moment in time, it is missing what has changed between its writing and this very moment.

My overview of the book is that it’s worth a read.  I would not recommend this book to someone who has never worked in TFS before, so make sure you know the basics of TFS before you start to do any customization.  I know I started the review off a bit negative and even ended it negatively but even though the first few chapters and the last few chapters did not provide what I was looking for, the rest of the book does cover many topics that I found very useful and needed to customize our TFS.