TFS Branching and Merging Guide v2

Apr 262012

Earlier this month some very useful guidance documentation was published on Codeplex.
The topic? Build and versioning guidance, from Microsoft’s ALM Rangers group.

The guides are broken down into a number of PDF files. In the main documentation archive (which you can download from Codeplex) are a number of files:

Branching and Merging Guide – Cheatsheet Advanced Plan.pdf
Branching and Merging Guide – Cheatsheet Basic Branch Plan.pdf
Branching and Merging Guide – Cheatsheet Picking a Strategy.pdf
Branching and Merging Guide – Cheatsheet Standard Branch Plan.pdf
Branching and Merging Guide – Cheatsheet Terminology.pdf
Branching and Merging Guide – Illustrations.pdf
Branching and Merging Guide – Illustrations.pptx
Branching and Merging Guide.pdf

Which, all said, cover a fair amount of material.
Also packaged are some Hands on Labs which provide a useful set of demonstration examples, and can be used with the Beta version of TFS.

According to the main PDF (Branching and Merging Guide.pdf) the following bullet points describe the new content covered in the beta documentation:

The guidance will have some new verbiage and recommendations around some of our existing branching
plans, as well as add some coverage for new branching plans.
This guidance introduces you to local workspace which is a new concept in Team Foundation Server 11.
Local workspace enables you to continue working even when network access is intermittent or
unavailable thereby providing increased bandwidth availability and client optimizations.
We provide new guidance around effectively managing shared resources in source control by discussing
various common scenarios and describing the pros and cons with each approach. This guide lays a solid
foundation for implementing sharing for your development efforts in your Team Foundation Server
environment.
Branching and merging with database projects is discussed in detail.
There is in-depth coverage of merge improvements in Team Foundation Server 11. There has been
enhancements made to the product that brings a whole set of improvements in the area of merging,
primarily fewer conflicts that require user interaction when merging, new merge tool for conflict
resolution in merging, new file comparison tool, baseless merging from the UI, and merging available on
unshelving.
Different scenarios for baseless merging are discussed in this release of the guidance. Baseless merges are
not ideal but may be required on occasion. The Pros and Cons of baseless merging are pointed out with
coverage on the enhancements made in Visual Studio 11 around baseless merging. You can now perform

There are separate diagrams within the “Branching and Merging Guide – Illustrations.pptx” PowerPoint side deck, enabling ease of access for reuse.

You might recall, I published my own (similar) version of this diagram here on Sanders Technology not that long ago:

This diagram is an excellent representation of how to branch and merge for multiple feature sets, keeping the main trunk in synch, as well as the features in release order.

The diagrams get quite a bit more sophisticated, here is another which illustrates my own rules for dev/branch and patch management:

What I quite like about these diagrams is that it underscores how important merging and branching are to a mature development lifecycle.

This model allows parallel development as well as maintenance on the released product.

I won’t go into too much detail – there’s a lot to read – suffice to say that if you have a vested interest in learning or understanding application lifecycle management (be it on Team Foundation Server or an alternative), this isn’t a bad place to start.

The guidance could easily be applied to other source control and lifecycle management tools.

Handy Links:

Download the Team Foundation Server 11 Branching and Merging Guidance
Download the Visual Studio 11 Beta
Download the Team Foundation Server 11 Beta
Download the Team Foundation Server 11 Beta Power Tools

Team Foundation Server in the Cloud (Part 2)

Cloud Computing, Team Foundation Server 1 Response »

Sep 192011

Part 1	Setting up TFS Azure
Part 2	Configuring Visual Studio to use TFS Azure
Part 3	Registering Team Build controllers for TFS Azure
Part 4	Builds in the Cloud

Introduction

Continuing on from Part 1, we’re taking an early look at TFS Azure, Microsoft’s first service offering of Team Foundation Server backed on top of the Azure Cloud service.

The Continuing Saga

By now you have probably registered with TFSPreview.com and created an initial Team Project. Using the same Windows Live credentials, now we’ll look at connecting to and consuming resources from Visual Studio 2010.

I’m assuming that you already have Team Explorer installed (if not, you’ll need it) and that you’ve applied Visual Studio 2010 Service Pack 1 and the KB Hotfix. I encountered a plethora of issues getting the hotfix applied, but hopefully you will have had less issues.

Connecting and Authenticating

Start Visual Studio 2010 and, once loaded, go to Team (Menu) –> Connect to Team Foundation Server.

Since this it the first time you’ll be connecting, click on the Servers.. button, and then click on the add button in the next dialog. Use the URI listed on your TFSPreview administration page (in the form .tfspreview.com">.tfspreview.com">.tfspreview.com">.tfspreview.com">.tfspreview.com">https://<yoursite>.tfspreview.com):

If all goes well, you’ll get an authentication page pop up and ask you to select the federated security model of choice (as of writing, only Live IDs are supported).

Selecting the default provider, we’re taking to Live to sign in – use the same credentials you registered your TFS service with (for best results). You can create or assign other IDs later on.

Once authentication is complete, you should find your server has been successfully added to the list of TFS servers. Select your server and you should be prompted with the available Team Projects:

Victory is Mine

Once opened, Team Explorer should populate as if the TFS service was not cloud based, which means we should be able to use TFS more or less as we would normally, i.e. source control, work items etc..

Limitations

A few things to note, from my first glance:

No Team Portal (SharePoint) or Team Web Access
Team Members (from TFS Power Tools) doesn’t seem to work/populate
No Reporting (SSRS)
No Process Guidance
Can’t create a new Team Project from inside Visual Studio:

You’ll need to create Team Projects from the browser/admin site

Group Membership/Security is managed via the website, even if you use the context menu in Visual Studio

Next Steps

In the next part, we’ll add a sample solution and define a build controller, and define a build definition or three, and see how well TFS responds. We’ll also allocate some extra users, and play with permissions, groups and work items.

Part 1	Setting up TFS Azure
Part 2	Configuring Visual Studio to use TFS Azure
Part 3	Registering Team Build controllers for TFS Azure
Part 4

Team Foundation Server in the Cloud (Part 1)

Cloud Computing, Team Foundation Server 14 Responses »

Sep 182011

Part 1 – Setting up TFS Azure (this article)
Part 2 – Configuring Visual Studio to use TFS Azure
Part 3 – Registering Team Build controllers for TFS Azure
Part 4 – Builds in the Cloud

Introduction

At the recent BUILD convention in the US, Microsoft announced a series of new Cloud-based services, one in particular being Team Foundation Server. Although we’ve heard rumours about such an offering for a long time, and that some services (such as TFSNow) actually were offered by third parties, this represents the first major push from Microsoft directly.

In order to drum up some initial interest, Microsoft launched http://www.tfspreview.com and an early beta period with invites sent to BUILD attendees and select members of the Microsoft development community. Although there are already a spate of blogs with video and image walkthroughs, I decided to give TFS Preview the Sanders Technology treatment.

I’ve been building or administering TFS installations for over six years now, since the early betas of Team Foundation Server 2005 back when I was an Associate Consultant at Readify. I’ve deep experience in all versions of TFS to date, so I expect I’m in a decent position to evaluate and discuss this new service and how it integrates into the development process.

Let’s start at the beginning..

Signing Up

Before we go any further.. have you got an invite code? They are rather hard to come by, and a lot of the early multi-use codes are now exhausted. I, personally, have a few activations left on an invite code (or two) so to those lucky readers who get in first, I’m happy to email you a TFS Preview invite code while I can – while stocks last!

Once you have your invite code, browse to http://www.tfspreview.com and click on the “Create Account” button.

On the next page, select a name for your TFS URL, paste your invite code and agree to the ToS. You’ll need a valid Live Account (which is used for all valid users of TFS in the cloud).

Assuming it all goes smoothly, your account will be created, and you’ll appear at the main console page. What to do next, is to examine all your software and make sure you have applied the hotfix (for Visual Studio 2010) if you wish to get your hands dirty. However, there’s still some initial configuration to be done in your browser first.

Creating a Team Project

Everything in TFS revolves around a Collection and a Team Project. In normal TFS, you can have multiple collections and multiple Team Projects – in the cloud, it seems that we have just the default collection (if anyone can figure out how to create multiple, please let me know).

From the account page, click on the “Administration” link in the upper right hand corner of the screen. You’ll enter the Administration console which has a number of options:

Our immediate priority is to create a Team Project – clicking on “create team project” will provide us with this nifty pop up window – fill in the details as you desire, and proceed by clicking on “Create Project”:

Administration

Once the project has been successfully created, you’ll also notice that a default collection has been created, and your team project is now a child of that default collection. The console now provides more functionality – click on the Project drop list and select “Browse all Projects”:

Select your Team Project and then click “Navigate”. I’ve circled the main page navigation as each should be worthy of a bit of investigation. Each link provides access to security, group membership and key team project configuration (such as Areas and Iterations) which essentially represent their approximate siblings in TFS 2005, 2008 and 2010 respectively. Little has changed here, except that instead of adding Active Directory accounts to groups, you add users according to their Live Accounts instead.

From the main page you can view all the traditional options which we would find in Team Foundation Server, I’ve taken screen captures of the most interesting windows:

Areas Iterations

Security Group Membership

Member Details Project Groups

By default, the user who creates the Team Project is an administrator, which means complete access to all settings and functionality. Now that a Team Project has been created, you will want to consume TFS from within Visual Studio.

If you haven’t already, download and install the hotfix located here. When I ran the hotfix I received this:

If you hit a wall, probably best to reapply Visual Studio 2010 Service Pack 1. Last of all, you can also hit the TFS Azure forums which are located here: http://social.msdn.microsoft.com/Forums/en-US/TFService/threads

Check back son for Part 2, where we’ll look at some practical ways to use this new TFS cloud service!

Downloads

Software Downloads for the Team Foundation Service Preview:
http://blogs.msdn.com/b/visualstudioalm/archive/2011/09/14/tfs-preview-downloads.aspx

Microsoft® Visual Studio® 11 Developer Preview:
http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=27542

Older Entries

Featured Articles

A quick and dirty Rules Engine using Windows Workflow (Part 2)
Hi there and happy new year. 2011 promises to be quite an interesting year, and I hope that I can continue to contribute here at Sanders Technology. To kick off the new year, I decided to revisit the Windows Workflow article I started late last year. A little while ago I wrote a post at entitled “A quick and dirty Rules Engine using Windows Workflow (Part 1)” which has evidently been fairly popular. Unfortunately, it seems that I forgot to follow it up with a part 2! Now, welcoming in the new year, I’m putting together the second part. Honestly though, folks, this could easily be a multi part mini project, because the uses of this Windows Workflow Foundation (WF) [...]
A quick and dirty Rules Engine using Windows Workflow (Part 1)
Recently I put my mind towards developing a fairly light rules based utility for applying various logical patterns on top of some linear business data. Honestly, my initial thoughts were “oh no, not another boring rules based implementation” because we (ought to) know how boring that can be – and convoluted – but this time I decided to try something a little different. Through no fault of my own, I’ve actually had very little to do with Windows Workflow Foundation – WF, not WWF which stands for World Wildlife Foundation, and not to be confused with the World Wrestling Federation, just to avoid confusion! Most of the project I’ve worked on previously have used some other workflow product, usually something [...]
The ADO.Net Entity Framework, POCO Objects and You
Introduction Now if you are like me, you’ve probably had some interest in POCO (plain old CLR objects) objects for at least some time. They are an invaluable tool in the distributed systems and service oriented architecture areas, but up until now they’ve been inaccessible for those designs. In a nutshell, both LINQ to SQL and Entity Framework (v1) class entities did not support serialization for the purpose of stateless transport(such as web service communication). This stems from the embedded context tracking attributes, and the design which stipulates a fairly poor experience for those daring enough to detach entities and “pass them around”. Enter the ADO.net Entity Framework v2.. ahem, version 4 which shipped in the early part of this [...]
A Dynamic Data Website with SQL Azure and the Entity Framework
This is part of a series of entries written about Microsoft’s new SQL Azure database service and the Entity Framework v4. Following on from my previous posts (check them out before continuing) – this article assumes you have followed steps outlined in the previous posts to create various models and accounts etc. Part 1 – Working with Entity Framework v4 and SQL Azure Part 2 – Next Steps with SQL Azure Part 3 – Putting it all together – SQL Azure Part 4 – A Dynamic Data Website with SQL Azure and the Entity Framework (this post) Addendum – Getting a SQL Azure Database Continuing along.. Our next step is to create a Dynamic Data website. If you haven’t come [...]
Putting it all together – SQL Azure
Happy Australia Day to you! Following on from my previous posts (check them out before continuing) – this article assumes you have followed steps outlined in the previous posts to create various models and accounts etc. Part 1 – Working with Entity Framework v4 and SQL Azure Part 2 – Next Steps with SQL Azure Part 3 – Putting it all together – SQL Azure (this post) Part 4 – A Dynamic Data Website with SQL Azure and the Entity Framework Addendum – Getting a SQL Azure Database Now we should have a working data model which has been created in your SQL Azure (Cloud) database. Taking lessons learned from Part 2, we’re going to create an Entity Framework (v4) [...]
Working with Entity Framework v4 and SQL Azure
This post is the first in a series of posts on this topic. The following is a summary of the various parts. Part 1 – Working with Entity Framework v4 and SQL Azure (this post) Part 2 – Next Steps with SQL Azure Part 3 – Putting it all together – SQL Azure Part 4 – A Dynamic Data Website with SQL Azure and the Entity Framework Addendum – Getting a SQL Azure Database Introduction Well, it’s been “out there” for a while, and now it is time I gave you a taste of how to combine some of the “Next Generation” data access technologies, today. SQL Azure is Microsoft’s “Database in the Cloud” and represents a complete makeover (replacement) [...]
Functional Transparency: Part 2
This is a little late – but I feel it is worth going into and you can catch up be reading (or re-reading) Part 1 located here. Just in case you are wondering “what on Earth is he babbling on about?” which is a fair and often under asked question, here’s a brief summary to refresh your memory. The objective is to implement additional (background) functionality which is not seen by calling/consuming code – hence, transparent. In fact, it’s even possible to enforce execution of certain functionality no matter how a DataContext is manipulated – neat, huh? So let us look at a simple database table and let us further assume you have generated a LINQ to SQL Model: SQL [...]
Functional Transparency with LINQ to SQL (Part 1)
I’m going to coin the phrase ‘Functional Transparency’ because it fits the definition. I’ve been working with functional transparency in LINQ to SQL for a few weeks now, and it seems to be working well enough to write about. The objective is to implement additional (background) functionality which is not seen by calling/consuming code – hence, transparent. In fact, it’s even possible to enforce execution of certain functionality no matter how a DataContext is manipulated – neat, huh? In other words, we implement additional functionality between the DataContext, its entities and the Database itself. Our objective may be to modify the data returned from a query (or data saved to a database), might be to audit operations or even check [...]
Intelligent Paging using LINQ to SQL and the LinqDataSource control
Undoubtedly, anyone who has evaluated LINQ to SQL has fond it a fairly powerful yet lightweight ORM technology which is less complex than the ADO Entity Framework yet utilizes the strength and power of Language Integrated Queries. One problem with LINQ to SQL is the auto paging feature of the LinqDataSource. Below is a rough GridView which displays three columns, UserName, FirstName and LastName. This is just a rough demo, so we’re looking at paging. If you simply drop a GridView and a LinqDataSource control onto a Web Form and configure the LinqDataSource (using Smart Tags) without specifying a Group By field or Order By field (Figure 1) then you will get fairly optimal database querying (Figure 2) although [...]

« Previous Post Pause Next Post »