views:

4304

answers:

30

Because I'm currently struggeling to learn IBM Rational ClearCase, I'd like to hear your professional opinion.

I'm particularly interested in advantages/disadvantages compared to other version-control-systems like Subversion or Git.

+16  A: 

The cost is a fairly obvious disadvantage. Not just the license cost, but also the cost of a ClearCase guru's salary. Almost every company I'm aware of that uses ClearCase seems to have at least one person whose only purpose is to tame the unruly beast.

The very fact that it's complicated enough to require a full-time nanny is also worrying.

Don
Well OP doesn't seem to care about the cost.
Otávio Décio
Costs for software, hardware, and people are not necessarily fungible. They may come out of different budgets, depending on the organization. Moreover, adding a person is not necessarily as simple as budgeting for salary and incidentals. There may well be other problems, and you may be betting the ability for a department to keep working on the availability of one individual. I'd much prefer a system that didn't need a full-time guru, and one where individuals could cope with most problems themselves.
David Thornley
+39  A: 

You can find a good comparison between ClearCase and Git in my SO answer:
"What are the basic ClearCase concepts every developer should know?", illustrating some major differences (and some shortcomings of ClearCase)


File-centric operations

The most single important shortcoming of ClearCase is its old "file-centric" approach (as opposed to "repository-centric" like in SVN or Git or Perforce...)
That means each checkout or check-in is done file per file. The atomicity of operation is at file levels.
Combine that with a very verbose protocol and a network with potentially several nodes between the developer workstation and the VOB server, and you can end up with a fairly slow and inefficient file server (which ClearCase is at its core).

File-per-file operations means: slow recursive operations (like recursive checkout or recursive "add to source control", even by clearfsimport).
A fast LAN is mandatory to mitigate the side-effects of that chatty protocol.

Centralized VCS

The other aspect to take into account is its centralized aspect (even though it can be "distributed" with its multi-site replicated VOB feature)
If the network does not allow access to the VOBs, the developers can:

  • still work within snapshot views (but with hijacked files only)
  • wait for the restoration of the network if they are using dynamic views

Expensive Distributed VCS option

You can have some distributed VCS feature by replicating a Vob.
But:

  • you need a special kind of license to access it.
  • that license is expensive and add to the cost of the regular license
  • any vob that uses the replicated vob (admin vob, admin pvob, ...) must be replicated as well (meaning some projects not directly concerned with a distributed development will still have to pay multi-site license...)

Old and not user-friendly GUI

  • the GUI is very old school and impractical (mid-90's MFC look, completely synchronous GUI, meaning you have to wait for a refresh before clicking elsewhere): when browsing baselines, you cannot quickly look for one in particular.
  • the GUI on Unix is not exactly the same than on Windows (the latest 7.1 version is better but not there yet)
  • the installation process is quite complicated (although the latest Installer Manager introduced by CC7.1 is now a coherent GUI on Windows or Unix and does simplify the procedure)
  • the only real rich application has only been developed for CCRC (the Remote Client)

UCM inconsistencies and in coherencies

As mentioned in "How to Leverage ClearCase’s features", dynamic views are great (a way to see data through the network without having to copy them to the disk), but the main feature remain UCM: it can be a real asset if you have big project with complex workflow.

Some shortcomings on that front:

Limited policies with Base ClearCase

Using ClearCase without using UCM means having to define a policy to:

  • create branch (otherwise anyone can create any branch, and you end up with a gazillon of them, with merge workflow nightmare)
  • put labels (otherwise you forget to label some files, or you put a label where you were not supposed to, or you "move" (gasp) a label from one version to another: at least UCM baselines cannot be moved)
  • define changeset. ChangeSets only exist with UCM activities. With Base ClearCase, you are reduced to clever "cleartool find" requests...

No application rights

ClearCase right management is entirely built on system rights.
That means you need to register your user to the correct system group, which is not always easy to do when you have to enter a ticket to your IT service in order for them to make the proper registration.
Add to that an heterogeneous environment (users on Windows, and server on Unix), and you need to register your user on Unix as well as Windows! (with the same login/group name). Unless you put some sort of LDAP correspondence between the two world (like Centrify)

No advanced API

  • only CLI is complete ("cleartool" is the ClearCase Command Line Interface), meaning that any script (in Perl or other language) consists in parsing the output of those cleartool commands)
  • ClearCase Automation Library (CAL) exists, but is quite limited
  • Java API exists, but only for web views for the CCRC client.

View Storages not easily centralized/backed up

The View storages are the equivalent of the ".svn" of SubVersion, exept there is only one "view storage" per view instead of many .svn in all the directories of a SubVersion workspace. That is good.

What is bad is that each operations within a view (a simple "ls", checkout, checking, ...) will trigger a network request to the view_server process that manages your view server.
2 options:

  • declare your view storage on your workstation: great for scalability, you can have as many view as you want without taxing the LAN: all communications are directly done on your workstation. BUT if that machine dies on you, you loose your views.
  • declare your view storage on a centralized server: that means all view_server process will be created there and that all operations on a view by any user will have to communicate with that server. It can be done if the infrastructure is "right" (special high-speed LAN, dedicated server, constant monitoring), but in practice, your LAN will not support this mode.

The first mode means: you have to backup yourself your work in progress (private files or checked-out files)
The second mode means: your workstation can be unavailable, you can just log on another a get back your views (execpt for the private files of a snapshot view)


Side discussion about dynamic views:

To add to the "dynamic view" aspect, it has one advantage (it's dynamic) and one shortcoming (it's dynamic).
Dynamic views are great for setting a simple environment to quickly share a small development between a small team: for a small development effort, a dynamic view can help 2 or 3 developers to constantly stay in touch one with another, seeing instantly when one's commit breaks something in the other views.
For more complex development effort, the artificial "isolation" provided by snapshot view is preferable (you see changes only when you refresh - or "update" - your snapshot view)
For real divergent development effort or course, a branch is still required to achieve true code isolation (merges will be required at some point, which ClearCase handles very well, albeit slowly, file-by-file)

The point is, you can use both, for the right reasons.

Note: by small team I do not mean "small project". ClearCase is best used for large project, but if you want to use dynamic views, you need to setup up "task branches in order to isolate a small development effort per branch: that way a "small team" (a subset of your large team) can work efficiently, sharing quickly its work between its members.
If you use dynamic views on a "main" branch where everyone is doing anything, then any check-in would "kill you" as it could introduced some "build breaks" unrelated with your current development effort.
That would then be a poor usage of dynamic views, and that would forget its other usages:

  • additional way of accessing data, in addition of snapshot views, meaning it is a great tool to just "see" the files (you can for example use a dynamic view to tweak its config spec until you see what you want and then copy those select rules into your usual snapshot view)
  • a side view to make merges: you work with your snapshot view, but for merges you can use your dynamic "sister-view" ("sister" as in "same config spec"), in order to avoid having a failed merge because of checked-out files (on which you would be currently working on your snapshot view), or because of a snapshot view not completely up-to-date. Once the merge is complete, you update your regular snapshot view and resume your work.

Developing directly in a dynamic view is not always the best option since all (non-checked-out) files are read over the network.
That means the dll or jar or exe needed by your IDE would be accessed over the network, which can slow down considerably the compilation process.
Possible solutions:

  • one snapshot view with all in it
  • a snapshot view with dll or jar or exe in it (files which do not changes every five minutes: one update per day), and dynamic view with only the sources visible.
VonC
I still don't get what's so great about dynamic views. I admit I don't have to do updates anymore, but if someone breaks the build I immediately have to work with that broken build and cannot just not update till it's fixed again.
Benedikt Eger
@VonC's point was that it works in a small team. Small teams, by nature, check in early and often, with small changes in each commit. Therefore, it should not be difficult to figure out who broke it and what they did. However, why would small teams buy ClearCase? The cost and workflows of other options are better suited than the dated ClearCase.
geowa4
@George IV: dynamic views can indeed work for small or even medium teams if used for sharing commits. But ClearCase as a all is only best used for medium to large projects (which can include small to medium teams in them, hence using dynamic views), with complex merge workflow. Otherwise, for a small team/project... open-source VCS (SVN) or DVCS (Git or Mercurial) are much more suited.
VonC
I'm on a small team. We use Clearcase because its a company standard. Dynamic views basically waste a day for me, each and every time someone else commits.
AlbertoPL
@AlbertoPL I agree with you if everyone is trying to do everything on the same branch: then the *dynamic* updates are killing you. But if the effort is small enough on a dedicated branch, then the small sub-team can really use dynamic views at their best.
VonC
Last time I used clear case it was VERY slow over a wide area network or the internet and it's client did LOTS of small round trips to it's server.
Ian Ringrose
ClearCase dynamic views are intended only to be used on a LAN. If you have a WAN you should use snapshots or multi-site VOBs (only makes sense if you have a WAN separating a number of developers who share local LANs. We use dynamic views with 300+ developers with no problems at all. I will submit that if dynamic views are causing you problems, either you're not branching enough, or you shouldn't be using dynamic views.
Nick Bastin
Also, if you are EVER having developers make commits directly to a "main" branch, then no VCS will help the fact that you don't have a development process that makes any sense.
Nick Bastin
@Nick: errr, nope: I have no problem with dynamic views. They are indeed used on a LAN, with adequate branching policy. They are also great for merging operations (avoid being blocked with checked-out files or non-up-to-date snapshot views during a merge), or for simple consultations (like tweaking a config spec, only to copy that config spec to his snapshot view once the select rules are correctly set)
VonC
I still think a fair amount of your post equates to "if you have bad SCM policy, ClearCase won't work for you" which notably misses the point that you can remove ClearCase from that sentence and replace it with your system of choice and it's still true. The only difference between those things, of course, being that you paid a lot more in hard cash for ClearCase than something like git, but at the end of the day your SCM is still hosed.
Nick Bastin
@Benedikt Eger: If build is broken it does not mean that you get the broken build as well. It highly depends on your config spec. If you are going to use /main/LATEST as the view rule, then it is your fault. If you have correct labeling and branching strategy your local build should not be broken at all. I worked for many years with CC and never saw such a flexible SCM system for the enterprise software development mainly because of the views (especially dynamic). In some projects we had source base of about 2 gigs. Just imagine how long you will checkout these 2 gigs with other systems. ->
ovanes
-> ClearCase can get the required source on demand when using dynamic views it not immediately overwhelm your disk with 2 gigs of data. This is just a small example of my personal experience. Just imagine how long will get these 2 gigs with SVN or Git, where there some cross-references and you can't just get only one small part.
ovanes
+2  A: 

I would suggest SVN for toolset and Git for scaling/workflow. I'd also suggest avoiding CC where possible. (Not counting money, the fact it is such a pain to use that is requires a full time admin is a total joke)

Matthew Whited
+7  A: 

My experience with ClearCase was a disaster, and I will second Don's statement that it requires a resident expert-- unfortunately we had more than one. I had experience with CVS and other version control systems, I was familiar with the concepts, but I found the ClearCase documentation incomprehensible and had to ask for help several times; different experts gave me conflicting advice to the point where we actually broke cd. That is, after I issued a ClearCase command in a UNIX shell, the "cd" command failed with an error message.

The basic task of a version control system is really pretty simple. Honestly, I think that half a dozen commands should suffice, using a file scheme that plays well with others. To me ClearCase looks like the result of a marketing exec deliberately complicating the hell out of things to make the product look sophisticated and powerful. I've heard that it can be configured to behave in a simple, safe, reliable way, but again that requires the services of an expert-- out of the box it's like a motorized swiss army knife.

Beta
Sorry to hear that. We are running ClearCase (2002, then 2003, 2007 ad now 7.1) on Windows, Linux and Solaris (8 and now 10) without a problem. cd works great ;) (Note: I also run SVN and Git)
VonC
Breaking cd is not very hard. Simply remove the directory that the shell is parked in. Unloading/reloading mvfs could do that. Just cd to / and back again (if the directory is back again).That said, I have nothing to say in defense of ClearCase's implementation. Great concept, though.
kmarsh
Yes, I know about cd to / or something known to exist-- it didn't work. That shell was a very sick shell.
Beta
+4  A: 

Performance.

ClearCase is powerful, stable (IF properly maintained and supervised) but it's slow. Geological sometimes.

Dynamic views views lead to horrible build times, snapshot views can take ages to update (lunch break for large projects) or checkout (go home for the day).

Kristof Provost
If it requires "proper maintainance and supervision" to remain stable, it's not really stable. It's like saying "the X car is stable if you have an expert pilot driving it".
João Marcus
Dynamic views can work well when using "clear make" to build C/C++ code and you share common output, otherwise I would not use them.
Ian Ringrose
@joao-marcus: Clearcase is not a car, it is a 747. You'd better have an expert pilot: your average amateur with their pilot license is simply not qualified to fly it. But I don't think you'd say that that makes a 747 a terrible or "unstable" aircraft.
Zac Thompson
+3  A: 

ClearCase seems extremely powerful, from the outside. But really, it's just that the number of commands and options you need to use for basic workflow is so high that these get hidden behind a few aliases or scripts, and you end up with something less powerful than CVS, with the usability of Visual Source Safe. And any time you want to do something a little more complicated than your scripts allow, you get a sick feeling in your stomach.

Compare this with git, which seems complicated from the outside, but after a week working with it you feel completely in control. The repository model is simple to understand, and incredibly powerful. Because it's easy to get at the nuts and bolts, it's actually enjoyable to dig below the surface of your daily workflow.

For example, figuring out a trivial task such as how to just view a non-HEAD version of a file in a snapshot view took me a couple of hours and what I ended up with was a complete hack. Not the enjoyable sort of hack either.

But in git, figuring out a seemingly complicated task such as how to interactively commit only some changes,(and leave the rest for later) was great fun, and all the time I have the feeling that the VCS is allowing me to organise code and history in a way that suits me, rather than history being an accident of how we used the VCS. "Git means never having to say 'you should have'".

At my work, I use git for all sorts of lightweight tasks, even within ClearCase For instance, I do TDD, and I commit to git whenever a bunch of tests pass and I'm about to refactor. When the task's eventually done, I check in to ClearCase, and git helps me review exactly what I'm changing. Just try to get ClearCase to produce a diff across a couple of files - it can't! Use Google to find out the various hacks people have tried to work around this. This is something version control should do out of the box, and it should be easy! CVS has had this for decades!

Matt Curtis
I don't quite understand how you can possibly be having this problem. You just pass the version tags (or label, or time, or branch, or...) that you're interested in to cleardiff and it will happily diff them for you. Also, if you're working in a snapshot view and you're truly offline, then of COURSE you can't diff a non-HEAD version - you don't HAVE other versions. If you are connected to the VOB server, however, you can just use the version tag:cleardiff [email protected]@\main\some_branch\some_version [email protected]@\main\some_branch\some_other_version
Nick Bastin
I'd ask whether labels are being used. If you have a for labeling, Clearcase can me made much easier. If you don't use labels than what Matt describes will happen often.
Kelly French
[Edit]That is, if you have a 'plan' for labeling...
Kelly French
If you use a VCS with changesets (i.e. developed in the past fifteen years) you don't need to use labels to group changes across files. I think this makes my point stronger; using ClearCase effectively means changing your development methods to revolve around ClearCase. Other modern VCSs (including Subversion and Perforce, not just DVCSs) are far less obtrusive.
Matt Curtis
@MattCurtis: Using ANY VCS means changing your development methods to revolve around them. Sure, your development methods may already look a lot like some other VCS, and that's not a bad reason to choose it, but every VCS has a preferred method of operation, and you will get the best use and performance out of that VCS if you conform to its' patterns. The real question is whether you believe those patterns are better than your current ones.
Nick Bastin
@NickBastin: I've found that to be much truer with some VCSs than others - in a given day's development using ClearCase, I find I'm extremely conscious of the VCS compared to how I feel when I'm using Git, which much more effectively lives in the background.Sure, all VCSs get in the way to some extent, but it's variable. Take moving files around a source tree to improve physical structure and speed up builds, for instance. That basically never happens with some (most) VCSs, because it's too tedious to deal with losing history or merge someone's changes, but others (Git!) make it trivial.
Matt Curtis
@NickBastin: you're right though. If your methods are already based around ClearCase, it takes effort to move away from it to another style of VCS.
Matt Curtis
+10  A: 

Everything I have done in Clearcase always seems hard. Whereas, I've never had that impression with other systems(except maybe CVS on occasion).

I've used SVN, CVS, Clearcase, and Mercurial.

Paul Nathan
Well, CVS always seems hard, too. But not as hard as ClearCase! +1
Evgeny
+1  A: 

The biggest downfall for me is both the performance (especially if your VOB is multisite or offsite), and potentially lengthy downtimes.

If you're like me and work in a relatively small office as part of a large company (with no onsite IT), Clearcase servers going down can cost you the better part of a workday in non-productivity as well as getting the right people to get it fixed.

Bottom line, use it only if you really need it for what you are doing and make sure you have a beefy IT budget to maintain it.

eskerber
+12  A: 
geowa4
If I get around to it, I'll post more.
geowa4
Implementing a merge lock will solve a lot of your problems. Also, rolling back changes by datetime is really really easy. Yes, it is a different way of working, and it is arguably more annoying than a tool that does atomic commits, but these things should not be getting in your way. In far less time than you have probably lost to these problems, you could have fixed them in your merge policy.
Nick Bastin
+4  A: 
  • Nightmare to administer in secure environments
  • Outdated technology
  • Non-intuitive GUI
  • Expensive
  • Resource monster
  • Sellout to Microsoft

In my opinion? Only reason to have it? If you are religiously following RUP.

Tom Werner
You don't need ClearCase to follow RUP, religiously or otherwise.
Thomas Owens
Sellout to Microsoft?
Greg Hurlman
A: 

Administration. I had to schedule multiple day-long downtimes to perform upgrades from 6 to 7, and to move the semi-massive (159GB) VOBS from an older server to SAN storage. With a system like git or svn+svk, this could be done overnight, nearly automagically, with no impact to users - they'd never notice. They couldn't push changes upstream, but they could continue to work. With ClearCase or raw SVN, they are at the mercy of the repository server.

ClearCase UCM is a great tool, I like it and think something can be done to add like functionality to SVN/mercurial/git/bzr - not that you can't implement it with hook-scripts, but that's a custom one-off for each site. UCM is so prevalent, everyone does it, but almost no-one tracks it in the repositories. :-/

Chris Kaminski
+1  A: 

Check seriously the ClearCase UCM. UCM is a mature approach of configuration management processes, and actually it's a wrapper for the basic ClearCase version.

I know SVN and GIT. I think you cannot find a mature wrapper to CM processes yet with them.

I work with ClearCase UCM for many years, and I developed new add-ons that help you automates some processes. Have a look: http://gomidjets.com

Tamir.

Tamir Gefen
A: 

It sucks.....(try http://www.sourcegear.com/)

abmv
A: 

Running a JDK from a VOB in Linux.

Try it, you need to play with the LD_PRELOAD variable (I know!)

Spedge
+2  A: 

I'm not totally against ClearCase ( it does have it's advantages ), but to list out the disadvantages:

  • License Limitations - I can't easily work from home, because I don't have access to the license server. Even with a snapshot view on my laptop I have to play tricks because I can't get a license. There is a special remote client, but adds tons of its own limitations to the mix
  • License Limitations again - Only so many seats to go around, and then no one can use it.
  • Unix tools out of date - ClearCase seems to run best on Unix systems, but the GUI tools suck there. Windows/Unix integration of ClearCase introduces all sorts of its own pains.
Chris Arguin
+3  A: 

I'm trying to consolidate a few comments into an actual post here. I'm not really here to persuade you that one is better than the other, except by way of making a few points:

  • If you're comparing git and ClearCase, I respectfully submit that you need to better define your needs - if you are considering ClearCase for a "good" reason, the git probably isn't even in the equation - it's far too new to trust for enterprise-level source control, imo.
  • ClearCase introduces a lot of concepts into the version control space that other systems don't have, so it can be pretty daunting and confusing. Especially if the only experience you have is reading the documentation, as appears to be the case for a few people here.
  • ClearCase is definitely not well suited to huge code bases supported by developers who are not on a LAN with a VOB server. You can have many replicated (multi-site) VOB servers to get them close to remote developers, but this isn't necessarily practical if those remote sites are just a single developer.
  • Do you want file versioning or repository versioning? This is a pretty important question, and one that will necessarily filter out an entire set of tools, making your job easier. Repository versioning has a lot of advantages (and it's not "new", like some posters claimed - commercial tools like Perforce have been around for more than a dozen years, and there may have been tools that did repository versioning even before Perforce), but it isn't a panacea.
  • With a sufficiently large installation of any source control system, you're going to need help. When considering tools, you need to consider how easy it will be to find people to help you (either job applicants who have experience, or consultants who will be there at a moments' notice to address any issues). There's no such thing as a maintenance-free SCM system, and assuming you have one will get you into more trouble than picking one that requires "too much" administration.
  • Don't pay too much attention to people who talk about how bad "dynamic views" are - bad SCM policies are bad, regardless of the tool you're using. Your configuration management policies and practices have to be separate from your choice of tool - no tool will stop people from smashing all over your codebase if you don't define sensible branching and merging policies. If someone suggests that having developers directly commit onto /main is ever a sensible idea, you might want to walk away from that conversation.

ClearCase is a fine tool, but it is a complicated tool. There is no getting around this - it does not have an "easy install" mode. :-) From a technical standpoint, there's nothing that git or SVN can do that ClearCase cannot (although often the terminology is different, since Open Source projects tend to just invent new taxonomy where there already existed one), but some things are definitely easier/harder for a given system, depending on their design. ClearCase "snapshot" views are basically the same thing you would have if you checked out a repository from SVN or CVS - it's a local copy of the source code on your machine, with pointers back into the central server for tools to query version history, etc. You can work with these views without any network connection to the ClearCase server at all once they have been created, and you can "recycle" them to avoid downloading your entire repository again when you want to move to work on another branch, for example. "Dynamic Views" are basically a ClearCase invention, and the standard operating mode for a LAN. They appear the same as checking out an SVN repository, but they don't actually copy any files until you make changes. In this way the view is available immediately, but it obviously cannot be worked with if the main clearcase server is unavailable, and is unpleasant to work with over a high-latency connection. They also have the convenience of being able to be mounted as a network drive on any machine with access to the server on which they were created, so if your windows workstation dies, you can just log onto another one, mount your view, and get back to work, since all the files are stored either in the VOB server (for files you haven't modified on this branch), or the view_server (for files you have created or modified just in this view).

Also, and this deserves its' own paragraph....clearmerge is nearly worth the price of admission alone. It's hands down the best merge tool that I've ever used in my life. I firmly believe a lot of bad practice in SCM has developed because of a lack of high-quality merge tools, so CVS users never learned to use branches properly and this fear of branching has propagated to the current day for no particularly good reason.

Ok, all that being said, if you're looking for reasons not to use ClearCase, they're not hard to find, although I think that's the wrong way to go about it. Really you should need to come up with good reasons TO use ClearCase, not reasons for NOT using ClearCase. You should come into any SCM situation assuming that ClearCase is too much tool or too complicated a tool for the job, and then see if you have some situation that encourages you to use it anyhow. Having IBM or Rational logos is not a good reason.. :-)

I would not even consider ClearCase unless you could say yes to all the following statements:

  • You do now, or will eventually have, more than 50 developers working on the same codebase.
  • Most of those developers are centrally located, or have high-throughput low-latency connections to a central location.
  • You have a set of SCM policies and can identify how to use ClearCase to enforce those policies (really you should consider this for any tool)
  • Money really is no object
Nick Bastin
> if your windows workstation dies, you can just log onto another one: only if your view storage was not on your workstation ;) (and centralized view storage is not always possible due to the additional stress it puts on the network, each view operation then involving a *network* access)
VonC
OK, clearmerge is a good tool, I'll grant you that! But no way is it worth the price of the entire system - either in dollars or in sanity.
Evgeny
@VonC: on an even halfways well designed LAN, dynamic views don't cause significant network traffic (say, compared to windows boxes smb'ing all over the place all the time). In my experience it's more efficient (and more convenient) than having a CVS or SVN checkout exported to NFS and mounted somewhere else.
Nick Bastin
+8  A: 

An absolute nightmare of a system. It made me wish we could go back to VSS! (Never mind any modern source-control system like Subversion or Git!)

  • It's slooooow.
  • If you use dynamic views and the network goes down you cannot access your working copy of the source. You can do nothing but sit and wait for it to be fixed.
  • If you use snapshot views you seem to run into conflicts and "hijacked" files all the time, so the files in your working copy are never quite the same as in the source repository.
  • Whenever you try a large update or deliver operation it invariably FAILS for one reason or another, requiring your ClearCase guru to spend a few hour/days figuring it out. Oh yes, you must have a dedicated, full-time ClearCase guru!
  • When it fails you often cannot roll back the operation, either, so you're stuck with an operation in progress and the developers are blocked.
  • When you look past the pretty(?) icons, the GUI is very poor - right down to things like being unable to resize windows to see full file paths!
  • Their support staff are quite reluctant to fix anything. Their first response is always "this is by design" and "can you work around it?" If they do ultimately provide a fix (after much arguing) it will be the most basic possible fix to the most immediate problem.

Basically, it's slow, complicated and unreliable as hell. Oh, and did I mention it's ridiculously expensive? The only way they can possibly sell it is by talking to decision-makers who have never used the product and never will! I'm quite sure that no developer in the world would ever buy it.

Evgeny
> When it fails you often cannot roll back: it depends if you have started to make checkin or not. If there are still only checkout files, the rollback consists just to "`undo checkout`" everything. Note: for merges which are foreseen as complicated (because of an important lapse of time since the last merge), a "merge branch" can be a good option in order to isolate the merge effort. Once everything is consolidate there, a simple merge to the dev branch completes the process (Note within the Note: that last advice is not ClearCase-specific and can apply to any VCS tools).
VonC
+1  A: 

Clearcase is so annoying it actually drives people to write poetry about it:

http://digital-compulsion.blogspot.com/2007/01/poetic-pathetic-version-control.html

http://grahamis.com/blog/2007/01/24/if-it-was-free-no-one-would-download-it/

hawkeye
+1  A: 

I recently had to wrangle with a similar situation. Maybe you can learn from my story.

The team I was newly assigned to was using a heavyweight tool in an convoluted, error-prone manner. I first attempted to sell them on my tools and processes of choice. This attempt failed miserably. I was flabbergasted that they would pick such a burdensome environment over one that was both easier and more effective. Turns out that they wanted to be disciplined, and using a painful process felt disciplined to them. It sounds wierd, but it's true. They had a lot of other misconceptions too. After I figured out what they were after, we actually stuck with the same tool suite (Serena), but massively changed how it was configured.

My advice to you is to figure out what matters to your team. Ripping on ClearCase won't get you anywhere unless you speak to their interests. Also, find out why they don't want to use alternatives. Basically do a little requirements gathering and fit your tool choices to your needs. Depending on your options, who knows, Clear Case may end up being the best option after all.

Darryl
+4  A: 

Down sides of ClearCase. An addition to the most in-depth post here.

1) The merge tool is not worth shit. It barealy helps you, remembers no decisions you made, its just a glorified diff.

2) The merge tool has to check out directories to even CHECK if they need a merge. Its a bit insane.

3) I use bit keeper at work (lets assume GIT), and merging two repositories even if there are conflicts is so trivial and user friendly even with command line, while clearcase having tons of GUI tools is a long and laborious process which is also extremely error prone.

4) All GUI tools require a ton of latency. Even seeing what can be done on a file requires a high speed connection. So right-clicking in the clearcase tool on a file working from home could take a minute or two having high speed internet because of the extreme amount of networking requirements.

5) Someone can completely fuck up the repository or checkins if they make their view spec different than the team. Which is quite insane that nobody can just check out some branch, they need the appropriate view spec which will incidentally give them the right stuff. The whole concept can be nice and flexible but 99% of the time it just causes lots of pain. Did I mention you can't email your spec via. MS Outlook since CC tools don't accept UTF8 so you can't copy-paste it?

6) I have absolutely NOTHING nice to say about CC. I used it for 2 years at 2 companies and dropped it in a heart beat feeling happy the entire time. It is also impossible to just experiment with at home with your own projects, so you will still learn SVN or GIT at home, and be forced to go through clearcase pains at work. Nobody I know has ever used CC voluntarily. They only use it because some manager at work decided CC is the path to salvation and forced everyone to migrate to it. In fact my last company migrated CVS -> ClearCase and in 1 yr ClearCase -> SVN. It was that hated.

7) CC is not just one thing that makes you say no. Its like living in a house infested with ants. Each ant is just a minor inconvenience at best, but the infestation will drive you mad.

Dmitriy Likhten
+1  A: 

The support is terrible. We've had tickets open for years. Our eclipse guru actually fixed a bug in their eclipse plugin locally in about 30 minutes by disassembling the java file. But the ticket still hasn't got past level one support. Every so often they either try to sneakily close it or ping it back to us 'to try on the latest version' (even though we sent them a reproduction recipe which they could try for themselves.).

Do not touch with a barge pole.

Ealdwulf
+1  A: 

ClearCase is perfectly usable if your willing to also use another version control system on top of it! personally I find using mercurial ontop of CC to work quite well.

Arthur Ulfeldt
+6  A: 

No atomic commits

Once you checked in files it is very hard to revert to a certain state, because atomic commits aren’t supported. When checking in multiple files, each file gets a new revision (similar to CVS) and not the check-in itself. I think this is a crucial feature, because you hardly want revert single files but complete commit actions (which should map tasks). With ClearCase you can only revert to certain states by using Labels. In practice using ClearCase Labels for each check-in is overkill and thus not done.

Crappy user interface

The GUI of ClearCase Explorer is just a big joke. Horrible in usability and ugly looking. Different and often necessary functions aren’t provided (e.g. recursively checking in worked on artifacts). Command line tool cleartool used with cygwin is much better, but still some things aren’t available like recursively adding new files/folders to source control. I have to laugh my head off if I read a 50 lines of code long script to workaround this.

High administration efforts

Administrating ClearCase beast is far from obvious or lightweight (in difference to other scm-systems like CVS, subversion or Git). Expect to put quite a few dedicated ClearCase experts to just keep it running.

Horrible performance

Nothing is worse as making your developers wait while interfacing with SCM-tool, it is like driving with hand brakes enabled. It slows down your brain and also your work. Getting fresh new files to your snapshot view takes around 30 minutes for 10K artifacts. An update (no artifacts were changed) for the same amount takes roughly 5 minutes. When experimenting a lot and jumping between different up-to-date views means a lot of waiting. It gets even worse, when you’re working on files and you want to check-in or update them. Check-out, check-in and adding to source control cycles take around 10-15 seconds which is obviously a nightmare. It gets very annoying when you’re refactoring renaming/moving types or methods (many files can be affected).

Lack of support of distributed development

Today software development is often a distributed thing (developers are spread around the world working on the same product/project). ClearCase definetely isn’t suitable for this, because it is badly suited for offline work. Doing a check-out (action before you can edit a file/folder) requires that you are network connected. Here you could use the hijack option but this is rather a workaround as a feature (you basically just unlock the file on the filesystem). If your development sites are far away from your ClearCase server the check-in/check-out latency can even increase so dramatically that it is not usable at all. There are workarounds for that like using ClearCase Multisite (scm DB replica technology), but you have to pay extra for it and is not trivial to adminstrate.

Git as alternative

Though being a big fan+supporter of Open Source I am still willing to pay money for good software. But looking at IBM-monster ClearCase I wouldn’t invest my money here, it has all these discussed shortcomings, and further more IBM doesn’t seem to invest money to improve their product significantly. Recently I had a look a Git scm which looks very good, especially for its branching+merging features, where ClearCase has its major strengths.

This information taken from http://www.aldana-online.de/2009/03/19/reasons-why-you-should-stay-away-from-clearcase/

joe
A: 

I will be maybe alone here, but ClearCase is not that bad as everyone says. It can handle huge repositeories. Dynamic view are pretty cool and powerful feature too. It is reliable, can be customized by adding triggers and constraints on a pef file basis, permissions, etc.

Unfortunatelly, it comes with a price, big price. It is costly, and to operate properly needs to be properly configured and maintained by dedicated IT team. It makes it really good for BigCo, but not so wise choice for SmallFirm.

I'm a big fan of DVCS and git, but can understand why would BigCo choose ClearCase over SVN and Git. What I can't understand why would anyone choose SVN over Git ;>

Dev er dev
+1  A: 

Dynamic Views. Must admire a fully functional translucent file system.

One big benefit is that the Intellectual Property is always in the corporate network. A laptop can be lost/stolen and no source code in jeopardy.

Another is the instant access to source code and changed files, no time is ever spent downloading anything.

It serves well for the purpose it has.

dengel
+3  A: 

Everything I've experienced related in any capacity to ClearCase is inefficient, ugly, overly complex, slow, confusing, expensive and inconvenient.

It seems to attract managers and engineers that JUST HAVE GOT IT ALL WRONG.

Damn, IBM and Rational must have amazing sales guys to sell such a crappy product.

Alex Worden
I too have wondered what sort of sparkling brochures the clearcase salespeople have to be able to sell this stuff. Of maybe it is just that it's a really wonderful system, for anyone who doesn't actually use it.
Mattias Nilsson
+3  A: 

Possibly the worst software ever made. I will not work for any firm that uses rational anything. Aside from CC completely crashing and restarting my workstation frequently on dynamic builds. What happens when you are pushing somehting to source control and CC does what it does best, crash? Is your code then put in lost+found, backed up somewhere maybe? No it is gone forever. So if you are ever in the god awfull situation of using this giant piece of expensive shit, keep duplicates of everything. Good job rational / ibm. Way to capture the most important part of source control, reliablity. Die slow.

Ryan
+2  A: 

My experience is mostly limited by CC, CVS and SVN. In principle, CC is technologically capable, enterprise ready and comparable by features with any modern VCS. But it has several flaws that make it unusable in any people-oriented environment. For process oriented environments it is probably more appropriate, though I doubt that such environments are appropriate by themselves. Maybe, in military, cosmic or medical software, I don't know. Anyway, I believe that even for these domains there are appropriate and still more friendly tools.

Beside being technically capable VCS, CC has several distinctive advantages:

  • Dynamic views
  • Nice version tree
  • Triggers
  • Good merge versioning, including renames

In my opinion, their use is limited excepting last one; and they don't compensate flaws. Dynamic view nice in theory, but not always available in practice. Version tree has much less use in other VCS, while necessary in CC because of proliferation of branches (see 6). Triggers, as I know, very detailed and capable, but I think that for most practical tasks SVN hooks are good enough. And now about disadvantages that mostly concerns usability:

  • CC totally fails in sense of usability for main user group: for developers. And that is the main reason why I think that it should never be used in any environment, be it enterprise or not. Even if it were free, it would nevertheless suck your company's money by wasting time of your developers and frustrating them. This point is composed from:
    1. "Check out-Check In" with strict locking approach - it is counter-productive, refactoring unfriendly, and dangerous in repository organizations with single development branch for multiple developers. Meanwhile, the advantages of strict locking are negligible.
    2. Poor performance and high load
    3. It effectively cannot be used remotely without multi-site (due to 2). Multisite is expensive too. ClearCase Remote client is very limited. It don't even have cleartool (before version 7.1), leaving alone dynamic views.
    4. It can hardly be used offline. Dynamic views are just not work. Snapshot views are effectively read only, because you cannot check out without access to repository (see 1). Hijack is poor option which in fact means that CC gives up any responsibility for hijacked file. And CC cannot show you difference with previous revision when offline. SVN is able to show difference with previous revision even being offline.
    5. Overly complicated model, especially with UCM: VOBs, PVOBs, Projects, streams, branches, views, deliver, update, load, restore, rebase, merge, baseline, check in, check out. I think that half of this concepts are just superfluous and doesn't add value, while increasing both technical and conceptual complexity. Few developers understand even basic stuff about CC.
    6. Proliferation of branches. For example, repository often organized with stream per developer (due to 1). It just has no sense in SVN or most other VCSs.
    7. No repository wide revisions. Well, there are such revisions as understand, they called baselines. But when I see some file revision and want to get repository snapshot at the moment of that file revision, I will get some problems. I will need to do black magic with config spec to create a snapshot view, or find somehow through dynamic view if it is available.
    8. Crappy user GUI. Version tree, even being nice, has mediocre usability. Merge tool is just a pity. Other "features": not resizeable windows, absence of incremental search in some places, mouse-centric interface, look and feel in 1995 style, strange work flow distributed between Client and Project Explorer etc.
    9. CC provokes rare and vast check ins. You all know, that check ins must be small and frequent. But developers usually refrains from additional interactions with CC, hijack files and work in local VCS or even without VCS at all (which is more often, unfortunately). And then, after two weeks of development they begin commit comlex feature that adds 20 files and affects another 20 files. It lasts for a day or two, because they hijacked files and now need to perform manual merge with all new changes from repo and resolve all conflicts and discrepancies. During that process, code lies not compilable, because several files successfully got checked in and others do not. And after that it still lies not compilable because they forgot to add another 2 files to CC.
  • It is very expensive
  • It is very complex in terms of infrastructure and requires dedicated administrators
Rorick
A: 
  1. no atomic checkins

As of the new version of version 7.1 CC provides atomic checkin as functionality IF you like that. Personally I would really not want it but apparently some people see that as "an essential feature". I NEVER would want one big bulk in one go as a sort of massive version. Then again... if you want it just turn it on.

so... no longer an argument.

edelwater
Yes, I would be really glad to have that. But we have no money to update our CC version =)
Rorick
edelwater
A: 

the point of "it needs a dedicated person" and "it is complicated" etc....

The core issue here with finding this a problem is that you have to define if you want to have configuration management performed in your organization (which is NOT version management). Configuration Management is like Project Management: even without a tool you still can do project managment and without a tool you can do Configuration Management. Lots of people have a hard time understanding this and lots of people think Configuration Management is equal to a tool which versions sources of software or something...... (therefore comparisons with subversions or other VERSION management systems)

ClearCase is a solution that is build for usage in a Configuration Management environment ERGO: there is a configuration manager (just like "there is a project manager").

So... if in your perception that dedicated person is there to manage a tool I think there is something very wrong. In my perception there is a dedicated person who does configuration management who from an end-user perpective only shows up when there is a problem with the tool but regards this as only 1% of his job.

So what you need to do (like in any other software project) go back to your requirements and put a list of requirements together on what your organisation wants with configuration management. AND YES like in any other software project you will have users (like e.g. developers) who totally not agree with other users (like e.g. management) on certain requirements. There lies the key imho on some reactions I read here.

And IMHO if you have the organization list of requirements AND a configuration manager in the mix.... the choice is pretty clear (see also the forum on www.cmcrossroads.com)

ClearCase is not a tool only for end-users entering their sources under version control like subversion or git. That is only 1% of why a configuration manager really wants a mature configuration management tool.

And... I think the choice of a CM system should never lay with developers equal to choosing the right project management tool or the right CRM system. Developers are end-users of a certain part of the functionality of the tool.

edelwater