Name of the blog

Short description of the blog

Gemini issue integration available now

We have just released the latest plugin for PureCM, which links changesets to issues in the Gemini issue tracking tool. Why Gemini? We've had various customers asking how they could best use PureCM with a web front end for their helpdesk team. As we've been focusing on developing a tight release planning/configuration management integration with the upcoming 2010-1 release, reaching to teams outside core development is currently better supported with 3rd party solutions such as Gemini. This tool is particularly well suited to integrate with PureCM given its simple yet flexible user interface. 

How does it work?

The main imperative when developing the Gemini bridge has been to keep it simple. Linking PureCM changesets to Gemini issues can be done simply by adding a 'GEM' reference number to the changeset description - that's it. There are some screenshots in our knowledge base that show you how this will look. What might be more important is actually the way the bridge is published: as open source. Yes, that's right. It's the first time we do so and we hope that you'll embrace this approach.

Why is the plugin open source?

This is a very simple integration, which requires minimal setup and virtually no training for developers. On the upside, this gives you a quick and easy integration with a web frontend to add powerful helpdesk functionality to PureCM. On the downside, the plugin doesn't include sophisticated checks, e.g. to make sure you avoid typos when adding the Gemini issue number. By publishing the solution open source, you can decide whether this fits your bill or whether you'd like to add some tweaks.

Furthermore, keeping the integration so simple also makes it very easy to use it with other issue tracking tools. You can get the plugin and customise it to work with your existing solution, getting a head start with the now available and fully commented Gemini bridge.

>> Download the Gemini bridge here


So where do we go from here?

As you might have guessed, this is but a first step. This bridge is great for a no-frills integration with Gemini, especially when you simply want to keep track of what has been submitted against a specific issue. However, with the new release planning functionality in PureCM 2010-1, we'll be able to look at a much tighter integration with Gemini. Think scheduling in Gemini that is reflected in PureCM. Think getting real-time updates on project status regardless of the tool you're currently working in. Having development and non-development teams collaborate along the development lifecycle based on the same up to date information, but using the frontend (or tool) that is most natural to them.

Make sure to revisit this blog - we'll keep you up to date on progress!


The PureCM GUI Views: Part 2

Well, this time the title might be slightly misleading. It should rather say something like ‘The PureCM GUI Views: Part 2 – kind of...’, as I’ll not talk about the PureCM GUI client itself, but about the GUI most developers face on a daily, well most probably even on a constant, basis: their IDE.

Whether it’s Visual Studio, Eclipse or any other solution, flicking between tools isn’t just a hassle, it might even lead to (manual) workarounds that potentially affect product quality. With today’s multi-screen infrastructure and powerful integrations, arranging the information you need has become much more flexible and comfortable. We were obviously delighted to see Microsoft adding a proper API to Visual Studio 2005+, allowing us to provide an enhanced plugin, e.g. to suppor custom panes that any developer can arrange the way he wants.

So something that starts off as being better ergonomically might in fact have implications for your productivity and quality of work. Being able to see your current checkouts and group them into one or more changesets clearly helps to structure your work without the need to use ALT+TAB all the time. We’re not alone with this view, as Adrian Bridgwater at ZDNet UK has also picked up on the topic in his app dev blog. And there are also Eclipse enhancements scheduled for PureCM 2010-1.

By the way, the PureCM 2009-2c release that has become available last week includes some enhancements to make the annotated file history work with the Visual Studio enhanced plugin. This might prove a welcome feature, especially when chasing down bugs in your projects. Know who’s last changed a line, when and why.

You can grab the release from our download section; and if you’re not familiar with our these features yet, why not have a look at our enhanced VS plugin online demo?

Welcome to BlogEngine.NET 1.6.0

If you see this post it means that BlogEngine.NET 1.6.0 is running and the hard part of creating your own blog is done. There is only a few things left to do.

Write Permissions

To be able to log in to the blog and writing posts, you need to enable write permissions on the App_Data folder. If you’re blog is hosted at a hosting provider, you can either log into your account’s admin page or call the support. You need write permissions on the App_Data folder because all posts, comments, and blog attachments are saved as XML files and placed in the App_Data folder. 

If you wish to use a database to to store your blog data, we still encourage you to enable this write access for an images you may wish to store for your blog posts.  If you are interested in using Microsoft SQL Server, MySQL, VistaDB, or other databases, please see the BlogEngine wiki to get started.


When you've got write permissions to the App_Data folder, you need to change the username and password. Find the sign-in link located either at the bottom or top of the page depending on your current theme and click it. Now enter "admin" in both the username and password fields and click the button. You will now see an admin menu appear. It has a link to the "Users" admin page. From there you can change the username and password.  Passwords are hashed by default so if you lose your password, please see the BlogEngine wiki for information on recovery.

Configuration and Profile

Now that you have your blog secured, take a look through the settings and give your new blog a title.  BlogEngine.NET 1.4 is set up to take full advantage of of many semantic formats and technologies such as FOAF, SIOC and APML. It means that the content stored in your BlogEngine.NET installation will be fully portable and auto-discoverable.  Be sure to fill in your author profile to take better advantage of this.

Themes and Widgets

One last thing to consider is customizing the look of your blog.  We have a few themes available right out of the box including two fully setup to use our new widget framework.  The widget framework allows drop and drag placement on your side bar as well as editing and configuration right in the widget while you are logged in.  Be sure to check out our home page for more theme choices and downloadable widgets to add to your blog.

On the web

You can find BlogEngine.NET on the official website. Here you'll find tutorials, documentation, tips and tricks and much more. The ongoing development of BlogEngine.NET can be followed at CodePlex where the daily builds will be published for anyone to download.

Good luck and happy writing.

The BlogEngine.NET team

PureCM to support SQL databases

PureCM currently uses its own database which has developed over the years to become a robust, secure, and flexible solution for most customer needs. There has been demand, however, from customers (existing and potential) to provide the capability to work with more established and well known SQL databases. We plan to have the option for customers to select from many of the most popular variants, but initially we will develop a SQLite solution followed shortly by SQL Server.

SQLite will become the default database type, but the option for PureCM's native database will still be there. So for existing customers there is no need to change to using SQL if they don't want to. A Migration facility will be available to convert existing databases though.

Advantages of using SQL databases include ..

Familiarity - Administrators already have the knowledge for administering sql databases.
Backup - Trusted and established methods for backup of data.
Interface tools - Easier access to data without use of PureCM.

We're implementing SQLite initialy due to its global cross-platform availability, ease of use (Zero-Configuration) and cost (Its free). This makes a good starting point from which expand.

We see SQL Server as a high priority for the large number of Microsoft Visual Studio development teams. As well as being able to integrate the PureCM client with Visual Studio, using Microsoft's SQL Server at the backend makes a lot of sense.

Additional database engines available to UNIX/Linux are also on the radar and will follow after SQL Server. More on this later.

In terms of usability, there should be no change as far as the PureCM user is concerned. The tool will look and feel exactly the same, with no performance disadvantages.

We aim to support SQLite Databases in the 2010-1 release of PureCM.

How Often Do You Check Your Code In

Any code you write should be submitted within 24 hours. If you have made changes to code on any of your projects which has not been submitted in the last day then you need to read this.

Back to Basics


Let’s recap on why it is importance to check code in frequently:

·        Your changes are safe – so they won’t be lost if your laptop breaks.

·        Other people can take over your work – if you have to go on emergency leave.

·        You can rollback changesets – if you want to revert your recent changes.

·        You can identify bugs quicker – isolating a bug to a small change makes it easier to fix.

·        Each changeset describes the code – it is much easier for someone to work out what a piece of code is designed to do if it was submitted in a small self-contained changeset.

I hope we all agree on most (if not all) of these points, otherwise you question why you are using version control at all.

Submitting Unfinished Code


One of the golden rules of version control is that you don’t submit unfinished code. You can work in your private workspace to develop and test your code in isolation. When you are finished you submit your changes to the Development Stream.

So if it takes a week to develop and test my changes, I can only submit my changes when it is finished.

Wait. Let’s rephrase that slightly.

So if it takes a week to develop and test my changes, I can only submit my changes to the development stream when it is finished.

You can therefore create a feature stream for your changes. In the feature stream you can submit as often as you want. When you have finished your changes you can merge them all back into the development stream.

Feature Streams are Easy


I bet there are some people who stopped reading this as soon as I mentioned the term ‘feature stream’ – development is complicated enough without having feature streams. But let’s break this down and look at why feature streams are perceived as complicated:

·        I’m only going to be working on this change for a week. I can’t be bothered setting up a new stream and everything else.

·        I don’t want the complexity of merging changes to and from the feature stream.

Now let’s look at these 2 points in turn.

Create a Feature Stream in 10 Seconds


In the PureCM GUI go to the Repository View. In the folder containing the development stream(s) for this project create a new stream folder and call it ‘Stephen’s Features’.



Now right-click the development stream and select ‘Create Stream From’. Call the stream ‘Feature A’ and put it in the new stream folder.


That is it! For the next feature you won’t even need to do the first step.

You can now right-click a workspace for the development stream and select ‘All Tasks | Rebase Workspace’. This will change your workspace to use your new feature stream. Since the files in the feature stream are currently identical to the files in the development stream the rebase will take no time at all.

Automate Merging to a Feature Stream


I lied. It might take 20 seconds to create your first feature stream.

There is another step you should perform after creating the feature stream folder. Right-click the ‘Stephen’s Features’ folder, select Properties and go to the ‘Merge Paths’ page. Uncheck the ‘Inherit Merge Path properties from parent’ checkbox.

Note that this functionality is only available with the Professional Edition. You can use feature streams in the Standard Edition but merging into the feature stream will have to be a manual process. If you are using the Professional Edition then you need to enable the ‘Professional Policies | General | Merge Path Administration’ and ‘Professional Policies | General | Enable Merge Paths’ policies if you have not already done so.


OK. I know this dialog can look a bit scary. But just go with me and select the checkboxes as shown above. What this mean is that whenever a changeset is submitted in the development stream it will be applied to the feature stream.

Feature Streams in Action


Now the feature streams are all setup, let’s see them in action. In the Repository View delete the old ‘Feature A’ stream (because it was created before we updated the stream folder permissions). Create a ‘Feature B’ stream and rebase your workspace to it.

Now pretend someone else is working on the development stream by creating a workspace for the development stream and submitting a simple changeset. If you now go back to the Feature B workspace you will see that the workspace is out of date and the Submitted Changesets shows the new changeset as outstanding.

Look familiar? The workspace is exactly the same as if you had been working in the development stream. You just need to update your workspace to get the new changes. So as you can see, in the general case where the files you are working on have not been changed by someone else, working in a feature stream is no different to working in the development stream.

Let’s see what happens if another developer changes a file which you have already changed in the feature stream...

Submit a change in the workspace for the feature stream. Remember that the big advantage with feature streams is that the change is not pushed to the server until you say. So this submit could just be a checkpoint of unfinished work.

Now go to the development workspace and submit a change to the same file. You will see that this submit succeeds. This is correct because changes in the feature stream should have no impact on developers working in the development stream.

If you look at the feature stream in the Repository View you will see that it has Pending Merges.

This is telling you that a change was submitted in the development stream which conflicts with changes in the feature stream. Right-click the pending merge changeset and select ‘Merge Change’. This will launch the Resolve Tool – exactly the same as if you had done an update to latest in the development workspace which caused conflicts.

In other words, the only difference between working in the feature stream and working in the development stream is that you need to merge any changesets with conflicts.

You do not even have to go to the Repository View to view your Pending Merges. Within a workspace you can use the menu ‘Workspace | Show Server Files Tab’ to launch a window showing the Pending Merges.

The final piece of the jigsaw is how the submitted changes in the feature stream are pushed to the development stream. Let’s demonstrate this by submitting another changeset in the feature stream workspace. So we now have 2 changes submitted in the feature stream and we want to merge them back to the development stream as a single changeset.

Go back to the Repository View, right-click the development stream and select ‘Merge Changes’. Select the feature stream as the source stream. You will see that only the changesets submitted in the feature stream are listed. Check all of the changesets and press Finish. Don’t choose for PureCM to automatically merge the changesets, because this will merge each changeset individually.

PureCM will then launch the Resolve Tool showing you all of the changes you have made and allowing you to change the description. When you press ‘Save’ the changeset is merged back into the development stream.

So as you can see. The process of pushing the feature stream changes back to the development stream is similar to the process of submitting a changeset. The only difference is that you have the slight overhead of using the Merge Wizard.

Remember that there cannot be conflicts when merging your changes back into the development stream, because you have already merged all the development stream changes into your feature stream. The merge will always be trivial.

Are Feature Streams Worth It?


As a developer, if you value the ability to checkpoint your code often so you can revert back to it, then yes I think the small overhead with feature streams will be well worth while.

If not then you might decide that you are happy working without them and only submitting every week or so. But if the day comes when you end up loosing a week’s work because your laptop breaks or your release is late because a developers had to take emergency leave then you might wish that you had been using feature streams.

Wish List


PureCM handles features streams well, but there is plenty of room for improvement. Thankfully most (if not all) of these new features will make it into the 2010/1 release (April 2010).

·        Simplify pushing the changes back into the development stream. There should be a toolbar button on the workspace which merges all the changes back into the development stream.

·        Automatically resolve pending merges when updating the feature stream workspace. This functionality would then be identical to when working on the development stream.

·        Distinguish between feature streams and other streams. For example, when displaying the submitted changesets the release streams are very relevant while the feature streams are not.

About SCM Essentials (and Resources)

We often get in contact with people evaluating an SCM tool for the first time. Most of the time, they work in a small team that has grown. So all of a sudden, the “have you finished working on file A?” or “which folder was the latest version in again?” questions don’t work the way they did before. Things get chaotic and errors start to creep in. Valuable time gets lost. So they start looking around for a tool to help them address these issues.

However, implementing SCM is just as much about how to define and set up the processes, as well as addressing resistance to change. Process might be a big word, but questions like “do I need to support multiple releases? If yes, how?” or “how and how often do I create builds and keep track of them?” have to be addressed even for the most basic implementation. This isn’t a bad thing at all, as going through these issues will already pay dividends.

Some resources to get you started

Of course, you can’t spend all your time on researching either. This is where some input in the form of best practices comes in very handy. CM Crossroads, the configuration management portal, has just put together a great set of articles to cover just that. It’s called “SCM Essentials for Small Teams” and gives an excellent overview about common issues and best practices when implementing SCM.

A somewhat more specific approach covering how to enhance responsiveness to change recently appeared on Dr. Dobb’s:  “Everything Changes: How Dev Managers Can Cope With Ever-Shifting Requirements”. It’s been written by Mike Shepherd, who just happens to be a colleague of mine at PureCM. His article covers key best practices that help you dealing with an ever faster rate of change.

That said, responsiveness to change automatically links to Agile, so you might also be interested to learn more about how to support your agile initiative with a sound SCM foundation. There’s a white paper on our website that sheds some light on the link between SCM and agile: "Agile SCM Adoption - 10 Essential Practices".

I hope you can benefit from these resources – enjoy reading!


P.S. Feel free to get back to me directly; I’m happy to discuss.

The PureCM GUI Views: Part 1

Yes, there are many powerful PureCM plugins into Visual Studio, Eclipse or other tools with SCC interface; even more so with the latest 2009-2 release. But if you want to access PureCM’s full feature set or work with the same interface across platforms, the GUI client is the place to be.

This is why I’ll shed some light on the PureCM GUI, starting with this introduction about its default views. However, I plan to do more than one blog on the topic, so if you’d like to read about a specific GUI issue, just let me know.

So what can you see in each of the PureCM views? Which view do I want to use as an administrator, development manager or developer? Let’s start this GUI introduction based on the PureCM Standard edition to cover the three default views available to any PureCM user.

Top level

The PureCM Administration view is the most encompassing view, listing all your server connections, available repositories and workspaces. This is the only view where you can also perform administrative tasks such as creating repositories and managing users, permissions or licenses.


Repository level

You’ll have to select the repository you want to work with, say the “Apps” repository (click this button  or use CTRL+R), which will set the context for the following views. The Repository view will then let you browse the repository's project streams and create branches or snapshots on the server side. Development managers can also access the project audit trail, see current checkouts, compare streams/folders and perform merges between streams (there's an online demo on how to organise your repository).

The Workspaces view lists all local workspaces based on any project stream present in the selected repository; in our example the workspaces for Project 1 Development and Project 2 Development. Release managers would see workspaces to pull the latest project version to their build machines, e.g. to perform continuous integration.

You can perform basic workspace operations from this view, but its main purpose it to give you quick access to the one you want to work with. This actually brings us to the final view.

Project level workspace view

This is the view most developers will spend 90% of their time working against a specific code line. To get there, simply select the workspace you want to work with. The PureCM GUI then automatically drills down to the workspace content, showing its files and folders, as well as grouping your changes into changesets.

The workspace is a private sandbox to work on a specific project. Here, you can checkout files, access file history and submit finished changes. You can get specific file revisions or synchronise your workspace to a particular point in time, e.g. to hunt down bugs. But you’ll also see who else is working on a file and what changes they have submitted to the server, so you can update your workspace to get the latest project status. There's also an online demo about the workspace features.

If you're in a hurry, you can also access a specific workspace via the combo box in the top right corner of the PureCM GUI at any times. Simple.


I hope that I’ve been able to show you that each view facilitates work for a specific user group. If you’re and administrator ...well, you know where. If you’re a development manager looking after branching and merging, creating build and release snapshots, or setting up new projects from scratch, the Repository view is yours. And as a developer, select a workspace from the Workspaces list and get a focused view on the specific project you want to work on.

But is the Administration view the same for administrators and developers? Or is there a way to customise available actions, visible repositories and ongoing changes? Yes, there is – and that’s what I’ll cover with my next blog.


Top 5 Hidden Tips for Developers

Browsing through the PureCM User Guide or looking on our website you will soon come across a list of PureCM’s big features – the features that sell PureCM. However, it is often the smaller day-to-day features which can make you love a tool or hate it. Here is a list of 5 ‘hidden’ features in PureCM which I find useful.

Opening Explorer for a Workspace Folder

I use read-only workspaces for developing because I like to constantly keep track of what files I am changing. This works great most of the time because I am using Visual Studio with the PureCM Enhanced Client, but sometimes I need to work on a file not included in the solution.

Previously I had to find the file in the GUI workspace, check it out, find the file in Explorer and open it. With the Enhanced Client I can now check the file out within Visual Studio using the Workspace Explorer View. This is cool, but I still have the pain of opening Explorer and finding my workspace, because the file cannot be edited in Visual Studio.

Then I came across the ‘Explore’ menu on a folder in the Workspace View. This will open Windows Explorer and take you straight to the selected folder.

Now I have started getting really lazy, to the point where if I need to go to a workspace folder in Explorer I launch the GUI just to use this menu. I find this quicker than having to traverse down in Explorer to find the workspace. I also use the ‘All Tasks | Open command prompt here’ menu to a lesser degree.

Synchronising a Workspace Back to a Changeset

When testing your software you find a bug and have no idea how and when it was introduced. You know it was working when you did your last round of testing 6 weeks ago , but somebody’s broken it. The first thing I do is isolate the changeset which introduced the bug – especially if it is a non-trivial change which someone else has made.

So in my workspace I select ‘All Tasks | Synchronise’ and select a changeset which was submitted 3 weeks ago. I then build it and see if the bug had been introduced. If the bug does not exist then I select a changeset submitted 1 and a half weeks ago. I carry on with this binary chop until I find the changeset which introduced the bug.

Fixing a bug when you can see how it was introduced is a lot easier than fixing a bug without any context. And if the bug still looks difficult to fix – at least you know who to blame and ask for help!

Moving Changes to Another Workspace

In the last place I worked I remember regularly creating a zip of the files I had changed so I could give them to another developer to either take over the work or test that his changes were compatible with mine. Now with PureCM I can simply shelve my changes and the other developer can unshelve them into his workspace. This is easier and less error prone – because my changes will not clobber his changes.

Another use for this which I find just as useful is the ability to unshelve changes into another one of my workspaces. We do a lot of multi-platform development so we have various build machines for the different platforms. We also have various test machines for the different platforms.

So if a customer reports a bug on a specific platform we try and replicate the problem on one of the test machines. Having reproduced the problem we debug it on the test machine. If the fix is trivial we make the changes on the test machine, check the bug is fixed and submit it.

If the fix is non-trivial then I would rather be working on my own machine. I have Visual Studio setup the way I like it with various third-party plugins which I find useful. So I make the changes on my machine and then unshelve them into the test workspace. If the bug is fixed then I can submit the changes. Otherwise I can carry on working on my machine.

Opening Files Within the PureCM GUI

Within the GUI or Visual Studio Workspace View you can right-click a file and select ‘All Tasks | Open with Default Editor’. This will open the file with whatever application is associated with the file in Windows. A useful shortcut for this is to hold down ‘Control’ and double-click.

You can even go one step further and set this to be the default behaviour when you open a file. In the GUI open the ‘Options | File’ page. Open the properties for the relevant file type (e.g. ‘text/*’), navigate to the ‘Editors’ page and move ‘Default Application’ to the top of the list.

‘Line by Line’ History

When debugging you come across a line of code which seems counterintuitive – but has obviously been put there for a reason. Why has it been programmed in this way? As usual there are no comments to provide any insights.

You can right-click the file and select ‘Show Annotated History’. Find the relevant line and select ‘Launch Changeset Dialog’.

Now I can have the changeset description and related files to help me determine why it has been programmed in this way. If it is still not clear then I know who to ask for help.

Wish List

I thought I’d also use this opportunity to outline some of the smaller improvements I am proposing to go into the 2010/1 release. If you agree with any of these suggestions then please add a comment to say so. Experience has shown that an enhancement raised by a customer carries much more weight than an enhancement raised by one of the developers.

Ability to navigate to my workspace within Windows Explorer

I’ve started using the Explorer Client and am using it more than I expected. I thought it would be one of those features which people without Visual Studio or Eclipse would use. But I am finding there are many situations where I want to checkout a file outside of my IDE.

If the Explorer Client had a sub-menu which listed all my workspaces and navigated me to the selected workspace then I would use it all the time.

‘Open Command Prompt Here’ on Linux

Why is the ‘Open Command Prompt Here’ menu only available on Windows? Developing on Linux I use a terminal much more than I do a command prompt on Windows.

Synchronising my workspace within Visual Studio

You can already synchronise your workspace within Visual Studio by using the Workspace View. But it would be even better if there was a toolbar button to do this. When working in Visual Studio I typically only use the Changesets View along with the Solution Explorer. If I can avoid hving to switch to the Workspace View then this is better.

Feedback on what changeset the workspace is synchronised to

After synchronising my workspace back to a changeset there is no way of telling which changeset it is synchronised to. I have a terrible memory so I normally end up writing the changesets down and crossing them off as I go through the binary chop.

I was thinking the ‘Submitted Changesets’ could show changesets which are not synchronised with a warning sign, the same way that changesets which have not been ‘Updated to Latest’ appear.

There is also no indication on the workspace that it is not up-to-date. It makes sense to show the clock icon, the same as if someone had submitted a changeset but you have not ‘Updated to Latest’.

PureCM 2009-2 beta available now

We have had an encouraging amount of feedback for the public betas we published for our last 2009-1 release. So of course we’re going to do it again for the upcoming 2009-2 release!You might have already read about some of the enhancements that you will get with PureCM 2009-2; if not, here are the bigger chunks:
  • Enhanced Visual Studio 2005/2008 integration
  • New Windows Explorer plugin
  • Bulk merge and rollbacks directly on the server

With this current beta, you will now be able to test the first two enhancements yourself. Both the enhanced VS integration and the Explorer plugin are included in the PureCM client installer to keep installation as easy as possible. If you want to select them individually, simply choose the “Standard” installation.

>> Download the PureCM 2009-2 beta [link removed]

What can I expect from these enhancements?

Tim has covered the new Visual Studio features with his blog in detail, but we’re really quite excited about it so here they are again:

  • No binding of solutions needed. This makes it much easier to add a new solution to PureCM or to get a source controlled solution from PureCM.
  • Embedded PureCM views. You can now display both the “Workspace explorer view” and the “Workspace changeset view” known from the PureCM GUI to manage your changes; plus you will get a PureCM toolbar to easily access the most common operations.
  • Perform advanced workspace operations. Embedding the workspace explorer view allows you to access operations such as rebase, workspace merge (merging changes from other streams into your workspace), shelve and unshelve etc. etc. – just have a go with the “All tasks” operations from the context menu  ;-)
  • Organise checkouts using changesets. Create one or more changesets to group your ongoing changes/checkouts directly in Visual Studio.
True, not everybody is working with Visual Studio, and we have had quite a number of requests for a basic integration into Windows Explorer. This plugin is particularly useful when working with many different tools, but without having the need to access advanced GUI features. This is what you get with this beta:
  • Get files from PureCM (i.e. creating a workspace)
  • Add files to a folder/workspace under version control
  • Checkout files and Submit changes
  • “Check consistency” to automatically detect changes when editing files without checkout
  • Support for namespace changes
  • Access file history
  • Visualisation  to show file differences and resolve conflicts (should they occur)
There are some features excluded from this beta which will definitely make it into the final release:
  • Add folders and files to version control as a new project/stream
  • Status icons for files under source control

So much for theory. To get a hands-on experience, download the beta installers, run them... and let us know what you think. Any feedback is highly appreciated.

>> Get the PureCM 2009-2 beta [link removed]

To send us your feedback, simply comment this blog or send an email to Have fun!

The Old Friend Visual Studio

Everyday while I sit at my desk I have two computer monitors looking back at me, one shows PureCM and the other shows Visual Studio. Most of my time is spent writing code or fixing bugs and for this there are few better tools that Visual Studio. For understanding the code I'm working on and keeping track of all of the changes going into our tool nothing in my opinion beats the PureCM Client. Both tools are vital for daily work but wouldn't it be nice if it could all be done from one tool?

What about SCC integration?

When we talk to customers we find that most developers do not want to work with a separate  client outside of their development environment. However the current way PureCM integrated with Visual Studio has a lot of shortcomings.

PureCM uses the SCC library provided by Microsoft to allow Visual Studio access to source control. The main advantage of this is that it provides a common interface into many different programs such as XML Spy. The huge disadvantage however is that it was designed strictly by Microsoft to fit with source control providers that operate with outdated concepts. The main problem this causes with PureCM is that Visual Studio works on a single file level and cannot cope easily with the concept of workspaces and changesets. This means that most of the core functions you wish to use in your daily work are not performed as well as we would like as we can never perform exactly what Visual Studio is asking us to do.

A second main problem is how ridged the bindings have to be between your solution and PureCM. The pattern of storing stream information in the solution file means every time you make a new stream you have to rebind this information. As the use of streams grows this becomes less and less practical as often you want to make a quick stream to implement a feature away from the main development stream and are left with the overhead of having to rebind every time.

The third main problem with the SCC is that we cannot implement any more functionality inside it. When I first joined the team at PureCM over four years ago we had a good product that fulfilled all of your main source control requirements. Since then the PureCM client has exploded with new features and evolved to make your work flow much simpler. However the Visual Studio integration has remained pretty much the same.

The Future

So here is some good news. From 2009-2 you will have access to a purpose built plug-in specifically designed for PureCM to integrate seamlessly into Visual Studio. This is very exciting for us as we can finally provide a tool that will make PureCM simpler to use. Our overall aim is to provide your workspace perspective from inside Visual Studio. Not everything will make the 2009-2 release but here are a few of the main features.

No more binding solutions to streams. The new plug-in will now work on a workspace level. It knows if your solution is inside a workspace and uses this workspace to access the server.

Simple interface to add your solution to PureCM. If you have a workspace already just copy your files inside and press the 'Add to PureCM' button. If you don't have a stream yet, the same button will give you a simple two page wizard that will create you a stream on the server, a workspace on your client and add your files in a single operation.

Simple way to get your solutions. Get from PureCM now offers the familiar workspace create wizard, but will let you select which solution you wish to use on the server before you create your private workspace. This will then create a workspace with the solution in the root folder.

PureCM toolbar. Now all of your common operations will be accessible from a toolbar inside Visual Studio.

New embedded panel windows. Now you can open up tabs inside visual studio to make it like the PureCM workspace perspective. These include the changesets tab to view and manage the changesets in your workspace. The Explorer tab to allow you to see and manage files from their structure on disk. And also the event log so you can keep track of what is happening.

The best way to understand these new features is to try them yourself. That’s why you will soon find a beta of the new PureCM release ready for download, including the VS integration. Have fun playing around with it and let us know what you think!

Note that Microsoft only supports custom 3rd party tool integrations for VS 2005 or newer. Users of older VS versions can obviously still use the SCC integration to integrate PureCM.