Having used the PureCM Visual Studio Client for a couple of years I got a real shock when I had to do some work in Xcode. Creating a read-only workspace and checking out the files manually sounded like way too much overhead. So I created a writable workspace and ran check consistency when I needed to submit. This worked ok, but I really missed the way the PureCM Visual Studio client tracks which files I am editing. So when I got my hands on our 2011/2 beta the first thing I wanted to try was the workspace monitor.

If you flag a workspace as monitored, then PureCM will keep track of when files are added, edited or deleted and automatically check them out. If I leave my PureCM GUI open on the desktop, it is updated immediately as I edit files in Xcode or any other editor. So I can keep track of what files have changed without running the consistency checker every 5 minutes.

When I ran multiple PureCM clients, I was really impressed with how well they synchronized with each other. When I perform a submit in the PureCM GUI, the Explorer and Visual Studio clients will refresh immediately. In particular the Explorer client becomes a lot more useful. I didn’t use this much before because the icons were always needed to be refreshed but I have found I am using it more and more with the new release.

This is just one of the new features in the 2011/2 release. I’ll keep you posted with other new features over the next few weeks. One of the things I am most excited about is the performance – submitting and updating seem to be lightning quick. We are in the process of comparing the times with the other tools on the market. It is looking like 2011/2 will make PureCM the fastest version control tool on the market.

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!

Good news for the many software developers looking to upgrade from Subversion to a more robust change management tool. PureCM now features a Subversion importer that will import an SVN trunk with full history.

Anyone looking to do an evaluation of PureCM will now be able to quickly and easily import real data from an existing SVN repo into PureCM in order to get the best possible test drive of the system in the least amount of time. This will be a huge benefit to people who ask the question, "but how will my projects look in PureCM"? Now you can tell and with minimal effort since the import is a point and click process.

Customers looking to switch off Subversion will also be able keep their old historical data by transferring into PureCM which provides the key advantage of being able to get started with PureCM while retaining your old data. Perhaps a bigger benefit is now you can leverage pre-existing IT infrastructure to properly backup this business critical data by hosting PureCM against SQL Server.

Importing data is an important part of what we do at PureCM. We recognize that many of our customers are switching to PureCM from something else. Importing data through a script or an API is always a possibility but not the quickest and easiest solution and for that reason PureCM has put a lot of effort into providing importers for as many SCM tools as possible, such as Visual SourceSafe, CVS and Perforce; and now Subversion joins the list.

Visit our knowledge base to get a step-by-step guide about how to use the SVN importer.

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.

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.

Summary

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

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:

http://www.purecm.com/download_file.php?type=white_paper&download_id=7

Over the last few years, we’ve seen a large number of development teams moving away from file-based version control tools. This is no surprise, as new tools on the market started to support the concept of changesets and atomic commits.

Why grouping changes makes sense

So instead of checking in every single file, developers were now able to group their changes in changesets. This gives teams a much better project history, as each changeset reflects a task. Also, changesets are applied to the repository database atomically, i.e. completely or not at all, thus protecting database integrity.

Distributed version control systems and, of course, PureCM also allow developers to create, checkpoint or rollback changesets without needing a connection to a central server. But task-driven development doesn’t stop there. You’d want to link your changeset to its original change request or defect in your issue tracking tool.

Easy: add the issue reference as a comment, or link it to your changeset using a 3rd party plugin. But what if you’re working on parallel versions, where changesets get merged across project branches? Do you still know to what versions your change has been applied to? Or how do you track your changes when implementing code reuse across projects?

How to keep track when working with parallel versions?

Typically, only your original changeset will be linked to the original issue, but it quickly becomes a manual and cumbersome process to find out into which releases, say, a particular bug fix has finally made it. This is where PureCM’s end-to-end focus on task-driven development comes in, providing a full picture with on a simple mouse click.

Watch the short 3 minute demo to learn how you can get full transparency between project branches and even when sharing components across multiple projects. Ah yes, here’s the link: http://www.purecm.com/file_downloader.php?type=video&download_id=8

I hope you like it!

With the 2010/1d release, Windows users will now have a choice between using SQLite or SQL Server for the PureCM server. We are currently beta testing the MySQL database for Linux and Mac users so this should become available in the next six months. This blog will help you decide whether to stick with SQLite or switch over to SQL Server. I will also look at the differences between running the server on Windows, Linux or Mac using SQLite.

If you are using the native database (pre 2010/1 release) then we recommend you upgrade to SQLite or SQL Server as soon as possible. Both of these databases have better performance than the native database and are more scalable – so it is a win-win. Details on how to upgrade can be found in the PureCM Knowledge Base.

SQL Server or SQLite

SQL Server has better management tools and scales better for large teams. So if you have over 30 developers using PureCM we definitely recommend you migrate to SQL Server. If you have over 10 developers then it will depend on the developer usage. If all of the developers are doing frequent submits, merges or workspace creations then SQL Server may give you a performance boost.

If you have less than 30 developers then you need to establish whether using SQL Server will be more expensive. If you already have a SQL Server license then great, otherwise you will need to work out how much this will cost. PureCM can be configured to work with SQL Server Express – but this will not work out of the box. We plan to support SQL Server Express properly in a future release.

If SQL Server is not expensive then you need to decide whether the scalability and management benefits of SQL Server outweigh the performance benefits of using SQLite.

I installed the PureCM Server on a test Windows machine running on the LAN. I got some performance statistics using SQL Server and SQLite when submitted and creating a workspace for about 10,000 files totalling about 1.2 GB of data.

As you can see SQLite is about twice as quick when submitting data but only about 20% quicker when creating a workspace.

Windows, Linux or Mac Server

If you have decided that SQLite is the best fit for you – then you might also want to consider which OS should host the PureCM Server. Here are some performance statistics when using the PureCM GUI on Windows 7 to submit and create a workspaces for servers running the different Operating Systems.

So the server OS made no difference for creating a workspace (database reads) but Ubuntu was significantly quicker (over 50%) when submitting the file adds (database writes) when compared to Windows.

Windows, Linux or Mac Clients

Finally you might be interested to know the performance differences between clients running PureCM. Here are the statistics when running the PureCM SQLite Server on a Windows Server 2005 machine over the LAN. This is using pcm (the PureCM command line client) with the same set of files (10,000 files totalling 1.2 GB of data).

As you can see, Mac and Linux are pretty much neck and neck – but Windows is significantly slower. But when you put it in context, taking just over 3 minutes to create a workspace with 10,000 files totalling about 1.2 GB of data is impressive. So regardless of which OS you choose I am confident PureCM’s performance will beat any other version control tool.

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.