Team Foundation Server for everyone, everywhere…

The topic I chose to present for this round of Dev4Devs Cape Town was (you guessed it) TFS.
This time I took a different approach and showed off the “new” focus that Microsoft has started adopting. Instead of trying to convert everybody to the Microsoft way of doing things, Microsoft is starting to adopt the desperate development realms and in some cases, is actually supporting them! This is very exciting for everyone using very competent, often “lower cost to entry” development tools and technologies, providing capability to grow which was previously unrealised.

So without further delay – here is a brief overview of my presentation: TFS for everyone, everywhere

IDE of choice…

Anyone who has worked with TFS should be familiar with Team Explorer. This is the developers portal into “the belly of the beast, erm TFS”.

Maybe a little less known to the Java, and especially the Eclipse developers would be a product  by the name of Team Explorer Everywhere (TEE).
This is (amongst others) an Eclipse plugin which is basically Team Explorer for the “non-Microsoft” orientated. It introduces TFS to the Windows, Linux, Mac, Solaris, AIX and HP-UX users (see here under system requirements for the “official” list of supported IDE’s and OS’s).

Deja vu?

As would be expected there are a few minor differences between the two, but by far any Visual Studio / Team Explorer user will feel right at home using and configuring TEE, right down to the check in dialog and policies.

API of choice…

OK, so now you have TFS integration into Visual Studio and Eclipse. What about the extensive .NET API (that is installed with Team Explorer)?

No Problem! Microsoft has released a TFS Java SDK.

Looking at a .NET example to create a work item in TFS:

1) Add a reference to Microsoft.TeamFoundation.Client and Microsoft.TeamFoundation.WorkItemTracking.Client

2) Establish a connection to the appropriate TFS Project Collection

   1: //get default credentials

   2: var credentials = CredentialCache.DefaultNetworkCredentials;

   3:  

   4: //connect to TFS project collection 

   5: TfsTeamProjectCollection collection = new TfsTeamProjectCollection(new Uri("http://localhost:8080/tfs/defaultcollection"), credentials, new UICredentialsProvider());

   6: collection.EnsureAuthenticated();

3) Using a Service Locator pattern we can get “services” from the project collection. In this case we are interested in the WorkItemStore. This is basically a repository for work items and can be used to load and query work items

   1: var workItemStore = collection.GetService<WorkItemStore>();

4) Then a bit of plumbing… Because each team project is based on a specific process template we need to get a work item definition that is appropriate to that project/process template. In this case we are looking for the “Task” work item definition in the “Dev4Devs” team project

   1: var project = workItemStore.Projects["Dev4Devs"];

   2: var workItemType = project.WorkItemTypes["Task"];

5) Create a new work item and start setting appropriate properties

   1: var workItem = new WorkItem(workItemType);

   2:  

   3: //set appropriate properties on the work item

   4: workItem.Title = "my new work item";

6) And finally, based on an active record pattern, we simple save the newly created work item

   1: workItem.Save();

Simple enough…..

So looking at the Java SDK, how difficult will it be?

1) The first step is to obviously get hold of the Java SDK and add it as a referenced library in the java project

2) Create a connection to the team project collection

   1: TFSUser user = new TFSUser("useraccount");

   2: TFSTeamProjectCollection collection = new TFSTeamProjectCollection("http://localhost:8080/tfs/DefaultCollection", user, "Password");

   3: collection.ensureAuthenticated();

3) Get the work item client (instead of store…)

   1: WorkItemClient workItemClient = collection.getWorkItemClient();

4) Get hold of the work item definition from the appropriate project

   1: Project project = workItemClient.getProjects().get("Dev4Devs");

   2: WorkItemType type = project.getWorkItemTypes().get("Task");

5) Create a new work item

   1: WorkItem workItem = workItemClient.newWorkItem(type);

   2:  

   3: //set appropriate properties on the work item

   4: workItem.setTitle("my new work item from java");

6) and finally

   1: workItem.save();

So, save a few nuances, pretty much the same when it comes to the interface exposed by the .NET and Java object models.

As mentioned earlier, I can’t wait to see where all this leads to in the adoption of TFS as a decent (and more often than not, cheaper) ALM suit.
Team Foundation Server…. not just your average version control

 

Team Foundation Server goodie bag

Anyone that has been following Brian Harry over the last number of weeks would have started seeing what is in the pipeline for Team Foundation Server vNext.

As he posts about the new features, I’m getting more and more exited about the way that Microsoft is busy closing the gap between TFS and the products that TFS is usually compared to. I find that there is still a very narrow vision of finding a single feature, and then if the system you are comparing against does not support this feature as expected, it is discounted (sometimes aggressively).

Things are changing though…

One of the new features that would make a lot of SVN users very happy is the introduction of local workspaces. This is a particularly big deal as a lot of people seem to have problems with working in “offline” scenarios.

Another contentious issue has always been the rollback ability within TFS source control. A large number of people may not have known this, but rollbacks in TFS have actually been possible for a while now. Granted a bit of a hassle as a “true” rollback was only possible via command line.
Well not any more. According to Brian, the next version of the TFS Power Tools will be bringing forward the Rollback “UI” from the next release.

Considering how TFS as a product is maturing while taking the community into consideration, I must admit that making a decision to take the passion I have for TFS, building a business around it while sharing it with the world, was probably the best thing I could have done.
After all, who would have ever expected a Microsoft supported “cross platform” Java based environment and API for TFS to appear?

I can’t wait to see what is coming next!

BTW: If you are considering upgrading to Visual Studio 2010 or TFS 2010, please do evaluate your Software Assurance options…

Professional Team Foundation Server 2010

I recently finished reading Professional Team Foundation Server 2010 by Ed Blankenship, Martin Woodward, Grant Holliday and Brian Keller.

I’ve been a long-time fan of all the authors and was quite exited when I heard that they were busy writing this book. So when it was finally available in this country I snatched one up and started reading.

Barring the fact that I think there are some questionable statements, I found the book to be tedious at times as it starts out with a high level overview and then drills down into more detail in subsequent chapters.  I think the layout of the book is well suited as a reference book, looking up sections as and when you need to find information on certain topics.

The book did bring some insight into areas that I was previously not so familiar with, and it is evident that the authors are well versed in TFS. One thing that I found interesting was the guidance on how to do “Planning and Deployment”. This is obviously very helpful when you’re doing this as a business or just wanting to adopt internally.

Overall I must admit that I did enjoy the book. I would say that Professional Team Foundation Server 2010 and Professional Application Lifecycle Development with Visual Studio 2010 are definitely required for any team taking development with Team Foundation Server and Visual Studio 2010 seriously.

Happy Reading !

Microsoft Test Manager Video Recording on Windows 2008 Server

I had some “issues” getting the video recorder collectors working on Widows 2008 R2 Server recently.

I’m sure some of you have had something like this pop up…

The link provided is not really of much use, it merely tells you to install the Expression 4 encoder. This in its self is not going to give you much joy, so here are the steps in a bit more detail:

Step 1: Add “Desktop Experience”

Using “Server Manager” add a new “Feature”. Select “Desktop Experience” as highlighted below, add any required features and complete the installation

Step 2: Expression 4 encoder

Download and install the Expression 4 (SP1) encoder.  Note that the new Encoder is now included in Visual Studio SP1.

Step 3: The missing link…

One thing that the Microsoft Help does not mention is that you need to update the Microsoft Test Manager Video Diagnostic Adapter as well. To do this you need to download the updated adapter and install it.

From here on it is as simple as ensuring the your configuration has the video recorder adapter enabled.
Open up Test Manager, select “Plan” and then select the “Properties” tab.

In the properties select the appropriate test settings and select “Open”.

Select “Data and Diagnostics”, scroll down the list of diagnostic adapters and make sure that the “Video Recorder” collector is enabled. You can select “Configure” toward the right of the “Video Recorder” collector row, and set some options if you want to configure the collector further.

Select “Finish” and voila, you can start recording test run sessions.

 

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 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….

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

 

TFS & VS 2010 and the Database Developer

 

I was working at a client last week, giving them an overview of Database Development using Visual Studio 2010 Database Professional (DBPro). They mentioned the TFS Provider for SQL Server Management Studio (SSMS) and their attempts in trying work with it.

It had been a couple of years since I looked at it last (honestly before DBPro was released). You can download (it’s free) the plug in from here (created by the famous Martin Woodward). I noticed that it had in fact been updated to work with TFS 2010. So I decided to give it a spin.

Firstly I must highlight one of the (in my opinion) less know features in SSMS, you can create and manage projects in pretty much the same way you do in Visual Studio.

After installing the TFS Provider, make sure that SMSS knows that you are using a Source Control plugin. Select Tools | Options. Select “Source Control” and if it has not already updated, change the current plug-in to “Team Foundation Server MSSCCI Provider”.

Now select the File | New | Project menu option and a pretty familiar looking dialog will appear

Once the project has been created open up the “Solution Explorer” ( View | Solution Explorer ) and the project layout is shown

Right click on the “project name” and select Add | New Item. Notice that you start to get the same experience as you would in Visual Studio. You have the ability to add a number of “different” items to the project. Different categories have different templates etc..

And now with the Source Control plugin you can add this “Solution” or “Project” to source control (as you would a Visual Studio Project) and perform source control related check-in’s and outs, view history, compare etc. etc..

Using SSMS you still do use scripts to manage your “database”. If you only have access to Visual Studio 2010 Professional (or not at all) then this is possibly an option to evaluate (you still would need a TFS CAL).

Both SSMS and DBPro use scripts to manage your schema (DBPro has a nice “schema view” that shows you the database schema represented via scripts though), BUT with all the additional functionality that DBPro offers, including database comparisons, unit testing and data generation, I definitely prefer DBPro.

 

Upgrade Visual SourceSafe today!

 

If you do not already know Visual SourceSafe’s mainstream support is coming to an end July 2012. This means that if you are still using SourceSafe after this date and you have a serious problem, too bad! (unless you are willing to pay for the extended support.)

So if you have not already though about upgrading, it is probably advisable to start looking at options.

Over the last couple of week I’ve noticed a bigger push from Microsoft to upgrade with pricing specials and more information around migrating to Team Foundation Server 2010 (being the de-facto Microsoft upgrade path).

If you have not yet looked at your options, do take a look at the following resources:

• Upgrade Visual SourceSafe Today
• Upgrade Visual SourceSafe to Team Foundation Server

That said, if you happen to be in South Africa and would like more information or advice feel free to give us a shout

Visual Studio 2010 SP1 released

Finally!

Very unceremoniously Microsoft has announced that the Visual Studio 2010 Service Pack 1 will be available today (8th March ) for download for MSDN Subscribers, and will be generally available for download on March 10th, 2011.

This brings with it some very exiting bits (in addition to fixing some very annoying bugs). Some of my personnel favourites include:

1. IIS Express Support (still need to install it separately though)
2. Silverlight 4 tools are included
3. Performance wizard for Silverlight (to profile Silverlight apps)
4. Unit Testing under .Net 3.5 (previously they all ran under .Net 4)
5. Initial HTML 5 support

On TFS SP1 most of the changes were focussed to allow the Team Foundation Server 2010 and Project Server Integration Feature Pack, in addition to a fairly large number of bug fixes outlined here by Brian Harry.

Oh and while we’re at it, don't forget about the Team Foundation 2010 Power Tools March 2011 release

TFS Security Overview

TFS security can be an interesting beast to work with from an administration point of view.
Not only do you have to manage the permissions assignments in 3 different places (TFS, SharePoint and Reporting Services), but the TFS security model takes on a very layered approach, where different permissions apply on different “levels”.

Most of the groups discussed below are configured and maintained in TFS, so where possible you would probably want to create Active Directory Groups and have these assigned to the correct TFS, SharePoint and Reporting Services groups. This allows you to assign and remove users from a single point (AD) and then this applies across the board.

Additionally TFS rights can be either “Allowed”, “Denied” or “Unset”. Unset means they are neither denied or allowed and means that the inheritance of that right from another group takes precedence. Also note that “Deny” takes precedence in most cases.

If you appear in two groups, one group allowing a feature and in another group that feature is denied, you will have that feature denied. The only exception is if you exist in an administrators group (“Project Administrators”, “Project Collection Administrators” or “Team Foundation Administrator”), the deny is overridden by the rights assignment in the administration group for the associated level.

Administration Console
This level is really assigned to individuals who are responsible for the administration of TFS itself. You cannot assign groups into this role (only users) and assigning this actually modifies rights on the physical aspects such the databases, SharePoint etc.
I would recommend that you limit the amount of users in this group to administrators responsible for TFS maintenance and high level configuration.


Server Level Permissions
Focussed more at operational aspects of TFS on a server level and not specific to a project collections. These groups can only be modified from within the TFS Administration Console.
The default groups created at this level are:

• SharePoint Web Application Services
• Team Foundation Administrators
• Team Foundation Service Accounts
• Team Foundation Valid Users
• Work Item Only View Users

This is where you assign permissions such as being able to create or delete project collections. The “Team Foundation Valid Users” and “Team Foundation Service Accounts” groups cannot be added to directly. The “Valid Users” group is an aggregated list of all the Server Level Permissions as well as the individual Project Collection “Valid Users” groups’ and merely assigns access to the TFS Web portal and viewing instance related information. The “Work Item Only View Users” is a group where you would typically assign project managers or the likes, that is only able to create and manage work items from the web portal, in other words you do not see build information and source code browser etc..
Permissions available on this level include:

• Administer Warehouse
• Create team project collection
• Delete Team project collection
• Edit instance-level information
• Make requests on behalf of others
• Use full Web Access features
• View instance-level information

Collection Level Permissions
These are specific to the project collection. The reason for having this level is to segregate project collections from each other, providing something of a contained “eco-system” for each project collection. These can be modified from the TFS Administration Console as well as directly through Team Explorer.
The default groups created at this level are:

• Project Collection Administrators
• Project Collection Build Administrators
• Project Collection Build Service Accounts
• Project Collection Proxy Service Accounts
• Project Collection Service Accounts
• Project Collection Test Service Accounts
• Project Collection Valid Users Collection 

As you can probably deduce from the names – these are still very much administration related groups, but as mentioned previously contained to a project collection.
Permissions available on this level include:

• Administer shelved changes
• Administer workspaces
• Alter trace settings
• Create a workspace
• Create new projects
• Delete team project
• Edit collection-level information
• Make requests on behalf of others
• Manage build resources
• Manage process template
• Manage test controllers
• Manage work item link types
• Trigger Events
• Use build resources
• View build resources
• View collection-level information
• View system synchronization information

Project Level Permissions
This level is specific to a project and can only be managed through Team Explorer. This is also where things become interesting… setting permissions on this level, you need to consider the Build, Area’s, Iterations and Version Control, as each exhibits its own set of permissions. So to draw a comprehensive security model on this level you would need to draw together all the required permissions and then allocated the appropriate permissions in each of these functional areas. Once again if you have a large number of teams working on different projects, Active Directory Groups are definitely the way to go.
The number of default groups are small and include merely:

• Builders
• Contributors
• Project Administrators
• Readers

Areas and Iterations:
To my mind these are ways of grouping work. They are very similar in structure with only the permissions between the two differing. I quite like the description of having Areas denote the “logical, physical, or functional” grouping vs. Iterations that denote the time based grouping.
Right click on the project name in Team Explorer and select “Team Project Settings” then “Areas and Iterations”. This will display the dialog for managing the Areas and Iterations. At the bottom of the dialog next to the “Close” button you will find the “Security” button.
The permissions can be set at each node of the hierarchy and the permissions set at the lower nodes override the inherited permissions.
Permissions include:
Areas:

• Create and order child nodes
• Delete this node
• Edit this node
• Edit work items in this node
• Manage test plans
• View this node
• View work items in this node

Note the work item permissions here. This allows you to “group” work items in the project and only allow certain users to “see” certain work items. This comes in handy when you subscribe to having a single project containing a number or individual projects.
Iterations

• Create and order child nodes
• Delete this node
• Edit this node
• View this node

Build
These permissions are specific to the build infrastructure that TFS provides. In Team Explorer under the appropriate project right click on the “Build” node and select “Security”.
Permissions available here are:

• View builds
• Edit build quality
• Retain indefinitely
• Delete builds
• Manage build qualities
• Destroy builds
• Update build information
• Queue build
• Manage build queue
• Stop builds
• View build definition
• Edit build definition
• Delete build definition
• Override check-in validation by build

Source Control
The version control repository where all files are checked into. Open the source control window by double clicking on “Source Control” node under the appropriate project. You should see the source control layout that looks similar to a folder structure. Right click on any of the “folders” select “Properties”. The dialog that is displayed will have a “Security” tab on. Note that if you have a folder marked as a branch the dialog looks different and the security functionality is under the “Permissions” tab. Similar to the Areas and Iterations the inherited permissions are overwritten.
Permissions available here are:

• Read
• Check out
• Check in
• Label
• Lock
• Revise other user's changes
• Unlock other user's changes
• Undo other user's changes
• Administer labels
• Manage permissions
• Check in other user's changes
• Merge
• Manage branch

The TFS security model does give you a lot of flexibility, but it is not always that easy to navigate and manage. I have come across very few instances where there was a need to create additional groups within TFS, the default groups that are created are adequate for most deployments. If the need does arise to create custom groups, you should be aware of all the various aspects that it may encompass.

TFS on Windows Azure

Big news if you following Microsoft PDC 2010 is that Mr TFS : Brian Harry did a demo on how they took TFS 2010 and modified it to run on Windows Azure.

This is obviously concerning from a competition point of view if you are hosting TFS, as Microsoft is most likely going to have TFS as an subscription service on Azure.

That aside, it is interesting to see the effort involved in “porting” a large scale application to Windows Azure and the caveats that you have to address to have something running successfully.

On the plus side they made some improvements to TFS itself, which makes more sense for it to run “in the cloud”. One of the major changes in my mind is that fact that they changed the Build Controller to have a client as opposed to a peer relationship.

I always hated the cyclical relationship between TFS and the Build Controllers. Working in distributed teams it was a mission setting up continuous integration and then with limited access to the TFS Build servers, we would either have to commute to the office to fix a build issue or, what tended to happen more often, you live with a broken build for a couple of weeks until someone went in to the office that could fix it.

I really hope that we will see these changes becoming available in the mainstream application.

Free Ebook: Moving to Microsoft Visual Studio 2010

Get it while it's hot..


http://blogs.msdn.com/b/microsoft_press/archive/2010/09/13/free-ebook-moving-to-microsoft-visual-studio-2010.aspx

Some bed time reading on how to upgrade yourself from previous versions to Visual Studio 2010. It gives a detailed overview of how things change and what new features are available in a fairly unique approach.

You can find a detailed overview of the book here.
 
(cross posted from http://devtendencies.blogspot.com/2010/09/moving-to-microsoft-visual-studio-2010.html)

MCTS : TFS 2010 here I come..

woo-hoo wrote the 70-512 exam and passed it.... I was a bit concerned about the depth of knowledge needed etc, but after taking advice and working through the TFS Admin (one of those tortuously long detailed guides) and TFS Install documents. In addition to a fair degree of working experience it seemed to be good enough :)...

Having this exam under my belt should provide me with the MCTS for TFS 2010 administration. First check box for the ALM competency checked....

Bad News?

Today I was doing some reading up on TFS in general. I then remembered about Grant Holiday. If you don't know him then you obviously do not take this TFS thing serious :). Why he is of such keen interest to me is that he helped start up one of the first hosted TFS services (in Australia), then went to work for Microsoft - still actively involved in TFS.


The first post on his blog really make my heart drop. Basically it stated that TFSNow (the hosted TFS company that he was involved in) no longer offers TFS as a hosted service.

That is not what I would have liked to hear. Why would one of the first companies to market no longer offer the service.

I dropped him a mail and anxiously await some insight into this....

Initial Idea

What is all this about...

I am at a stage where I have to evaluate my career growth path. Looking online from my current role, the aspirations are very limited. Like one of the Microsoft "small business sites" indicated you basically have a limited number of options:

1. On the technical side going into architecture (such as enterprise architecture), or
2. on the other side going into the more business side of things (PM / analyst) and
3. almost unanimously they all reckon "or you can always go the start up route".

The start up route is obviously the "nicer" one to consider - being your own boss, working your own hours, doing your own thing.

Hhhmm - easy then to say "take the start up path", but if you do not have a product or concept that will work you're probably going to sit back at this cross road shortly with 1 less option to evaluate.

So lets get some of those ideas ....

Obviously - first requirement is that I need to know something about the industry that the idea originates from. Being in the software industry for over a decade now - this is where I'll be applying my thinking.

The first idea that comes to mind: develop your own super duper application and hope someone will see the benefit and spend money on it (probably the route most taken). Alas, I have worked for one or two companies that took that route not being able to make it (even after getting fairly large clients to buy into the idea).

The problem with this is that the time to market is too long, and I have very limited funds available for this venture. I could get a another job and try to work on it after hours, but I've been in industry long enough to know that coming home after long days at work to try and develop something else - will push this venture out even further..

Next idea: I need to leverage something that is gaining ground in industry, is a unique offering in the current market and will have a much quicker turnaround time to get up and running.

Enter Microsoft's ® Team Foundation Server...

I have been working with TFS since TFS 2005 and have become my (previous) company's "TFS Guy", maintaining their current infrastructure and doing consulting to their clients around TFS and software processes. But being a custom dev shop their focus was on delivering projects (leveraging TFS) , and not TFS as a product though.

During these off site projects and the TFS consulting gigs, I realised that there is a lack of skills around configuration, managing and maintaining TFS (often blaming the product for their lack of understanding) and of coarse a hefty pricetag to correctly license and use the product, yet there is a fairly steady adoption rate.

So if you can change the local mindset of having their own in house infrastructure and get them to adopt a hosted scenario, with possibly better security, configuration and maintenance, there may be some hope after all.

Looking around there are a number of hosters already that seem to have cornered the market abroad, offering a fairly diverse array of services and features, but as every South African knows the exchange rate and time delay in any service request etc, can really put a damper on a South African budget.

So with this in mind I decided to look at pursuing this and seeing if I could in fact make a decent business out of it. I also decided to keep an online diary of sorts to try and gain better community awareness and to document my struggles in the hope that someone else could learn from it and pursue their dream (hopefully in a different field :) )

So let the adventure begin and see if the idea will end up in the toilet or if it will allow me to gain the independence that every employee is in search of.

Note:

As a note I'm posting with a fair delay, as to not give to away to much of my intention or the process. I do believe and hope this is a first in South Africa, so I do not want someone to steal this idea before I can get my name and services out there..