Name of the blog

Short description of the blog

Jenkins and Hudson Plugins coming soon in 2013/2

With the 2013/2 release now less than a month away we wanted to outline some of the major new features.

One of the biggest features of the 2013/2 release is the plugin for Jenkins and Hudson. In case you did not know Jenkins/Hudson is an open source Continuous Integration tool similar to CruiseControl. Hudson was the original application but this was forked in 2010 by unhappy open source developers to create Jenkins.

 

PureCM already has plugins for CruiseControl.NET and FinalBuilder - so why do we want another CI plugin?

 

Firstly Jenkins/Hudson has possibly become the most widely used continuous integration tool. This is down to it's active open source community, ease of installation, ease of use and number of plugins. So if you are looking to choose a new CI tool - CruiseControl, Jenkins and FinalBuilder are 3 of the best available.

Secondly we already have customers who are using Jenkins and Hudson. So if you are already using Jenkins/Hudson then it will be simple to install the PureCM plugin and get going with the PureCM streams.

The final benefit is that Jenkins/Hudson is cross-platform and is more commonly run on a linux server. This is not the case for FinalBuilder or CruiseControl.NET.

 

What does the plugin do?

 

Similar to the CruiseControl plugin the plugin allows Jenkins/Hudson to check if any submits have been performed against a stream and update the workspace to get the latest code. Jenkins/Hudson goes a bit further than CruiseControl in that it lets you browse the workspace files. It also gives you more details about the change - like what files have been added, edited and deleted.

 

When will the plugins be available?

 

Unfortunately the plugin required some changes to the pcm command line so they will not be available until the release of 2013/2 in October 2013. If you want to get a beta version of 2013/2 along with the plugin please email support@purecm.com and we will send you the details.

AVC 2: PureCM and Agile

 

In this post I would like to explore more of the Agile Manifesto and how it relates to software development and to delve into some of the reasoning behind why PureCM was designed and built the way it is.

Individual interactions over processes and tools. A cynic might look at this and say this means there is no need for software tools, but that's the point at all. Software tools are helpful and in many cases necessary but your tools should not define your process and you shouldn't be overly dependent on tools for communication. In Agile the right process is the one that works and over time teams might be changing, tweaking, rearranging process to find what works.

In order for an SCM system to be effective in this type of environment in needs to be flexible and adapt to the process instead of imposing process. The right tool is the one that works for you. I want to mention a long time complaint I have had with several SCM systems that impose process either intentionally or through lack of capability. For example AccuRev is a  system where mainline development as an intentional strategy is not supported and Perforce, VSS, CVS only mainline development as a strategy is supported (generally speaking) due to lack of capability.

PureCM has the ability to do basic mainline or complex branch heavy development strategies with any number of combinations in between due to not having a locked workflow and while also having strong capabilities which allow users to adapt PureCM to their process and not the other way around. Change is continuous in the agile flavors and unless it's not practical to think one could go out and buy a whole new set of tools after each tweak to the process, so having tools that can adapt with the right amount of configurability (built in options) is important.

Working software over comprehensive documentation. This entry in the manifesto is a cross-hairs pointed squarely at the waterfall process where every feature and function is documented in great detail before a project even begins. This approach has many pitfalls but in brief what you end up doing is either wasting a ton of time documenting features that never get built (for whatever reason) or adhere so strictly to the original documentation that you lose all ability to adjust to changing market/customer/technology demands over time.

PureCM has adopted a strategy to manage metadata information at the most minimal levels but I will detail this with when I get into Scrum, in short the PureCM task can be reduced to a one-sentence entry and expanded upon over time, detail increases as priority increases so you only spend time documenting features with a high probability of going into development.

Customer collaboration over contract negotiation. Here is part of the manifesto that puts emphasis on including the customer or the key stake holders in the software development process. This can take on different forms in practice from user acceptance testing by the customer, or demo of new features after increments.

PureCM can be a facilitator to this process but it depends on how collaboration is defined and adapted by the team, I will provide several examples once we are Scrumming.

Responding to change over following a plan. Another pitfall of the waterfall process. A lot of software teams might spend months or years working on a project using the original requirements documentation approved by the customer only to find at the end of it all the customer was not happy with the result or conditions in the market had changed enough to make features obsolete before they were even released. With the Scrum adaptation instead of planning out an entire project and a year's worth of effort in advance you plan out short increments called Sprints and this allows priorities to shift in short time to meet the changing demands of the customer.

 

With PureCM it is possible to actually manage your software development effort by sprints and I will get into greater detail in forthcoming posts so stay tuned!

AVC 1: Agile vs Scrum

 

Let's get this Agile Version Control (AVC) series started with a little discussion...

It is important right off the bat to look at the definition of Agile versus the definition of Scrum. We'll talk about Agile and Scrum (and even more things) later on, so it's worth looking at these in more detail.

Agile itself is not a specific way of working, it is generic set of principles or priorities which are outlined in the Agile Manifesto. These are listed as:

  • Individual interactions over processes and tools
  • Working software over comprehensive documentation
  • Customer collaboration over contract negotiation
  • Responding to change over following a plan

In brief, this is Agile. There are a dozen or so additional principles you can add on that are important, like self-organizing teams, sustainable working pace, but these are also covered in the individual Agile flavors so not as important to list here as I can get into those details later.

Scrum is a specific flavor of Agile, specifically it is referred to as an agile project management framework. It draws on the principles of the Agile Manifesto but goes into detail to define day-to-day activities and how to manage a project in a specific way. 

Agile is not about just having daily standup meetings or deciding to swap one feature for another during a development cycle based on customer demands. These actions do exist in Scrum but you are not scrumming if you just have daily standup meetings, there is a lot more to Scrum and perhaps the most important aspect is how teams are managed and organized, in short they manage and organize themselves, there is no project or product manager anymore and teams are empowered to make decisions and solve problems on their own as opposed to being micromanaged. It is the first thing I noticed about Scrum. 

..but why is this important?

Because in the design and construction of PureCM there are facets of the product which will mesh with principles of Agile and will therefore be applicable to many different flavors of Agile, but because my flavor of choice is Scrum that is where I will go into details (though I will try to mention others here and there). 

There is a vast multitude of SCM and version control systems available today. Many of them will claim to be Agile. Many of these will cite specific features or points of interest like code reviews and continuous integration. Often these are features the tools had before claiming to be agile but are now being marketed as 'Agile' capabilities retroactively. With PureCM what we will show is how you can follow the principles of the Agile Manifesto first and then second how nicely PureCM adapts to Scrum and how this is a ground up effort that makes PureCM truly Agile and Scrum compatible and not just offering rebranded legacy features here and there and calling it agile.

So we've properly started the series - I look forward to continuing our journey! 


 

New Blog Series: Agile Version Control

A few months ago we've run our first blog series, publishing about a dozen blogs on how common software challenges can be tackled effectively. The SDC series was born. We've had some great conversations with readers and customers as result of that blog series, so I'm glad to announce the next series that will start soon:

Agile Version Control


Hmm. Agile in 2011? Ten years after the agile manifesto was published? Of course! These 10 years have brought many rich experiences working with agile and other methodologies in software development. We still get numerous rich and insightful discussions with our customers about what could be done better. And at the same time, we're also confronted with "how to" questions from teams getting started with agile: How to make version control or software configuration management (SCM) agile?

It's seems to be a small part of the development process only, and yet getting it right is a key success factor to any agile initiative. So join our upcoming agile version control series to get in touch with best practices and let me know about your thoughts.

 

PureCM can now handle thousands of open features

One change which you will probably not notice after installing 2010/2 is that submitted changesets are automatically merged to features in the background. If you work in a larger team with many developers using features then you will soon see the massive performance improvements.

Prior to 2010/2 when you submit a changeset, this changeset is automatically merged to all features as part of the submit. This means that you are waiting around for this to finish until you can carry on working. Plus the server is locked so other users cannot submit until all the automatic merges are complete. This is not a problem if you have 5-10 open features, but in a team of 100+ developers this can turn into minutes.

With 2010/2 after you submit a changeset it is not automatically merged to any features immediately. If you go to the Merging view you will see that the changeset appears under ‘In Progress Changesets’ for each feature.

 

The server will then merge these in-progress changesets when it is not busy. So you are not waiting for the merges to complete and the server does not prevent other developers from submitting changesets.

Another neat feature with 2010/2 is that you can move unmerged changesets into the ‘In Progress’ state. So if you have hundreds of changesets to merge into a stream you can simply select all the pending changesets and select ‘Move to In Progress’. You can then carry on working while the server processes the changesets in the background.

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!

Summary

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

Summary

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