This module explains the project manager’s tasks to set up a UCM project. Create a UCM project for the ClearCase UCM tutorial. Creating a view on the. Before using ClearCase® UCM, review the development tasks. When you Eclipse: Creating a workspace for your ClearCase UCM tutorial project. You must . Leif Trulsson. Implementing ClearCase. Implementing ClearQuest for. UCM ClearCase Tutorial—A formal hands-on walkthrough of UCM functionality.

Author: Fenrik Tygonris
Country: Papua New Guinea
Language: English (Spanish)
Genre: History
Published (Last): 23 April 2009
Pages: 159
PDF File Size: 9.28 Mb
ePub File Size: 1.75 Mb
ISBN: 848-9-22444-351-3
Downloads: 22978
Price: Free* [*Free Regsitration Required]
Uploader: Gardakazahn

By using our site, you acknowledge that you have read and understand our Cookie PolicyPrivacy Policyand our Terms of Service. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.

If this question can be reworded to fit the rules in the help centerplease edit the question. This question exists because it has historical significance, but it is not considered a good, on-topic question for this siteso please do not use it as evidence that you can ask similar questions here.

This question and its answers are frozen and cannot be changed. But it also supports a “replicated” mode allowing you to replicate a repo in a distant site MultiSite ClearCasesending deltas, and managing ownership. The branches are mastered in one VOB or another; you can only check-in to the master VOB for the branches mastered there, though you have readonly access to any branch at any replica.

That also means a merge must find a common base contributor not always the same as a common ancestor through history exploration see next point. It only affects a singe file, or a single directory without its files ct findmerge is recursive. A commit of several files is not atomic. Almost every other modern tool is “repository centric”, with an atomic commit transaction, but first-generation systems like RCS, SCCS, CVS, and most other older systems do not have that feature.

When a file is “removed” rmnameit does not know it: Create two files with the same size and content, they will get the same id in Git — a SHA1 key — and will be stored only once in the Git repo! Not so in ClearCase. Plus, If two files with the same path and name are created in two different branches, their id being different means those two files will never be merged: Not so for ClearCase, where a branch is a way to reference a version number.

Any version number starts at 0 just referenced in ClearCase to 1, 2, 3, and so on. Each branch can contain a new list of version numbers 0, 1, 2, 3 again.

This is different from other systems where the version number is unique and always growing like the revisions in SVNor is just unique like the SHA1 keys in Git. It is called an “extended path name”: Git does refer to everything through id — SHA1-based So it is “id-accessed” or “id-referenced”. For ClearCase, an id refers to an “element”: Then they will merge their checkout version of that same file. It actually triggers nothing: Only modified files will have their new versions stored in the declared branch.

This is not a database with an easy query language. SVN is more like “server-based” protection, where the Apache server can get a first level of protection, but must be completed with hooks to have a finer grain of rights.

Git has no direct rights management and must be controlled by hooks during push or pull between repositories. It can be a pre or post operation. ClearCase is a beast to use.

Slow, buggy, and expensive. Some things that I have done to cope with using CC are:. All our development is done on branches; I created a couple today, for a couple of different sets of changes.

If it had been for an older release on a branch, it wouldn’t have been any harder. The merges from my temporary branches were fully automatic; no-one had changed the files I worked on while Cleaarcase had them checked out. Although by default checkouts are reserved lockedyou can always unreserve the checkout later, or create the checkout unreserved. When the changes take multiple days, the resynchronization of my temporary branch with the main branch is easy and usually automatic.


The mergetool is OK; the biggest problem for me is that my server machine is miles or so from my office or homeso that X over that distant is a bit slow but tutirial intolerably so. I’ve not used a better mergetool, but that may not be saying much since I’ve tutorrial used any other graphical mergetool. Views dynamic views are fast on our setup. I’ve not used snapshot views, but I don’t work on Windows when I can help it our team tutoria, snapshot views on Windows; I’m not clear why.

CC is not trivial to use, though at the moment, I find ‘git’ as daunting as CC is to those who’ve not used it. But the basics are much the same – checkout, change, checkin, merge, branch, and so on.

Directories can be branched – cautiously – and certainly are version tutoial. I can half see cleacrase I’m not sure I like giving up that trackability, though.

We always considered that practice as evil mixing meta-data information into dataintroducing “merge hell”. See also How to get Clearcase file version inside a Java file. Checkin Trigger Example provided you use an appropriate merge manager. There are several issues exposed by this discussion, and they all get mixed together. My views verge on the archaic, but have a rationale behind them, and I’m going to take the time to write them down messed up by life – it may take several edits to complete this.

Commercially, my employer used SCCS up to mid, but they started to switchover to Atria ClearCase from earlytackling separate product sets one at a time.

Our project migrated later, when there was already some experience with CC. Partly because I insisted on it, we embedded version control information in the source files via a check-in trigger. This lasted a while – but only a while – because, as VonC states, it leads to merge hell. And that conflict has to be resolved manually, rather than being handled automatically. ID keywords take tuorial formats, one for files being edited and one for files that are not being edited:. RCS also has a keywords mechanism, and the keywords also take two formats, though one is for files which have not yet been inserted into RCS and the other is for those that have:.

I’ve not done enough merging with RCS to be sure what it does tutoriial keyword information, but I note that if it treated both the expanded and ‘contracted’ notations as equivalent regardless of the content of the expanded materialthen merging could take place without conflict, leaving the contracted notation in the output of the merge, which would be appropriately expanded when the resulting file is retrieved after checkin.

As I’ve indicated in my discussion of SCCS and RCS, if 3-way merging is done treating the keywords in the correct contracted or editable formats, then there is no merge conflict. The problem with CC from this futorial – clearly, the implementors of CC disagree is that it lacks a system for handling keywords, and therefore also lacks an appropriate merge manager.

I’m sure that this little bit of extra work is the reason why it is not supported, something I’ve always felt was shortsighted in such a powerful system. I like to have the metadata in the source code because my source code as opposed to my employer’s source code is distributed outside the aegis of the clearcxse code control system. That is, it is mostly open source – I make it available to all and sundry.

If someone reports a problem in a file, especially in a file they’ve modified, I think it is helpful to know where they started from, and that’s represented by the original metadata clearcwse the source file. Consequently, even if someone takes a chunk of my source code and modifies it, there are usually labels enough in it to identify where it came from, rather than leaving me to speculate about which version it is based on.


Getting started with UCM

And that, in turn, makes it easier to see what parts of the problem are of my making, and what parts are of their making. Now, in practice, the way open source works, people don’t migrate code around as much as you might think. They tend to stick with the released version fairly closely, simply because deviating is too expensive when the next official release is made.

I’m not sure how you are supposed to determine the base version of a piece of source code that originated clearacse your work and has been revised since then. Finding the correct version, though, seems key to doing that, and if there are fingerprints in the code, then it can be easier. So, that’s a moderate summary of why I like to embed the version information in the source files. It may be ancient relic, something to be bidden farewell in the era of DVCS.

But I’m not yet claercase convinced by that.

Rational ClearCase – Wikipedia

However, it might take still more of an essay to explain the ins and outs of my release management mechanism to see why I do things as I do. One aspect of the reasoning is that key files, such as ‘stderr.

When I release a program that uses it, I simply ensure I have the most recent version – unless there’s been an interface change that requires a back-version. I haven’t had that problem for a while now I did a systematic renaming in ; that caused some transitional headaches, tutprial Perl scripts allowed me to implement the renaming pretty easily. I don’t tutirial how many programs use that code – somewhere between and would be a fair guess.

This year’s set of changes the version 9. They are also internal to the implementation and do not affect the external interface, so I don’t have to make up my mind just yet. I’m not sure how to handle c,earcase using git.

I don’t want to build the library code into a library that must be installed before you can build my software – that’s too onerous for my clients.

So, each program will continue to be distributed with a copy of the library code a different sort of onerousbut only the library code that the program needs, not the whole library.

And I pick and choose for each program which library functions are used. So, I would not be exporting a whole sub-tree; indeed, the commit that covered the last changes in the library code is typically completely unrelated to the commit that covered the last changes in the program.

I’m not even sure whether git should use one repository for the library and another tutorkal the programs that use it, or a common larger repository. And I won’t be migrating to git until I do understand this. OK – enough wittering. What I have works for me; it isn’t necessarily for everyone. It probably means I’m the one with problems – hangups for the lost past. But I value what the past has to offer. I can get away with it because most of my code is not branched. I’m not sure how much difference branching would make.

I worked with clearcase for the better part of 6 years and generally found it tolerable. It does have a certain learning curve but once you get used to the quirks tugorial can pretty much work smoothly with it. A very competent CC admin that knows what he’s doing is essential for anything but trivial setups.

Unless you have one, people are going to run into problems and soon enough there will be talk about the “ClearCase” problem.