Using CVS in an design enviroment

Hallo,

In our place we use a lot of scripts around cadence to make the design
flow smoothly.
Sometimes these scripts get improved and therefore edited.
On the other hand - to guarantee reproducability of older design data,
older "projects" must see the old scripts
In our place those scripts are stored in a global place on the system.
If I want to improve script, I ideally have to copy all the script tree to
have a new version and do the changes there.
To test a new sub - script, I also have to adapt an main script to refer
to the new sub - script to test.
Finally during testing I want only me to use the new script under test,
all the others should still see and use the older (stable) script.

In ClearCase it is possible to see a dedicated version of a file in the
absolute same unix path. That means a user using a script does not have to
care about versions of script every time he calls it - just once when
setupping which version to see.

So there comes my big questions:

Is there a way to use CVS(or its successor(s)) in a way to achieve the
wanted behaviour ?
How would I have to install/setup/use/handle it ?
Were would the scripts be installed ? Where would I call them from ?


Hope to get some answers.

 

CVS would require you to set branch tags and to communicate to the user
which branch tag he is supposed to check out the first time he checks
out from the repository. When you later do a revision to the branch, you
can move the tag, and the end user will be able to discover that there
are newer data available if he wants to know.

For most users the initial check out from the repository is so difficult
that most users avoid using CVS. This is my experience from revision
control during the last years. If your organization has some kind of
'project management' wrapper then the cvs stuff could be integrated.

Advantage with CVS is that the user can use his brain and help you debug
the scripts as there are functions for creating patches. Downside is
that each user has his/her own copy of the script. CVS is not very good
with soft-links.

 

One way that I used was to dedicate a "user" as the design system owner.

We than created a design system that was built by "cron" at known intervals.
The entire system was stored in CVS (except a few custom binaries and
libraries.)

The library <system_lib_paths>/TechX/current was a symlink to the
latestlibrary
The library <system_lib_paths>/TechX/{P,W,D,} was a symlink to the latest
controlled library

The library <system_lib_paths>/TechX/<date_string> was a recently built
library.
used for bug fixes/fixing/testinh

The library <system_lib_paths>/TechX/<n>{P,W,D,S}<nn> was a name sepcifing a
docimented (ISO)
release that had gone onto some level of testing. These were archived and
controlled.
Each letter indicated the level of control . P- Preliminary, W- Working
Copy, D - corporate Document,
S - Corporate standard.

The "user" required constant monitoring and maintainance ...

-- Good luck. It is the exceptions and management (and developers) buy in
that really
helps to build such a system.

-- G

 

All the scripts in questions go under CVS in a single
repository. Any time you want to save a particular
configuration of scripts, you 'cvs commit' them and
then 'cvs tag tagname'.

Thereafter, if you want to re-create that that set of
scripts elsewhere, you 'cvs checkout -r tagname'.

Anywhere you want.

Anywhere you want. Usually, you would set
$PATH for all users on a particular project.

-Jay-

 

Bonjour,

In my case I have the proper level of control without using a CVS/RCS
system.
Here is how it is setup:
- there are 2 directories with SKILL : dev and stable
- normal users have only stable in their skillpath
- EDA user has dev before stable in his skillpath
- when a dev file is tested/qualified, rsync is used to copy to the stable
- all the SKILL in both dev and stable does is define functions and
variables, it has no side effect on the design framework.
- projects have a cdsinit that loads SKILL files (from stable, since the
skill path has only that one.) and calls them for their side effects.


I may one day improve with autoload, so that projects code does not
need to explicitly load the files. But I so far don t feel the need for CVS.