Comparing concepts between ClearCase UCM and RTC


There seems to be some confusion about the differences and similarities between Rational ClearCase and Rational Team Concert.  Some of this is due to changes in terminology, and some of this is due to the different usage models and capabilities of the products.  This article seeks to clear up some of that confusion.

I include UCM as part of this discussion, since so many of our customers have deployed ClearCase with UCM.  If you are using ClearCase UCM integrated with ClearQuest, then I strongly suggest that you also read Comparing concepts between ClearQuest and RTC.

Basic Terminology

Let’s take a look at the differences between ClearCase UCM and Rational Team Concert (RTC).  ClearCase is a configuration management system. Customers may use it stand alone, or they may use the UCM functionality.  UCM forces users to create software Components, and then creates Baselines on those components. Files being modified are Checked Out, modified, and then Checked In within the context of a View, which is a work area for development.  Change Sets are built up with each of the individual changes made as part of an Activity.  These Change Sets are then shared with other team members through the Delivery of those Change Sets.  ClearCase stores it’s artifacts in a proprietary format, and stores all of it’s data in repositories called VOBs. Each VOB may contain one or more UCM Components. The individual VOBs can store artifacts in any directory structure that a user would like to use. ClearCase supports parallel development, and when there are conflicts between versions of the same file, these are resolved using Merges. In base ClearCase, VOBs may contain Branches, which are logical “splits” of the code to enable parallel development activities to take place in isolation. In UCM these Branches have some more formal constraints, and are referred to as UCM Streams. So a team member will Deliver his or her changes from their own working area, called a View, to a Stream.  Other team members will Rebase their Stream, and pick up changes made on the parent Stream. 

ClearCase has a concept of a Dynamic View, which is a workspace that changes without any user intervention, based on user configured settings. ClearCase also has the concept of a Snapshot View, which is a copy based workspace, associated with the state of the repository at a point in time. Snapshot Views are brought “current” by Updating the view. From either view type, Baselines and Change Sets may be Delivered from Stream to Stream, with any individual file Merges being detected by the system, and then resolved by the user. As Components get Change Sets applied to them, the individual Components will have Baselines (essentially a label across all artifacts within the Component or VOB) applied to them. A “master baseline” with a collection of Baselines across multiple Components is called a Composite Baseline.

In RTC SCM there are many of the same concepts, but there are some subtle changes. Jazz has a single repository, which stores its artifacts as REST-enabled resources. These resources are stored in a database. Jazz supports the use of many enterprise database technologies, including Oracle, DB2, and SQL Server. This is commonly referred to as the Jazz Repository. In Jazz, software is broken into software Components. These Components may contain artifacts in any type of directory structure, and parallel development is supported by use of Jazz Streams. Users working on Jazz Components will join a project, and will create their own Repository Workspace (which holds copies of all of their Change Sets), as well as a personal Sandbox work area on their local machine. As files are modified, the Jazz client will track those changes, and the user will Check In their changes. There is no concept of check out, although Jazz does support resource Locking. When a user sees changes in his or her Sandbox, they will Check In the changes, and relate them to a Change Set, which collects the individual changes and stores them in the Repository Workspace area. These Change Sets can then be Delivered to one or more Jazz Streams. Other team members will Accept changes to their Repository Workspace from this Stream, and pick up changes made on the parent Stream.

The user Sandbox, or Eclipse Workspace, can have its status checked at any time, with the interface indicating all potential outgoing Change Sets (work the user wants to Deliver), as well as incoming Change Sets (work done by other team members). Users are able to select Change Sets to either Deliver (sharing their Change Sets with the team), or Accept (applying Change Sets in the Stream to their own Repository Workspace and Sandbox), on an individual basis. Baselines of the Components can also be created, and a collection of Baselines across multiple Components is called a Snapshot. This should not be confused with a Snapshot View in ClearCase, as the concepts are completely different.

There are a number of subtle differences in the way that these systems work, and it gets reflected in how users will interact with these systems. In ClearCase, users are often encouraged to create Streams and Branches to isolate their work. Often customers will create multiple Views (workspaces), with one set of changes being done in each View. This is done so changes can be isolated from each other, and to ensure that no artificial dependencies are created between Change Sets. In Jazz, users are encouraged to perform one change at a time within their Sandbox (workspace). Users working on multiple changes have a choice, they will either create multiple Sandbox and Repository Workspaces, or they will Suspend work on one Change Set, before beginning on another one. This ability to Suspend work essentially takes all of the changes associated with a Change Set, and stores them in the Repository, so a user can Resume (or reapply) these changes at a later time. The Workspace is then returned to the state that it was in prior to the changes from the Change Set being applied. This helps cut down on the number of Workspaces that developers must keep track of.

When using ClearCase with ClearQuest and UCM, it is possible to associate a ClearQuest Record with a Change Set. This requires some configuration, and availability of both the ClearCase repositories (VOBs), and the CQ database. In Jazz/RTC, all of this information is in the same Repository, so a link is created between the Work Item and the Change Set. Since everything is REST-based, many different types of Jazz objects can be linked to each other, providing greater flexibility in the relationships between development artifacts.

ClearCase Concept Rough Jazz Equivalent What it does
Check Out/Check In Check In Commits changes to the repository
Activity Change Set Collects a set of file changes into a single package of changes, usually associated with a CQ Record/Work Item
VOB Jazz Repository Stores data under source control – single Jazz repository, multiple VOBs
Dynamic View n/a A virtual workspace whose contents are dynamic
View Storage Repository Workspace There isn’t a good equivalent for the repository workspace, but a view storage area on a view server comes close
Snapshot View Sandbox/Eclipse Workspace Copy-based workspace used for development activities
Updating Synchronizing/Accept Update of the user workspace, where changes from other team members are brought into the user’s personal work area
Deliver Deliver The promotion of a change set from the workspace to the stream, where it is shared with the larger team
Rebase Accept Changes made by other team members are brought into the user’s personal work stream
Reserved Check Out Locked Ability to “reserve” a resource, making sure that you are the only user who can modify the resource
Baseline Baseline A collection of files (configuration) within a component at some point in time
Composite Baseline Snapshot A collection of different components, and specific baselines from those components
UCM Process Templates (like Scrum) An out of the box process that defines record types/work items, and the relationships and process associated with them
Stream/Branch Stream A logical “split” of the code to enable parallel development activities to take place in isolation
Merge Merge Taking versions of the same file on two different branches, and reconciling the changes made to those files
n/a Suspend/Resume Ability to temporarily store or restore changes made in a workspace, to return the workspace to some known configuration

For more information

About the author

Daniel Toczala is the Technical lead of the Jazz Jumpstart team.  He has worked with Rational Services in the past as a Senior Solutions Architect.  He used his experience in helping a variety of customers in implementing organizational change to help build the concept of deployment patterns.  He has done numerous presentations on how organizations can utilize Jazz technologies and Agile approaches to software development to improve the value that software development organizations deliver to their customers.
Dan travels the world helping IBM customer, but his home is in New Hartford, NY.  He can be contacted at

Dashboards and work items are no longer publicly available, so some links may be invalid. We now provide similar information through other means. Learn more here.
Was this information helpful? Yes No 29 people rated this as helpful.