Name of the blog

Short description of the blog

Modular Software and Version Control


There are many issues to consider when deciding how to structure your software from an architectural point of view. Chances are that you’ve already split up your code into several modules or components to separate the various routines.

However, deciding about the best software design isn’t the purpose of this blog. At PureCM, we like to look at software from a version control point of view. So let’s agree for the purpose of this blog that a component is a set of files and folders that are versioned together. This also means we’re looking at code components, and at referencing compiled DLLs or the like.

To modularise or not to modularise…

Remember, we’re looking at this question from a version control point of view. So basically there are two options: consider project as one module, or having many modules that are developed individually.

The advantage of having one module for the whole project is obvious. The project gets always built and versioned as a whole, while release snapshots are also taken from version branches as a whole. Also, creating a workspace for a version or feature would always populate the developer workspace with the full content:

Simple. So why would we want to have separate modules?

One of the main reasons is that you might want to reuse certain modules or components for other projects, that they might suddenly get their dedicated developer (team) and individual release cycles. As a consequence, these components need their own container in order to version them separately from the projects they are linked to.

Shared components – an example

Let’s assume you’re using your icon component across multiple projects, with only a specific group working on them – I’ll call them ‘magic designers’. They are the only ones working on these files, so don’t really need to get the other project content to make their changes.

In such a case, you can give them their own version branch in PureCM, which only contains the ‘icons’ components files and folders. Any of your projects using that component could then link to that component version.

So now your developers can either create a workspace for the relevant project version/feature, or the shared component only.


Sharing component releases or all changes immediately?

Using shared components in PureCM also gives you another option. You can choose whether you want to share a static component release or dynamic component version.

The obvious advantage of sharing component releases is that changes made against the component version aren’t shared until t ested and ‘released’ as a release snapshot. A development manager would then simply update the component link to the latest component release to update his project. Of course, this also assures that you can link your projects to different component versions as needs dictate.

O n the other hand, there are cases when you’d want to immediately reflect changes made to a component across all linked location. Linking to the component version allows you to do so. Of course, even with this solution you can have your ‘magic designers’ group work on multiple component versions without problems.


Which of the discussed option you choose is down to your needs; the following t able summarises the available options in PureCM:


Only share stable component updates

Share component updates immediately

Support one component version only

Link to relevant component release

Link to component version

Support multiple component versions

Link to component release of the relevant version

Link to relevant component version

However, as a development manager you can be sure that PureCM tracks all your changes across all linked locations:  any changes made to the component, when a component was linked to which project, at what point the link was updated to a newer component release etc.

If you work with PureCM Professional and use tasks, you will get even more information. PureCM will show all tasks originally completed against a component in the history view of any linked location - and the other way around. Not bad to facilitate release note creation (and have a full, repository-wide task history)!

If you want to learn more about working with shared components, there’s also a white paper available. It covers the above and component setup in more detail. Just download it from here:


SDC, Part 13: Rescheduling (and the consequences for work in progress)

Tim has already described how to schedule tasks and features in Part 3 of the series. This blog will build on this to show how you can reschedule a task or feature. This is one of the major benefits to using features – you can choose which version the feature will be completed in. 

For example you might start a feature in Version 1 thinking it will only take a week. The developer working on the feature will submit changes to the feature. If you realize it will take longer than expected you can move the feature to Version 2. Because the developer only submitted changes to the feature, Version 1 was never updated.

Rescheduling Tasks and Features

To reschedule tasks and features, select them in the Projects view and select ‘Move’. This will launch a dialog for you to select the new version. Alternatively you can drag-and-drop them into the version within the Projects tree.

You are not restricted to moving tasks and features between versions. You can move them between features and folders in the same way.

If developers have not started working on the task or feature then this is it. If work has already commenced then the situation becomes a little more complicated... but less so than you might expect!

Work In Progress: Tasks

A developer is working on the task within her workspace so the task appears under Current Tasks with the file changes.

If a manager moves this task to another version the developer will receive a warning that the task has been moved.

When the developer goes to the My Tasks view, she will see that the task is still assigned to her but that it is not currently being worked on.

The developer will press ‘Start’ to begin working on the task and select the existing workspace. This will switch the workspace to the new version while keeping the changes made.

If you are using a release of PureCM prior to 2010-1d you will first need to manually shelve your changes to the server and revert the changes from the original workspace. You will not be able to switch a workspace which contains changes. After switching the workspace you will need to unshelve the changes back into the workspace.

The simplicity of this approach is often overlooked. Before we started using tasks the team leader would tell each developer which version to submit the changes into. So it was the responsibility of the developer to ensure they were working against the correct version. This is both prone to error and time consuming. Now PureCM switches the workspace to the correct version automatically.

Work In Progress: Features

Now, let’s look at the case when a developer has already submitted changes to the feature. PureCM will automatically create a new feature stream from the new version and merge all the changes from the old feature stream into the new feature stream. If the files in which the changes were made are identical between the two versions then this will all happen automatically. If any of the files are different then this will create an update conflict.

If you are using a release of PureCM prior to 2010-1d you will need to create a new feature from the new version. Create a merge rule from the old feature stream to the new feature stream with the auto-merge flag set. Complete the old feature and set the owner for the new feature.

Update conflicts appear in the My Tasks view if you own the feature.

Click on the Resolve button to launch the Changeset Dialog and resolve any conflicts.

In Summary

This blog has described how to reschedule tasks and features and how developers can switch their changes to the new version.

  • Moving tasks and features in the Projects view is trivial.
  • If a developer is working on a task in a workspace then PureCM will switch the workspace to the new version.
  • If a developer has submitt ed changes to the feature then these changes will be merged to the new feature stream.
  • Moving a feature may create update conflicts which can be resolved within the My Tasks view.
We'll now make a pause in our blog series, look at feedback we get from our readers, and then start filling the gaps. Any comments about topics you'd like to see here are highly welcome!

SDC, Part 12: Parallel Development with Merge Rules

Lee has started to talk about merging in his last blog, as he showed how to apply a hotfix to the current development version. I’ll take on his topic to talk about one of PureCM’s most powerful features: automated merging with ‘Merge Rules’.

Where does merging happen?

PureCM is a client/server based solution, so the all project data is stored in a safe repository. As a developer, you work in a so called ‘workspace’, a local copy of any project held in the repository. This solutions has the benefit of supporting both concurrent and offline development.

The following diagram shows you that there are basically two cases when you might merge:

  1. When updating your workspace based on a version or feature to get your colleagues’ changes.
  2. Directly between branches on the server. Examples for the latter are merging between different versions or development stages of a project, e.g. from development to test.


Updating a workspace is always ‘on demand’ to let the developer decide when to get the changes. Merging on the server can be performed by a user with the necessary permissions, or automatically using merge rules. 

It’s worth noting here that PureCM always merges tasks, i.e. a submitted changeset and not individual file changes. This makes merging extremely transparent, as you’re able to track that you just merged ‘bugfix a’ or ‘feature b’.

Why you want to automate merging with ‘merge rules’

Merge rules are a very powerful feature that allows you two things:

  1. Automatically track changes submitted to one branch (source) that are not present in another (destination). For example, the owner of a development version gets notified about new bug fixes made to a maintenance version
  2. Automatically merge changes submitted to one branch (source) that are not present in a second (destination).

This means that a development manager can basically work with two levels of automation. Level 1 highlights pending merges and lets him preview and confirm (or exclude) the merges. Level 2 merges changes straight away and only notifies in case of a merge conflict that has to be resolved.

This results in reduced overhead when managing parallel development and avoids human error and regression bugs. Merge rules are created automatically in the following cases:

  1. Automatic tracking is enabled from parent to child versions, e.g. from ‘Version 1’ to ‘Version 2’ as seen in the last blog
  2. Automatic merging is enabled into features to keep the feature branch automatically up to date and minimise overhead

A development manager can get an overview of all existing merge rules in the ‘Merging’ view. Here, all merge rules between active versions and features are listed. To keep the view tidy and avoid unplanned merging, merge rules are automatically removed as soon as the version or feature is completed.


Customising merge rules

The Merging view is also the place where development managers can change merge rules as needs dictate. They can change existing merge rules from automated tracking to automated merging and vice versa, or create new merge rules from the menu of the ‘Merge Rule’ folder:

The one condition to respect when creating new merge rules is that the source and destination branch must be part of the same branching hierarchy. In other words, they must have a common ancestor, which is typically the case within a project.

Performing one-off merges

Merge rules are the perfect solution if two branches have a longer lived relationship. However, sometimes you just want to merge a single change without the need to create a merge rule. This is very simple in PureCM and can be done by selecting a completed task and select ‘Merge Change To’.

This will bring up a dialogue where you can select the destination. That’s it. 

Merge tracking

Thanks to its stream-based branching, PureCM can track the merge history of any task throughout the full project hierarchy. Simply access the task properties and select the history tab to see to which versions and features it has been applied to.

We’ve actually finalised another nice feature for our next release in July that allows users to list all releases a task is present. If you’ve ever wondered whether a bugfix has gone into this or that release, this new feature will be an invaluable time saver!


This blog has covered how development managers can take advantage of PureCM Professional’s merging capabilities to automate parallel development.

  • Merge rules either track or merge changes automatically
  • Existing merge rules can be customised and new merge rules created
  • Notifications are automatically made to the owner of the destination version
  • Merge rules are automatically removed once a version or feature is completed

Stay with us and learn how you can reschedule tasks and features as part of an agile planning process – even if coding has already started!

SDC, Part 11: Fixing a bug on a live release

In this blog we will look at how to use PureCM in the process of fixing a bug in a live release. As a developer will probably already be working on 'the next release' it is important that switching to a previous release (to fix a bug) is as uncomplicated as possible.

PureCM provides the mechanism for a developer to work on a fix for an old version, and create a new release, without affecting his current development environment – or have his current development environment affect the bug fix environment (parallel development) … So how does it work?

Raise the task

The first stage is to raise a new task on the specific version of the project. A developer can then simply go to his 'My Tasks' view and click on the 'Start' button to populate his workspace with the code of the relevant version. This will avoid inclusion of any new changes that have gone into subsequent versions.

We've already covered how to create a new task, assign it to a developer and start work on it. So assuming that is all in place, the next step is to actually fix the bug.

Annotated File History

This is a good time to highlight an older feature of PureCM that proves very handy in the process of investigating and fixing bugs.. 

We will assume that the developer has debugged the release and managed to isolate the code that is causing the bug. If it is not an obvious bug, then in order to establish if the code was deliberate or just to find out why it was written, then using the annotated history can help…

This provides a quick way of navigating to the changeset that the code was implemented with thus providing the developer with the description, and if this is not enough to make a judgment on how to proceed then the changeset also provides the name of the developer who made the change – a short conversation could clear things up! As well as 'why' the change was made, it could also be useful to know 'when' the change was made in case an older release needs to be fixed.

Now the bug is fixed, the developer has completed some local testing and is keen to get this fix to the customer as soon as possible, therefore a new release is required. Clicking the 'New Release' option on the Version performs this task.

Tim's blog on creating a release has covered the details for this and how to deploy the release files to another machine, typically to build it.

Merging the change into relevant versions

The last stage in this process is to ensure the fix finds its way into other relevant development versions. This can be achieved by using PureCM's merging capability, even automatically using the 'Merge Rules' functionality. 'Merge Rules' will be described in detail later on in the SDC blog series.

So assuming merging is not done automatically, the owner of the target version can manually perform the relevant merges by navigating to 'My Tasks' where any Pending Changes (per version) will be listed ..

Here, I'm the owner of 'Version 2'. Pressing the 'Show' button reveals the list of changesets pending merge into this version. Right click the relevant changeset and choose 'Merge Change' (or 'Exclude' if you don't need this change).

In Summary

Fixing a bug on a live release can be achieved quickly using PureCM ..

  • Create a task specific to the version
  • Use Annotated History to understand the reasons and history of a change
  • Create new release based on the fixed version using the 'Create Release' functionality.
  • Ensure the fix is merged to the relevant Versions using PureCM's merging functionality.

The next blog will look at merging and merge rules in more detail.

SDC, Part 10: Creating a Release

In the last blog Kenji took a good look at some of the current and upcoming reporting systems inside PureCM. Today I'm going to take a closer look at Releases.

What is a Release?

A release is a snapshot of the code at a specific point in time. This gives you a permanent copy of your code at a specific point, which typically will remain read only. You can directly browse the content of a release and use it for internal/external/beta/etc builds or to send to your testers. Having a release gives you an easy way to tag points in your development and keep track of who is running which version of the code.

Make a release from a feature!

You don't just get to make releases of your versions. If you want to send a feature for testing before it gets integrated into the version you can also make a release of the feature.

How do I know what is in a release?

The quickest way to find a release is to navigate to the relative version/feature in the projects view and select 'Show submitted tasks and releases'. This provides you with a list of all of the changes that have gone into the version and shows at which point your releases have been created.

This gives you a very quick way to see what changes made or missed each release and also provides the interface to do more with your releases. Viewing the files contained within the release for example can be done by selecting the release and selecting the 'Show Files' option.

Seeing what files has changed between releases in very simple as well. Simply select two releases from the list and select 'Compare' from the menu. This will launch the familiar stream comparer tool which will show the files from both releases. If you are only interested in what has changed you can filter out the matching files in the options menu.

Getting the release on your local machine

The best way to get the release files to where you need them is to create a workspace. If you have an old workspace you can switch you can find your release in the 'Projects' tab listed under the correct version. Alternatively, you can simply select the correct release in the projects view as talked about above and choose 'Select Workspace'. Of course, creating a workspace to deploy a release can be scripted, e.g. using one of our build tool integrations, the command line interface or the .NET and Java APIs.


  • Releases are snapshots of your code at a specific point in time
  • Releases can be made from both Versions and Features
  • You can view your releases by selecting 'Show Submitted Tasks and Releases' in the Projects view.
  • You can get the files by simply creating a workspace.

In the next blog Lee will take a look at the process of fixing a bug in a current live release without including changes from ongoing development; the basic case of parallel development.

SDC, Part 9: Project Status Reporting

We’ve now covered the development journey from setting up a project hierarchy and assigning features and tasks to completing work. It’s time to have a look at how you can keep track of what’s happened. PureCM offers several ways to visualise project status, which I’ll present below.

What information do you need?

True, there are countless reports, diagrams and options when looking at reporting. But if I try to reduce to the max, as a development or project manager you’ll quite likely want to get answers to the following questions:

  • What has been completed in this version (or iteration)?
  • Which tasks are still open?
  • Who is working on what?

Note that I’m usually referring to features and task when asking these questions. I want to see which features have been implemented, not which lines of code have been changed. The latter is very important, too, and will be covered in the next blog.

What has been completed in this version?

Getting the current project status

With PureCM, you can easily get that information in the Projects view. Select the project or version you want to look at and simply set the filter to ‘Completed tasks and features’. This will give you a list of all work items that have been completed. 

From there you can immediately drill down to more detailed information, e.g. show all tasks of a feature or all files that were changed/added/deleted as part of the change. Or you can check into which other versions or features a specific change has been merged into.

If you also want to see all release snapshots that were taken, click on ‘Show submitted tasks and releases’. This will open a chronological view of how the changes were applied to the server. 

Progress over time: the project burndown

The above has given you a quick update on the current status, but you don’t see how you’ve progressed during, say, the last iteration. Of course, you can save the task lists at multiple times to get a burndown report, but this is definitely too manual a task. So let’s change to the ‘Reporting’ view, where we can create report templates. 

With the next PureCM release in July you’ll get three new task-based reports with the Professional edition: The burndown, burndown with priority and the developer status report. All three allow you to define a template that dynamically generates a html report that you can customise, print and/or export as CSV or XML.

Besides getting a good feeling for velocity (“how many tasks do I typically complete in a certain period of time?”), an increase in total tasks also shows you whether you’ve suffered from scope creep. Reporting is an area we’ll be working on further, so feel free to share your needs with us!

Which tasks are still open?

Now that we know what has been completed, we can check on what is still open. Again, we can start from the Projects view and set the filter to ‘Open tasks and features’. From there we can filter on a specific task status or priority to get a better idea of where we are just now.

As before, you can also switch to the Reports view to see how the number of open tasks has evolved over time to estimate how likely it is that you finish all open tasks for the current iteration or version. This time, I've exported the CSV and created a standard chart in no time.

Of course, not all tasks have the same importance. Thus you can also get a burndown per priority to check whether at least your high priority items can be completed as planned. ;)

Who’s working on what?

Finally, you might wonder which of your team members might have some free resources... To do so, you can again use the Projects view and filter on a specific user name or run the developer status report. The project view might be more useful if you’re about to assign work, as you can do that from the same view. On the other hand, the report is easier to show or print for a progress meeting with your team, as you can list all developers at once.


I’ve covered three basic reports that most probably all project managers need to answer. More specifically, I’ve covered the following topics:

  • Current project status from the Projects view: Completed or open tasks that allow fully dynamic drill down from feature to code line.
  • Burndown report from the Projects view: History of completed and open tasks for a given period of time, typically based for estimation
  • Report templates can be customised, printed and exported as CSV/XML

With this, you should be armed for any progress meeting. Tim will move a step forward on the development lifecycle and explain how you can create release snapshots, retrieve them and visualise the file and folder differences.

SDC, Part 8: Code reviews using features

We've seen how developers can work with both tasks (for small work items) and features (for larger work items). This blog will look at how code reviews can be achieved using features.

Why Reviews?

As a developer completes all the tasks required for a feature, without code review, the option to 'Complete' on the feature is used. Submitting the resulting changeset would merge the feature into the parent Version immediately, close the feature, and stop any code changes from being merged into the feature (from the parent Version). This means that the developer's code is added to the main (parent) Version without any kind of formal inspection or review by someone other than the developer.

This is perfectly acceptable and a common way of working, but in many cases it is a requirement for code to be reviewed before being submitted into a main version. By using reviews, a feature can be given to a manager (or group of), to perform a review of the code changes. The result of the review is either to accept the changes, and commit them to the Version, or reject them.

When rejecting a review it is usual for the feature to be handed back to the developer to complete any outstanding requests.

How to enable Reviews

Because of the isolation of a feature it is very simple to use it as a platform to review the code. Reviews 'come for free' simply by assigning the feature to a user or group of users other than the developer.

So for example.. 

A feature is assigned to a 'Lead Developer' (who is responsible for the review) - this makes them the owner of the feature, and the tasks of that feature are assigned to a 'Developer'. The developer completes the tasks as previously described in earlier blogs. As the developer completes the last task of the feature, this feature appears in the Lead Developer's list of 'Pending Features' (under 'My Tasks' and also 'Workspaces' tabs)..

Here the Lead Developer clicks on the 'Complete' button and is presented with the changeset dialog showing the files to be reviewed. Each file can be viewed and changes scrutinised. The 'Submit' button is used if the changeset is acceptable. This results in the changeset being merged into the parent Version. 

If it is decided that the changeset should not be submitted (ie. rejected) then the dialog can be closed and the Lead Developer can create new tasks for the feature and assign them to the developer.

These tasks would then appear under the Developer's 'My Tasks' list as before, and the feature would no longer appear in the Lead Developer's task list, until the new tasks are completed.

In Summary


  • The isolation of a feature allows for an easy way to perform code reviews.
  • By assigning the Feature to the manager and the tasks to the developer, the review process is automated.
  • The reviewer can accept a feature by submitting the changeset, or introduce new tasks to the feature for the developer to perform.

In the next blog we will focus on the project manager again and look at project reporting.

SDC, Part 7: Working on a Larger Work Item: Features

In the last blog Tim described how a developer works with tasks to complete small units of work. I will follow on from this to discuss how a developer works with larger pieces of work.

My Features

We have already introduced the concept of a feature and described when a manager should create a feature as opposed to a task. So lets assume a manager has already assigned a feature to you.

After a feature has been assigned to you it will appear in the ‘Workspaces’ view under ‘My Features’.

From here you can:

  • Open a workspace for the feature. This will allow you select an existing workspace or create a new workspace.
  • Show the file differences between the feature and the version.
  • Complete the feature by merging all the changes back into the version.


Feature Workspaces

To start working on the feature press Open and select an existing workspace or create a new workspace. If you have already created a workspace for a feature which you have completed then you should select this workspace. This will switch the workspace from the old feature to the new feature. Switching a workspace is a lot quicker than creating a new workspace.

After opening the workspace you can start working on the files the same as if you were working against the version directly. You can use any of the PureCM clients or one of our IDE plugins such as Visual Studio or Eclipse.

The difference between working on a feature, rather than working on the version directly, is that submitted changes are only applied to the feature. So you can checkpoint your work, submitting unfinished changes, without breaking everybody else’s workspace.

Completing the Feature

When you have submitted all the changes required for a feature it is time to complete the feature and merge the changes back into the version. In the Workspaces view press Complete.

This will open the Changeset Dialog showing all the changes for this feature.

Press the Submit button to apply these changes to the version. All the feature changes will be merged back into the version as one changeset.

Features & Tasks

If you are using features and tasks then you start working by selecting Start on the task in the My Tasks view, as described in Tim’s blog. Whether the task is part of a feature or version makes no difference when working with tasks; PureCM will automatically populate your workspace with the correct files and folders.

When all the tasks within a feature have been completed, the feature will appear under ‘Pending Features’ in the My Tasks view. From here you can Complete the feature to merge it back into the version. The feature will only appear under ‘Pending Features’ if the feature is assigned to you.

In Summary

  • You can create a new workspace or switch an existing workspace to start working on the feature.
  • You can checkpoint your code within a feature workspace without breaking everybody else’s workspace.
  • After submitting all the changes to the feature you complete the feature by merging all the changes back into the version as a single changeset.
  • When working with tasks, it makes no difference whether you are working on a feature task or a version task.

The next blog will describe how you can use features to perform code reviews.

SDC, Part 6: Working on a small work item: tasks

In this part of the SDC series we are focusing on a developers day to day life. Last time Lee looked at developer workspaces, now we are going to look at how tasks interact with and manage those workspaces.

My Tasks

We already introduced the concept of a task in my last blog looking from a managers point of view. To a developer a task represents  a small chunk of work that has been assigned to them to complete. These can be easily viewed from the 'My Tasks' area.

As you can see the tasks in this view are broken down into three sections; 'Working', 'Assigned' and 'Group'. These divide the tasks between those that have been linked to a workspace and those which have not. Each section is sorted by priority to help you complete the most important tasks first.

To link a task to a workspace select start button. This will launch a dialog to let you select your workspace. By default it will highlight a workspace connected to the same version as the task. You can always chose to switch an old workspace by selecting it. If no workspaces exist it will launch the new workspace dialog and automatically select the correct version.

Group Assigned Tasks

These are tasks that have been assigned to multiple users using a group. This does not mean that they all work on the same task together, instead it provides a good way for managers to put tasks into a pool for a team to complete (This can be great for end of release bug fixes). As soon as a developer starts work on a task he removes it from the pool and assigns it to himself.

What does Complete do?

For both assigned and group tasks you get the option to complete it. This is designed for when the task is completed without any changes to the server. These cases can include testing tasks or simply tasks that have been completed already.

Working Offline

If you ever need to work while being disconnected from the PureCM server you will be happy to know that tasks assigned to you are stored locally for you to continue working.

Inside your workspace

Each task linked to a workspace acts as a changeset. You can work on multiple tasks at once as different changesets by simply starting work on multiple tasks.

Sometimes you may have no choice but to implement two tasks as one changeset. In this case PureCM allows you to submit the changeset with both tasks assigned to it. From the submit dialog you need to switch to the 'Tasks' tab and select all of the tasks you intend to submit.


When you know which workspace you are working in and want to select the next task without changing your view, select the 'Current Tasks' node and choose the 'Work on Task' item. This provides you with a way to select the task you want to work on or even create a new task inside the correct version.


In Summary

  • You can complete a task without submitting a change from the My Tasks view.
  • Tasks can be assigned to a group to allow any developer from the team to work on it.
  • Tasks assigned to you are stored for offline work.
  • You can link multiple tasks to a changeset by selecting them in the submit dialog.
  • You can create new tasks from inside your workspace using the work on task dialog.

The next blog will look at larger work items that are too big to handle with a single task.

SDC, Part 5: Developer Workspaces

Up to now, the blogs have focused on a manager's point of view of using PureCM's project features. This blog will focus on a developer's perspective.

Where developers work ..

The workspace is (always) where developers work. This is a local copy of a version, feature or release where the developer can perform day to day operations using features such as Checkout or Submit.

By having a local copy of files and folders the developer can work independently of other developers, and choose when to either integrate others' changes, or when to submit their changes.

A developer can have multiple workspaces at any time and can also switch a workspace to point to a different Version. 

Using Workspaces

As an example of using workspaces I will explain how I currently work ..

I have multiple workspaces, of which two I actively use on a day to day basis. One is based on a feature that I am implementing for the next major release of PureCM (2010-1-r2). The other is for any bug fixes that I am tasked with for the current release (2010-1). As you have seen in the previous blog, versions and features get their own branch in PureCM. This means I currently keep an active workspace for each different PureCM release I'm working on and switch workspaces between features.

The feature has been broken down into several tasks, which on their own involve small amounts of work - roughly no more than a day for each. 

By navigating to the 'My Tasks' tab I can select a task to begin work on, by clicking 'Start'..


Here I can choose the workspace where to carry out the work. In the workspace, I checkout the files relevant for the current task, make the changes, and submit the work. The work is submitted via a changeset. The changeset shows the files involved (edits, adds of new files, and any deleted files). The task is also shown as a tab on the changeset. The task description is automatically added as the changeset description - this can be amended if required.

Usually, before submitting changes, I would make sure the workspace is up to date (with others' changes). This is done with the 'Update to Latest' operation on a workspace node, or the 'Update' button found in the 'Workspaces' page to the right of the relevant workspace (See image below). It is possible to have PureCM automatically update a workspace immediately before a submit. This is one of the options found in the Option dialog found in the 'Tools' menu..

Once submitted, the changes are uploaded to the feature, the task is completed and I can move onto the next task. 

This process is repeated until all tasks in the feature are completed. At this point the feature can be completed. Depending on how the features are set up, this could involve code review before the changes are finally merged into the parent Version.(There will be a blog written soon covering this topic). 

Workspace Switching

Moving on to another feature involves simply selecting a task from the 'My Tasks' list and, when the same workspace is selected, PureCM automatically switches the workspace to point to the new feature that the task belongs to.

As for the other (2010-1) workspace I have, changes are made and submitted directly to the Version. If changes are required on a different version, then the 'Switch Workspace' option in the workspace/Advanced menu allows a different version to be chosen. The workspace is then updated with the relevant files. The 'Workspaces' tab also alows you to 'switch' a workspace..


In Summary


  • Workspaces are local copies of a version, feature or release
  •  Changesets are used to submit changes to the server 
  • 'Update to latest' keeps the workspace up to date 
  • Workspaces can be switched to different versions (automatically or manually)


We briefly touched on the use of tasks in this blog. The next blog will focus specifically on tasks, and working on small work items.