image-blog-vcs-what-is-clearcase-basics
January 30, 2020

What Is ClearCase? An Overview of ClearCase Basics

Version Control

Many teams still use ClearCase — otherwise known as IBM ClearCase or Rational ClearCase. Here we cover what ClearCase does and why teams still use it, even today.

So, What Is ClearCase?

ClearCase is a software configuration management tool used for version control. It manages changes across development lifecycles, from design to code to test.

It is one of many version control systems available today. (Other options include Perforce Helix Core, Subversion, Git, and TFS.)

ClearCase Basics: How It Works

So, how does ClearCase work? And why do development teams use it?

Here are the ClearCase basics you should know.

File-Based Architecture

ClearCase has a file-based architecture. All “elements” (files and directories) are versioned independently. The directory structure is managed in a similar fashion to a Unix filesystem.

ClearCase elements are stored in repositories called Versioned Object Bases (VOBs). Users access these elements using a “view”. A view can either be a “snapshot view” (local files) or “dynamic view”. Dynamic views use the Multi-Versioned File System (MVFS) to access data within a VOB in real time.

All operations are performed on a per file basis — one at a time. Here’s an example:

If you wanted to “tag” and entire build or release, you would need to apply the tag recursively to each file and directory. One at a time. This is a tedious and time-consuming task. And it only gets worse when the number of files increases.

It is impossible to group changes to multiple files into a single database transaction. (It is not atomic.) This dramatically increases the potential for partial delivery of bug fixes and features. As a result, broken builds become far too common.

ClearCase was designed back in an era of where projects consisted of 1,000s of files, yearly release cycles, and file sharing over a LAN.

This has created some complications in the modern era of 100s of 1,000s to millions of files, weekly and daily release cycles, and file sharing over the WAN.

Monolithic Codebases

Teams that are still using ClearCase more than likely have monolithic codebases. (Monolothic codebases are ones where all code is in one massive logical codebase.) But ClearCase has scalability limitations. So, these monoliths are often split physically into multiple VOBs.

Monoliths contain all of your legacy code and full version history. However, it gets increasingly more difficult to maintain the code in a monolith over time.  That slows down velocity. And it compromises quality, while putting your business at a competitive risk.

For that reason, some teams are considering breaking their monoliths up as a way to modernize.

[Related Blog: When to Move Your Monolith]

 

Replication Model: ClearCase MultiSite

ClearCase requires an add-on for replication — ClearCase MultiSite.

ClearCase MultiSite enables developers at different locations to use the same VOB. However, ClearCase MultiSite comes with a price — and a steep one at that.

If you replicate a repository for the person who needs it, you’ll have to pay for everyone who touches it. (Even if you have 100s or 1,000s of developers locally — and only 5 people remote!)

You have to continually manage the “branch mastership” in ClearCase MultiSite. This adds a lot of overhead to the development teams, reducing velocity.

Branching

ClearCase branching is done on a per-file basis. When merging from branch-to-branch, you still merge on a per-file basis. ClearCase UCM (Unified Change Management) is a layer on top of ClearCase. UCM manages branching and merging in a restricted way. But under the covers, everything still happens on a per-file level.

Most teams using ClearCase fit into the following types:

  • They use no branching or little branching.
  • They do some branching manually, typically with private, task, or feature branches.
  • They do extensive branching and manage it with scripting.
  • They are using UCM and dealing with the constraints and performance issues that come with it.

ClearCase branching and merging used to make for effective collaboration. However, as software and hardware projects have grown in complexity, ClearCase hasn’t been able to keep up. This results in slow performance and difficulty branching and merging at scale.

Security & Audit Controls

ClearCase permissions are enforced at the file/directory level. They follow a model very similar to the Unix filesystem.

ClearCase permissions ensure that no one accesses the repositories without appropriate credentials. These permissions are defined at both the VOB level and the element level. Any changes a user makes are transcribed and maintained for traceability. Plus, admins can use scripts to enforce policies on a shared repository.

However, ClearCase permissions are tied to the OS. This makes it difficult to manage complex rules and proper sync permissions across multiple platforms (e.g., Windows, Linux, Mac).

Admin Required

Typical enterprises require a team of admins to set up and maintain ClearCase. The number of admins required increases when ClearCase MultiSite is also in use. Due to ClearCase’s chatty communication and resource intensive nature, the hardware requirements are also quite costly.

It takes a tremendous amount of resources to:

  • Configure the ClearCase servers.
  • Manage interop environments (mixed Windows and Unix).
  • Orchestrate a backup solution (there is no native way to do a hot backup).
  • Manage the complexities of MultiSite.
  • Deal with client side installations.

Is ClearCase Dead? 

ClearCase isn’t totally dead yet. Many teams still use it. But ClearCase’s popularity is dying.

At one time, ClearCase was at the cutting edge of technology. Today, however, some of ClearCase’s technology can actually slow down development teams.

Many teams are now considering their options (one of which is comparing ClearCase vs. Git). That’s because there are a lot of risks involved with continuing to use ClearCase version control.

 

Gain Speed and Save

Let’s face it. You can’t afford the productivity loss and serious risks that come with using ClearCase.

It’s time to switch to a better version control. One that scales. One that’s fast. One that gives you the automation, flexibility, and control you need for branching. One that works with Git.

MODERNIZE YOUR MONOLITH

5 Risks of Using ClearCase (and ClearCase MultiSite)

Here are some of the biggest risks facing teams who continue to use ClearCase.

1. Lack of Support

ClearCase is now supported by HCL, as part of HCL’s 2016 partnership with IBM. But support is lacking. This has raised concern among many teams using ClearCase.

2. Lack of Meaningful Updates

ClearCase hasn’t changed much in recent years. IBM is still developing and maintaining it. But recent releases have lacked new, modern features that most teams seek. As a result, ClearCase hasn’t kept pace with trends in the industry.

3. Slow Performance

ClearCase has notoriously slow performance. This is especially true as the number of assets grow — and as large monoliths become even larger. Simple operations like updating or merging can take minutes to hours. This has a big impact on developer productivity (and patience).

4. Painful Replication

ClearCase offers replication (with ClearCase MultiSite) — but it’s painful and expensive. License and hardware costs to implement ClearCase MultiSite are high. Maintenance of “oplogs” and “epoch tables” require dedicated administrative resources. The branch mastership model of replication requires development teams to add extra steps to collaborate — thus slowing velocity.

5. Complicated Branching

ClearCase branching is complicated — and creates problems for teams. For starters, there’s no defined relationship between branches and no associated workflow for the development process. And there’s no built-in method to identify which fixes need to be applied across several different branches, increasing the risk of regressions.

Helix Core: The Clear Choice For ClearCase Teams

ClearCase has major problems. It doesn’t scale. Its architecture is outdated. And it’s expensive to maintain. Continuing to use ClearCase will only frustrate your team.

Helix Core is the clear choice for ClearCase teams.

Helix Core scales to handle your users, number of files, and size of repositories. Its architecture is modern and fast. It’s easy (and much less expensive to maintain). Switching to Helix Core will relieve your team from the frustrations of ClearCase.

Helix Core has everything you love about ClearCase plus the modern features your team needs to be successful in the future.

Helix Core Mitigates the Risks of ClearCase

1. World-Class Support

While ClearCase support is lacking, Helix Core is backed by a global support team.

2. Regular Product Updates

Helix Core has 2 major releases each year. In the latest — Helix Core 2019.2 — we added functionality to further customize Perforce Streams (our branching) to support component based development (CBD). We also added support for minimal downtime upgrades, which removes the friction of keeping up with product updates. For developers who prefer to use a client instead of the command line, we added a dark theme for P4V (the visual client).

3. Fast Performance

Helix Core delivers fast performance, no matter how large your monolith grows. Teams of over 10,000 users can access the same repository fast — even with millions of files and terabytes of data. Helix Core is orders of magnitude faster than ClearCase. End users will experience dramatically improved performance.

4. Easy Replication

Helix Core has Perforce Federated Architecture. This enables remote teams around the globe to access files as quickly as they would if they were sitting right next to each other.

5. Better Branching

Helix Core has Perforce Streams for branching. Streams provides automation, flexibility, and control. You can automate your process and see branch-to-branch relationships graphically. So, you’ll be able to clearly identify where changes need to be applied.

Plus, Streams supports complex development processes and reduces bottlenecks. And you won’t have to write any scripts.

Switch From ClearCase to Helix Core

Let’s face it. You can’t afford the productivity loss and serious risks that come with using ClearCase.

It’s time to switch to a better version control. One that scales. One that’s fast. One that gives you the automation, flexibility, and control you need for branching. One that can even allow you to have some teams who work in Git.

That better version control is Helix Core.

See for yourself why ClearCase teams are switching to Helix Core. You can try it for free for up to 5 users.

Try Helix Core

 

Related Content: