Configuration Management and Version Control

March 6, 2017
Managing all the content associated with projects can quickly get out of hand. But there are proven tools that can help make these problems a thing of the past.

Version control woes are still a real issue. Of course, control system integrators try to manage all the content associated with your projects, but sooner or later things can get out of hand and they end up in situations where they are spending a lot of time just finding, recovering or recreating work that has already been done. The good news is that a lot of proven and tested tools already exist that could easily make these problems a thing of past.

First, let's clarify a few things. This article will focus on configuration management; version control is only one part of this in the overall scheme. Configuration management is really about two things: managing change and improving the reliability of information. With a good configuration management system, there should be a complete picture of what changed, the reason for the change and who performed it. The figure here depicts this level of traceability from both a top down and a bottom up view.

There are two components to the configuration management system: version control and task/issue management. Before we discuss either of those, it is important to note that the first requirement is to organize all project information—otherwise it could easily become a “garbage in and garbage out” situation.

Version control

If a system integrator is used to doing things manually and saving files and other information with a myriad of prefixes, the jargon and ways of using the version control system can be daunting. It is a good idea for system integrators to introduce these concepts step by step so they are not overwhelming.

In the first phase, they could introduce version controls as a backup system. The goal in this phase is to provide a standard way of storing all project data under version control and introduction of the version control paradigm. In this phase, version control is used mostly for sync and backup capability and also its ability to roll back any file to its previous known state. In version control lingo, we would mostly be working with commit and push/pull scenarios.

This presents a nice segue to discuss the tools parts of the version control. There are a lot of options here (Git, SVN, TFS, etc.). What’s great is that most of these options are open source and free. In the software development world, Git is currently the most popular version control system. This is for good reason, since it has a great feature set that can make a developer’s life very easy. You can refer to the Git documentation for greater detail on the topic, but here is an overview of how it works: Each user clones the project repository on their local machine. They make changes to their local copy and commit locally first (Git keeps track of all the commits). Once the user is confident in all the changes that have been made, they can then push it to the server for the changes to be available for everyone else to pull.

Git is a type of distributed version control system because of the “local commit” part. Most of the Git operations are local (hence quite fast) and it keeps the whole history chain local, so everyone has the full copy of the history and the latest data. The distributed system is not without its cons, though, if you are dealing with large repositories and binary files. In other words, keeping all that history local can easily get out of hand.

In such a scenario, a centralized version control system (like SVN or TFS) might be better suited. The major difference is that most of the operations are remote. When you commit, you send files to the server directly so there is no “local commit” and only the server keeps the whole history. It also allows part of the repository to be checked out, which makes the initial clone or checkout faster if you want to work on only a small portion.

The transition to the version control system can be made easier by adding windows shell integration tools (like TortoiseSVN or TortoiseGit), which make all the operations available on a right click of files/folders. There are several easy ways to set up the server side of things or one of the cloud-hosted solutions might also be available to help make life easy.

One other thing to consider for the tool selection is that although the capability to “diff” and view changes exists for most text content (and even Microsoft Word and Excel), this feature is not available for proprietary PLC, SCADA binary files. There are, however, some specialized version control tools (like versiondog) that provide some of those features. The workaround for other tools is to manually “diff” the two versions using PLC compare tools.

At this point, it might seem like a lot of work to keep the backup of the files. If all we were looking for were the backup-type functionality, then tools like SharePoint, OneDrive or Dropbox would suffice, especially if the content is mostly documents. But remember: The goal is to have both top-down and bottom-up visibility, which is what a true version control solution will help to achieve.

Task/issue management

After that discussion on the tools, let’s get back to the second phase of the implementation plan. Here, we will introduce task/issue management. Just as with version control, there are many choices available (JIRA, TFS, Redmine, etc.). The key features to look for would be version control integration and flexibility in managing tasks and issues. Both JIRA and TFS are quite popular and widely used. In this phase, the focus is on dividing work into tasks, assigning it to the user and keeping track.

Once the tasks are easily managed and the content easily versioned, here are some advanced concepts that can be put in place during the third and final phase. On the version control side, start using the concept of branching and tagging for creating development sandboxes and for marking releases. On the task management side, start linking the tasks with the commits so they are easily able to trace what changes were made for each task.

At the end of this phase, everyone should have good visibility and control on the process and content, which allows for greater and more efficient tracking of the whole project. If it is important to draw more efficiency out of the process, now would be a good time to start looking toward agile project management techniques. The good news is that with the above implementation, the legwork to apply these techniques will have already been done.

For more information, you can find the complete series on configuration management from the Control System Integrators Association (CSIA).

Andy Robinson and Nishant Saini are both information solutions consultants at Avid Solutions Inc., a certified member of the Control System Integrators Association (CSIA). For more information about Avid Solutions, visit its profile on the Industrial Automation Exchange.