Team Foundation Server 2008 vs 2010

When speaking to potential clients, I more often than not end up needing to explain to them that all the issues and problems they are highlighting often derive from TFS 2008, or more so, TFS 2005.  In my business I find that I still deal with a lot of misconceptions around TFS as a product and what it provides. The result is that I end up needing to “re-sell” clients on TFS.

Dealing with such a legacy is a hotly contested market space and obviously a big hindrance to any business. So in an attempt to correct some perceptions I’ll endeavour to address some misconceptions around TFS 2010, specifically comparing TFS 2010 against TFS 2005 & TFS 2008.

To start off with, a real common one….

TFS 2010 is Expensive…

In years gone by the licensing structure of Visual Studio 2005 & 2008 merely included a TFS CAL ($499) in the MSDN subscription. You still had to purchase a TFS server license for about $2800.
In 2010 you still have the CAL included in the MSDN subscription, BUT you now also get a TFS 2010 server license included!
You can however still buy a retail copy of TFS 2010, it will only set you back $499 allowing 5 named users without the need for additional CAL’s (going over this number you will have to purchase CAL’s for each user though).

So… if you purchased Visual Studio 2010 with MSDN for each developer, you are ALREADY licensed for TFS 2010.

Due to the fact that TFS 2010 comes with a restricted usage SQL 2008 license (or in fact can run on SQL 2008 Express) and WSS3 or SharePoint Foundation is free, you can have a fully functioning TFS 2010 environment up and running without coming close to the capital expenditure of its predecessors!

The next thing that people always go on about is “but svn/git/mercurial is free”. Yes they are free, BUT they are merely version control products (and yes some of them are pretty good ones at that).
TFS has a version control component to it, BUT it also incorporates and integrates a large number of other features, to mention a few:

• extensive reporting capability
• collaboration
• work item management
• test case management & lab management
• build automation

“But…” you say, “there are a bunch of other tools that can perform these tasks”. “Yes“ I say “there are”, but are they seamlessly integrated to give a single view across all the functions in the development sphere? Do they give you the ability to interrogate the progress, activity, quality or performance of your team in detail? Are they integrated into your “day-to-day” environments making them a natural part of your environment?

If you have not yet considered TFS 2010 due to cost, please take some time and get the facts (or speak to me )!

You may be surprised!

Visual Studio 2010 version aversion…

TFS being a tool that has some intimacy with Visual Studio often puts me in a situation where clients have many questions regarding the different versions of Visual Studio. The tight integration between TFS and Visual Studio can leave one wondering… where does Visual Studio end and TFS begin.

I will be the first to admit that any search for a comparison between Visual Studio editions is pretty easy to come by, but for convenience, here's a useful comparative table of visual studio 2010 versions.

(Image stolen from Ahmed Salijee)

Visual Studio 2010 Professional

Professional is your entry level environment allowing you to perform you day to day coding tasks. A big issue that I have is the lack of quality tools packaged with this edition, but it is a cheaper alternative to get your team up and going.

Visual Studio 2010 Premium

Premium in my mind is the minimum version that an enterprise dev team should consider. More expensive, but adding a quality perspective, including aspects such as code analysis, code coverage & metrics and then also (in my mind) a hugely underutilised “Database Professional”.

Visual Studio 2010 Ultimate

Ultimate is the granddaddy. A strong focus on architecture with support for modelling and layer validation, but including load and web tests. It also includes a Test Manager license (see Test Professional below). Very pricey and probably not worth the money in most teams/smaller companies.

Stepping out of the developer realm a new product or edition has been introduced in the 2010 suite called Test Professional

Test Professional

Contrary to common believe this is NOT a development environment. It includes Team Explorer, but that is where the similarities end. Test Professional edition primarily consists of Microsoft Test Manager, a tool that is targeted toward the tester, someone that needs to set-up test cases and execute these by (often) manually running through the application. It also includes the ability to set-up and configure Lab Management which in my opinion is more technical than I would prefer to allow a tester to handle.

Misconceptions…

One of the misconceptions that I often deal with is that you need Visual Studio to “work” with TFS. Team Explorer is actually all you need which happens to be a free download (you still need a CAL to access TFS though). Team Explorer does provide a tight integration between TFS and ANY Visual Studio 2010 version though. Then again Team Explorer is just one of the many ways to interact with TFS…

 

DevDays 2011 Cape Town

DevDays 2011 Cape Town drew to a close yesterday evening.

I presented one of the community session slots and decided to upload the presentation for those who could not attend.

Enjoy…

5 Misconceptions around
TFS and Visual Studio 2010

Visual Studio vNext

For those of you that do not keep up to date with what is happening around the world, TechEd North America is currently in progress.

Being a technology junky I generally enjoy events such as TechEd and MiX(especially our American counterparts). This is the time that Microsoft starts introducing stuff they have been working on since the last event, or gives us a glimpse into what they are working towards in the next wave of product releases.

This time, once again, TechEd is hardly off the ground and the excitement has already started to set in.  As part of the keynote Jason Zanders gave some insight into what is coming in Visual Studio ALM vNext.

I must admit, from a brief glimpse, there are some very exciting things heading our way! I really like the revamp of the TFS Web (TSWA) and the new functionality around planning and capturing feedback. I would however like to see more around the work that they have been doing with TFS on Azure.

In Visual Studio the unit test integration hooks for 3rd party frameworks looks interesting and the new “Team Navigator” has potential.

Oh man.. we’re just starting to get the hang of VS & TFS 2010 and we are already looking to the next version with anticipation…
Hi, my name is Niel, and I’m a technology junkie

TFS as an open platform?!

Brian Harry has previously mentioned his intent for TFS to be an open platform. To date the architecture supports this very nicely, from the wide range of integrated applications and clients to providing developers with a very rich .Net API.

Then Microsoft took over Teamprise’s Client Suite rebranding it to Team Explorer Everywhere (TEE).
For those that have not yet heard about TEE, it is basically Team Explorer for Mac, Linux and some Unix flavours (yes… even Windows). One of its components is an Eclipse plugin, giving (primarily java developers) basically the same experience that we are familiar with inside Visual Studio.

Yesterday Microsoft once again upped the ante by providing a java SDK for TFS.

This extension to different development environments, and the work that Microsoft has put in on the Hosting story and is putting in to get TFS on Azure means that you can have the benefits of TFS, without the need to actually run any Windows based servers locally! How neat is that!

Now what I would really be interested in is how much demand there is for this, and what is Microsoft doing to “sell” TFS to non Microsoft dev environments? Locally TFS and Visual Studio is being evangelised via the main stream events such as DevDays and Tech Ed, but what should we be doing to get the message out to people that do not attend these events?

But enough business, where did I put that old Java book of mine….

Dev4Devs Cape Town

Dev4Devs was held on Saturday, what an awesome event!

Well done to my fellow presenters for giving us very interesting (yet brief) insight into some topics that lie close to their hearts, and a big thanks to Dave Russell from Microsoft for setting it up and hosting the event here in Cape Town. 

I believe Dev4Devs is a platform for people who have a passion for what they do, and would like to share it with “the world”. You’ll experience what it means to present to like-minded people allowing just enough time to give you a “taste” for what presenting is all about. I would really encourage people to give it a go. Dave has promised that this would definitely not be the last time that this event is held in Cape Town.

We each had a 20 minute slot to talk about, or “present” on a topic of our choice which is challenging, but part of the fun! And of coarse, if by some highly unlikely event you get bored with the current topic, the next one is literally around the corner

Thanks to all that attended, hope to see you at the next one…

For now though, the next event to look forward to is DevDays, see you there!!

Custom Check-in Policies for TFS 2010

I was showing a demo to a client on custom policies the other day. We went through a couple of caveats that exists between the TFS 2008 and TFS 2010 way of doing things.
If you look long enough you will find specific posts or conversations on individual issues. I decided to do a post that encompasses these issues, and a couple of my findings while creating these custom policies in TFS 2010.

Creating the custom policy is fairly straight forward. Using Visual Studio, create a new class library and add a reference to “Microsoft.TeamFoundation.VersionControl.Client.dll”.

Next create the class that you will be using and inherit from “Microsoft.TeamFoundation.VersionControl.Client.PolicyBase” and implement the methods. You should have something like this:

using Microsoft.TeamFoundation.VersionControl.Client;

 

namespace TeamFoundation.CommentPolicy

{

    public class CommentWordCountPolicy : PolicyBase

    {

        public override string Description

        {

            get { throw new System.NotImplementedException(); }

        }

 

        public override string Type

        {

            get { throw new System.NotImplementedException(); }

        }

 

        public override string TypeDescription

        {

            get { throw new System.NotImplementedException(); }

        }

 

        public override bool Edit(IPolicyEditArgs policyEditArgs)

        {

            throw new System.NotImplementedException();

        }

 

        public override PolicyFailure[] Evaluate()

        {

            throw new System.NotImplementedException();

        }

    }

}

The “Type” property can be related to the friendly name of the policy. Interestingly enough, the “TypeDescription” property is the description shown on the “Add Check-in Policy” dialog (Figure 1), and the “Description” property is the description shown in the description column of the “Check-in Policy” tab (Figure 2) when the policy is selected.

 
Figure 1: Add Check-in Policy Dialog

Figure 2: Check-in Policy Tab

The “Edit” method is where you would handle any custom configuration that you may require. This method is executed before the policy is added to the list in figure 2 and when you click the “Edit” button while the policy is highlighted in the Check-in Policy tab (Figure 2). Note that if you return “false” in this method the policy will not be added to the active list. In addition, the “PolicyBase” class has a property “CanEdit” that you can override manually. If you return false for this property the “Edit” method will not be executed and the “Edit” button next to the list in figure 2 will be disabled.

Next up is the “Evaluate” method, this is where all the magic happens. You have access to the protected property “PendingCheckin” which provides pretty much all the information that you would need to devise some weird and wonderful policies. If the “Evaluate” method returns an array containing a valid instance of a “PolicyFailure” class, the check-in will show you the policy violation.

So once you have populated the properties and methods accordingly the next point is of utmost importance. You must mark your class as Serializable. If you do not, your new policy will simply not show up in the available policies list.

Next up you need to register the policy in the registry under the following path: [HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\10.0\TeamFoundation\SourceControl\Checkin Policies].

Create a new String Value with the name of the assembly that contains your policy excluding the .dll extension and the value being the full path to your assembly. Example :
Name: TeamFoundation.CommentPolicy
Value: C:\Projects\Policies\TeamFoundation.CommentPolicy.dll

This should complete the steps to create and register a new check-in policy. The only thing left is to deploy the policy on each workstation that is to adhere to the policy. If you do not do this an error will be displayed that the policy is not installed, and it will be disregarded. The TFS 2010 Power Tools however have a “new” way of deploying these assemblies, but it is still up to the developer to opt in to the deployment mechanism.

TeamFoundation.CommentPolicy.zip