The simplest way to establish branches is along the three broad phases of development activity in a 
typical organization, namely: 
DEV – activity around new feature development and bug fixing 
MAIN (also called TEST or INTEGRATION) – activity around ensuring product stabilization and 
readiness for release 
PRODUCTION – activity around providing sustained engineering services for released products 
The DEV branch is for staging all new development activity whether it is for feature development, bug 
fixing, or integration of breaking changes. This area is designed to isolate, contain, and stabilize new 
development . 
The MAIN branch exists in spirit in most organizations, but it goes by a few different names.  Some 
organizations refer it as ―TEST,‖ others as ―INTEGRATION,‖ and another common name is ―MAIN.‖  We’ll 
refer to this branch in this document as MAIN, but please keep in mind that the intent is identical for this 
branch whether you call it MAIN, TEST, or INTEGRATION.  It’s the branch that is used as a holding tank to 
integrate changes to and from feature branches, and it should be kept as stable as possible.   
The PRODUCTION branch contains the sources of your released products, or soon to be released 
products. Since this branch houses sources of released products or soon to be released products, quality 
of code is very stable and guaranteed to be as such via strict control of changes. 
A release of an application that follows this strategy will look like this: 
Highlights summary: 
Code for features and bug fixes is developed in the DEV branch. 
At significant milestones and upon meeting some well-defined quality criteria, code gets merged 
into MAIN periodically.  
Code in MAIN gets stabilized for release criteria such as feature completeness, security, and 
performance. 
Code is merged into PRODUCTION from MAIN when the quality is high enough for additional 
testing in production. Releases happen from PRODUCTION. 
Pdf reader thumbnails - Draw thumbnail images for PDF in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Thumbnail Generation with Various Options for Quick PDF Navigation
view pdf image thumbnail; create pdf thumbnail
Pdf reader thumbnails - VB.NET PDF Thumbnail Create SDK: Draw thumbnail images for PDF in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Thumbnail Generation with Various Options for Quick PDF Navigation
how to view pdf thumbnails in; program to create thumbnail from pdf
As code from each branch gets promoted to the next branch or released, the given branch 
becomes open for the next milestone. 
This is the most basic representation of our branching guidance, one that we will elaborate and improve 
upon based on several scenarios discussed in the following sections. It is important to note that all of the 
criteria we’ve defined in the 
Branching Checklist
can be easily accomplished using Team Foundation 
Server. We’ll demonstrate those implementations as we go.  In the following sections we will delve into 
the various implementations of this branching guidance based on the scenarios we described under 
Branching Scenarios
, as well as the size of teams we need to serve.  
Branching Strategies 
Recall our discussion under 
Branching Scenarios
where we described different isolation scenarios - 
let’s consolidate those scenarios with the branching structure described above. The following table 
summarizes the various isolation scenarios accommodated by our recommended branching structure – 
DEV and  PRODUCTION. Note that we have intentionally left MAIN out of this table. We will explain why 
this is so shortly. 
Isolation Criteria Allowed 
DEV 
PRODUCTION 
Feature Isolation 
√ 
Team Isolation 
√ 
Integration Isolation 
√ 
√ 
Release Isolation 
√ 
Our branching guidance allows for several criteria for branching under DEV – we can use it to house our 
branches for feature isolation, or integration isolation, or at a much higher level provide for isolation 
along team organizational lines.  Similarly, we could potentially have different versions of our product in 
production or on users’ desktops that we need to provide maintenance for – accordingly we provide for 
one or more branches under PRODUCTION, each pertaining to a particular release we intend to support.  
For the purposes of this paper, we will start referring to DEV and PRODUCTION as container nodes to 
denote the fact that they contain one or more branches under them. MAIN on the contrary always 
remains a single branch – and should always be kept as such. This is because MAIN is intended to be the 
confluence point for all coding activity happening both under DEV and PRODUCTION. Think of it as a 
railway junction where code meets and makes connections to different destinations. As such, there can 
only be one MAIN with the singular purpose of stabilization for the next release. 
There are other branching strategies that may be appealing for the culture and process of your team that 
aren’t covered in this document. Some of these are: 
Branch per Task 
Branch per Component 
Branch per Technology 
C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
XImage.Barcode Reader. XImage.Barcode Generator. File: Compress PDF. Page: Create Thumbnails. Page: Insert PDF Pages. Page: Delete Existing PDF Pages.
thumbnail view in for pdf files; pdf thumbnails
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
XImage.Barcode Reader. XImage.Barcode Generator. File: Compress PDF. Page: Create Thumbnails. Page: Insert PDF Pages. Page: Delete Existing PDF Pages.
enable pdf thumbnails in; generate pdf thumbnail c#
There is an excellent whitepaper published on MSDN by Chris Birmele that can provide you with more 
information on these strategies:  http://msdn2.microsoft.com/en-us/library/aa730834(VS.80).aspx
. Be 
aware that this section is for information only and you should do the necessary amount of research before 
implementing any of these strategies. 
Broad Areas of Branching Isolation 
Branch: 
DEV 
MAIN 
PRODUCTION 
Type 
Branch or Container  
Always a Branch 
Branch or Container 
Goal 
Feature development, integration 
and stabilization of breaking 
changes 
Achieving ship-
readiness of the next 
major product release, 
performance and 
security stabilization, 
end-to-end acceptance 
Servicing, sustained 
engineering of released 
products, or final fixes 
for the most imminent 
next release 
Ownership 
Development Managers 
Release Management 
and QA 
Release Management 
Permissions 
Read-write for developers 
working on respective features, 
and some test engineers focused 
on feature/function 
level/integration testing. 
Read-only for most 
users. Senior, expert 
developers responsible 
for merging/integrating 
and promoting source 
code between branches 
and into MAIN have 
read-write permissions. 
Urgent hot fixes to daily 
build will necessitate 
read-write permissions 
on a case-by-case basis. 
Read-only for most 
users. Read-write 
restricted to selected 
developers and testers 
working on hot fixes, 
quick fix engineering 
and other sustained 
engineering efforts. 
Otherwise very tightly 
controlled to ensure 
stability of shipped 
code, and readiness to 
provide sustained 
engineering fixes. 
Build Activity 
Continuous integration due to 
heavy code-churn. Need constant 
feedback on code health via 
frequent builds and testing 
iterations. 
Daily builds based on 
whenever code is 
promoted from the DEV 
branches into MAIN. 
On-demand builds 
based on DEV/TEST 
need/readiness. 
Test Focus 
Feature completion, feature 
stabilization, feature integration, 
and core product milestone 
requirements. Need constant 
feedback on code health via 
frequent builds and testing 
iterations. 
End-to-end acceptance 
testing, performance 
and security testing. 
Iterate until the product 
ready to ship. 
Sign-off on release of 
product or hot fixes. 
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Reduce image resources: Since images are usually or large size, images size reducing can help to reduce PDF file size effectively. Embedded page thumbnails.
thumbnail pdf preview; pdf file thumbnail preview
C# PDF Convert to Jpeg SDK: Convert PDF to JPEG images in C#.net
Support of converting from any single one PDF page and multiple pages. Thumbnails can be created from PDF pages. Support for customizing image size.
disable pdf thumbnails; generate thumbnail from pdf
Creating Your Branching Strategy 
Now that we’ve described the concepts behind branching and merging in Team Foundation Server, let’s 
turn our attention to how you can describe an optimal branching strategy for your development needs. 
Single Release Scenario 
The diagram above represents both the physical layout of the branches as well as their logical 
representation. The physical layout describes how the branches actually appear on your Team Foundation 
Server Source Control view, while the logical view represents their inter-relationships. These relationships 
represent how these branches were created – the arrows point to the child branch in a parent  child 
relationship. Code promotion – which is accomplished by merging as we described earlier -   happens 
along the relationship path established by the parentage. Team Foundation Server’s merge functionality 
supports a bi-directional merge along these promotion paths. 
Let’s describe the typical workflow of the development activity staged in these branches. 
Code for features and bug fixes is developed in the DEV branch.  
At significant milestones and upon meeting some well-defined quality criteria, code gets merged 
into MAIN. If MAIN doesn’t exist, we create MAIN by branching it from $/MyProduct/DEV based 
on some known state - a label, a given date, a changeset, etc. 
Code in MAIN gets stabilized for release criteria such as feature completeness, security and 
performance. 
Code is merged into PRODUCTION from MAIN for release when the quality is high enough for 
additional testing and the product is close to release-quality.  If PRODUCTION doesn’t exist, we 
create PRODUCTION by branching it from $/MyProduct/MAIN based on some known state – 
label, date, etc. 
As each milestone gets promoted to the next branch or released, the given branch becomes open 
for the next milestone. 
We iterate on this cycle until we reach a quality bar established for release – at this point, a 
release (Release1.0) is declared from $/MyProduct/Production. 
We create a read-only Safekeeping branch under $/MyProduct/Safekeeping/Release1.0 from 
$/MyProduct/Production/Release1.0. 
$/MyProduct/DEV
$/MyProduct/MAIN
$/MyProduct/PRODUCTION
$/MyProduct/Safekeeping/Release1.0
C# PDF File Compress Library: Compress reduce PDF size in C#.net
Reduce image resources: Since images are usually or large size, images size reducing can help to reduce PDF file size effectively. Embedded page thumbnails.
create thumbnail jpg from pdf; cannot view pdf thumbnails in
VB.NET PDF - View PDF with WPF PDF Viewer for VB.NET
XImage.Barcode Reader. XImage.Barcode Generator. File: Compress PDF. Page: Create Thumbnails. Page: Insert PDF Pages. Page: Delete Existing PDF Pages.
enable pdf thumbnails; show pdf thumbnail in html
At this point, $/MyProduct/DEV and $/MyProduct/MAIN become available for the next release 
(2.0) of the product, while $/MyProduct/PRODUCTION becomes available for sustained 
engineering of Release 1.0.  
Multiple Release Scenario 
Our representation above corresponds to a relatively small sized team with just one release to support. 
Now we will consider a shop that needs to support more than one release at any given time. We modify 
our branching strategy to support multiple Release nodes under $/MyProduct/PRODUCTION, effectively 
making it a container node, as defined in earlier in our document. 
The physical and logical view of the branching structure can be represented as follows: 
This is a good example of Isolation by Release as discussed under the 
Branching Scenarios
section. 
Most of the workflow descriptions under 
Single Release Scenario
still apply, with the exception of 
branch creation operations for releases. At the time $/MyProduct/MAIN is ready for release, it is branched 
into a version folder to denote the release - $/MyProduct/Production/Release2.0 for example, and 
$/MyProduct/SafeKeeping/Release2.0 
Multiple Feature/Team Scenarios: 
The next degree of complexity we need to address is to accommodate isolation for parallel development 
of features for a release. It now makes sense to make DEV a container and introduce multiple feature 
branches, created by branching from MAIN. For example: 
$/MyProduct/MAIN  $/MyProduct/DEV/FeatureBranch1 
$/MyProduct/MAIN  $/MyProduct/DEV/FeatureBranch2 
$/MyProduct/DEV
$/MyProduct/MAIN
$/MyProduct/PRODUCTION
•├───Release1.0
0
•└───Release2.0
0
$/MyProduct/SafeKeeping
•├───Release1.0
0
•└───Release2.0
0
C# PDF Convert to Images SDK: Convert PDF to png, gif images in C#
Converter control easy to create thumbnails from PDF pages. Selection for compressing to multiple image formats. Cut and paste any areas in PDF pages to images.
no pdf thumbnails in; create thumbnail from pdf
C# WPF PDF Viewer SDK to view PDF document in C#.NET
XImage.Barcode Reader. XImage.Barcode Generator. File: Compress PDF. Page: Create Thumbnails. Page: Insert PDF Pages. Page: Delete Existing PDF Pages.
show pdf thumbnails in; pdf thumbnail viewer
$/MyProduct/DEV/ now becomes a container node for various feature branches, while 
$/MyProduct/MAIN becomes the junction point for code promotion between these feature branches. 
Defining Your Code Promotion Model 
We’ve so far dealt with the creation of branches and establishing relationships between the branches 
(denoted by the arrows pointing to the child branch) to provide isolation for various scenarios such as 
providing isolation for multiple development endeavors or supporting multiple releases. By establishing 
these relationships, we’ve also implicitly defined the code promotion path – that is, the path along which 
code can be promoted to the next branch. 
When we created the following branches: 
$/MyProduct/MAIN  $/MyProduct/DEV/FeatureBranch1 
$/MyProduct/MAIN  $/MyProduct/DEV/FeatureBranch2 
we established a parent-child relationship between MAINFeatureBranch1, and MAINFeatureBranch2. 
While the arrows point towards the child branch in the relationship, realistically it is a bi-directional arrow 
that best sums up the relationship as stored by Team Foundation Server. The modified diagram illustrates 
the point: 
$/MyProduct/DEV
•$/MyProduct/Dev/FeatureBranch1
•$/MyProduct/Dev/FeatureBranch2
$/MyProduct/MAIN
$/MyProduct/PRODUCTION
•├───Release1.0
0
•└───Release2.0
0
$/MyProduct/SafeKeeping
•├───Release1.0
0
•└───Release2.0
0
The bi-directional arrows denote that code can be merged in either direction – parent  child, or child  
parent.  This is referred to as the ―merge path‖ which Team Foundation Server offers as the default in the 
merging dialog for a merge operation. 
The merge path defines the code promotion path and has great significance with respect to the best 
practices we are going to describe in dealing with container branches vis-à-vis their parent node. This is 
especially true in the case of the DEV container branches created from MAIN. Let’s illustrate it with the 
following diagram that explores the relationship between them: 
$/MyProduct/DEV
•$/MyProduct/Dev/FeatureBranch1
•$/MyProduct/Dev/FeatureBranch2
$/MyProduct/MAIN
$/MyProduct/PRODUCTION
•├───Release1.0
0
•└───Release2.0
0
$/MyProduct/SafeKeeping
•├───Release1.0
0
•└───Release2.0
0
$/MyProduct/MAIN
$/MyProduct/PRODUCTION/
Release1.0
$/MyProduct/PRODUCTION/
Release2.0
Code Promotion Criteria 
In creating the parentchild relationships between MAIN and the DEV container branches 
(FeatureBranch1, FeatureBranch2) we’ve established a code-promotion path which needs to follow certain 
criteria for merging operations between them. Let’s look at the criteria for code-promotion in this 
relationship: 
1.
Enforce and maintain a high code quality bar in MAIN at all times. This is important from two 
standpoints: 
a.
MAIN hosts the code that is being readied for the next release – we need to guarantee its 
ship-readiness or at least milestone readiness at all times. 
b.
MAIN serves as the junction/confluence point for development activity happening in 
isolation in the various DEV branches – FeatureBranch1, FeatureBranch2. That is, if 
FeatureBranch2 needs fixes contained in FeatureBranch1, it can only get them after those 
fixes have been merged into MAIN from FeatureBranch1. Any destabilization of MAIN 
could potentially contaminate other dependent branches. 
2.
Frontload as much code destabilization in the DEV container branches, and stabilize them before 
merging back to MAIN (for reasons mentioned in #1). 
Quality Gates 
The first criterion we defined for code-promotion was to enforce and maintain a high code quality bar – 
the best practice guidance here is to have a well-defined, agreed upon and publicized set of quality 
criteria that need to be satisfied by any DEV container branch intending to merge into MAIN. At Microsoft, 
these have come to be known as ―Quality Gates‖ which typically consist of the following conditions being 
met: 
1.
A successful build of the source code in all flavors (debug, retail) and on all applicable platforms 
(x86, AMD64, etc.). 
2.
A successful test run using all the build verification tests that are run on builds off MAIN – these 
could be a combination of core scenarios, performance and security tests. 
Forward/Reverse Integration 
Our second criterion for code-promotion was to frontload and stabilize destabilizing changes (new 
features, bug fixes, integration efforts) in the DEV container branches before merging back into MAIN. In 
this respect, we are introducing two new concepts: Forward Integrations (FI) and Reverse Integrations (RI). 
Forward Integration refers to the operations where the child branches sync up to the latest changes 
from its parent branch as in the example: 
$/MyProduct/MAIN  $/MyProduct/DEV/FeatureBranch1 
Conversely, Reverse Integration refers to the operations where the child branch updates its latest 
changes into its parent branch as in the example: 
$/MyProduct/MAIN  $/MyProduct/DEV/FeatureBranch1 
Code Promotion Best Practices 
The merge operations described above – Forward Integration and Reverse Integration – effectively 
describe the code promotion process for this structure. Certain best practices in this regard need to be 
emphasized with respect to code promotion. 
Given the need to ensure utmost stability of MAIN, Reverse Integration criteria should be stringently 
enforced for child branches intending to promote code to MAIN. This should involve: 
1.
A Forward Integration from MAIN, which as defined earlier, is a full sync of the current state of 
code in MAIN into the child branch. Forward Integrating frequently from MAIN as well as 
continuous integration builds (see: Continuous Integration Using Team Foundation Build
) well in 
advance of the final Reverse Integration are recommended as these greatly reduce the effort 
needed to resolve merge conflicts and stabilize code in the in the feature branch which will be 
Reverse Integrated. Effectively, this front-loads the discovery and fixing of build and test issues via 
several iterations before the final Reverse Integration into MAIN – enforce a policy of ―building 
early and building often‖. 
2.
Satisfying the Quality Gates criteria for the merged code before it is checked into the target 
branch. 
Following these guidelines, the final Reverse Integration into MAIN is less likely to have merge conflicts -
unless another branch has checked-in ahead of the current child branch. It is usually prudent to set up a 
Reverse Integration schedule to avoid being repeatedly overtaken by Reverse Integration from other 
branches and having to repeat the Reverse Integration passing criteria. More importantly, it allows other 
development teams to prioritize and coordinate their Reverse Integration efforts in a spirit of 
collaboration. Release Management and/or QA teams usually own the scheduling of RIs based on 
requests from individual development teams. 
Baseless Merges 
As we’ve discussed above, the branch command will create a relationship between two folders which you 
can leverage to perform merges of code between the branches. The relationship is bi-directional so code 
can be merged both ways but Team Foundation Server currently doesn’t facilitate merging between child 
branches. To begin to understand baseless merges, let’s consider the following structure: 
In the scenario above, we have well-defined code promotion path between: 
$/MyProduct/MAIN  $/MyProduct/PRODUCTION/Release1.0 
$/MyProduct/MAIN  $/MyProduct/PRODUCTION/Release2.0 
These code promotion paths exist because both Release1.0 and Release2.0 under production are children 
of MAIN. Unfortunately, there is no direct relationship between the child branches - Release1.0 and 
Release2.0, which makes it difficult for us to merge, for example, a hotfix from Release1.0 into Release2.0 
without having to traverse through $/MyProduct/MAIN.  
If we followed the merge path established by the branch command, a fix from Release1.0 will need to be 
merged in the following sequence for it to be available in the Release2.0 branch: 
$/MyProduct/PRODUCTION/Release1.0  $/MyProduct/MAIN  $/MyProduct/PRODUCTION/Release2.0 
In some cases it may not be feasible to traverse through MAIN because MAIN could potentially have 
moved far ahead of the source code versions in both Release1.0 and Release2.0, and it would take a 
significant amount of work to merge, build, and test the hotfix in MAIN. Here is where baseless merges 
become necessary. The following diagram explores the existing relationship and baseless merges. 
$/MyProduct/DEV
•$/MyProduct/Dev/FeatureBranch1
•$/MyProduct/Dev/FeatureBranch2
$/MyProduct/MAIN
$/MyProduct/PRODUCTION
•├───Release1.0
0
•└───Release2.0
0
$/MyProduct/SafeKeeping
•├───Release1.0
0
•└───Release2.0
0
Documents you may be interested
Documents you may be interested