[comp.unix.questions] RCS info wanted

amir@pilat.Israel.Silvaco.COM (Amir J. Katz (Xpert)) (03/14/91)

There is an alternative to SCCS, called RCS (Revision Control System).
Questions:
1. Is this a commercial product or public domain ?
2. Where can I get more information about RCS ?
3. Is it better than SCCS ? If so, why ?

-- TIA,
--

   Amir J. Katz, System Manager

Internet:	amir@taux01.nsc.com
UUCP:		{decwrl,uunet,...}!nsc!taux01!amir
Phone:		+972 52-570713
Fax:		+972 52-570719
Snail-mail:	Amir J. Katz, Silvaco Israel Ltd.
		19 Maskit St., Herzelia, Israel

jik@athena.mit.edu (Jonathan I. Kamens) (03/16/91)

In article <AMIR.91Mar14144117@pilat.Israel.Silvaco.COM>, amir@pilat.Israel.Silvaco.COM (Amir J. Katz (Xpert)) writes:
|> There is an alternative to SCCS, called RCS (Revision Control System).
|> Questions:
|> 1. Is this a commercial product or public domain ?

  It is distributed by the Free Software Foundation under the GNU Public
License, which means that it is not public domain, but it is freely
redistributable as long as long as you meet the conditions of the GPL (which
is, basically, that you give the sources for it to anyone who asks and that
you send any changes you make back to the authors; but don't take my word for
it, read the GPL).

|> 2. Where can I get more information about RCS ?

  Anonymous ftp to prep.ai.mit.edu and grab the file /pub/gnu/rcs-5.5.tar.Z.

|> 3. Is it better than SCCS ? If so, why ?

  This is a recurring debate on the net.  Which one is better is pretty much a
matter of personal opinion, so your best bet is to grab the RCS sources and
take a look at them and decide for yourself.

  One of the biggest differences between the two (in my opinion) is that the
basic SCCS commands are very primitive and almost impossible for the user to
"just use" -- you almost certainly need some sort of front-end in order to use
SCCS effectively.  RCS, on the other hand, has useful utilities that can be
used by the user without any front-end (which isn't to say that front-ends for
RCS don't exist; they do, for example CVS, which is also distributed by the
FSF).

-- 
Jonathan Kamens			              USnail:
MIT Project Athena				11 Ashford Terrace
jik@Athena.MIT.EDU				Allston, MA  02134
Office: 617-253-8085			      Home: 617-782-0710

gwyn@smoke.brl.mil (Doug Gwyn) (03/16/91)

In article <1991Mar15.175701.17723@athena.mit.edu> jik@athena.mit.edu (Jonathan I. Kamens) writes:
>  One of the biggest differences between the two (in my opinion) is that the
>basic SCCS commands are very primitive and almost impossible for the user to
>"just use" -- you almost certainly need some sort of front-end in order to use
>SCCS effectively.

I disagree -- the BRL MUVES project (over 100,000 lines of code in numerous
files in dozens of directories, with a half dozen developers) uses SCCS to
maintain the source code, documentation, etc. and it is pretty easy to use
for routine purposes:
	admin -ifoo s.foo	# to create the initial archive
	get s.foo		# to check out the latest version
	get -e s.foo		# to check out for editing
	delta s.foo		# to check back in after editing

The main need for any sort of "front end" program occurs on Berkeley-based
systems where it is desired to strictly enforce access controls, due to
lack of kernel support for the sort of UID manipulation that SCCS relies
upon to support such usage.  However, if you simply rely on the normal
user/group permissions, as we do for the MUVES project use of SCCS, it
works adequately.

It also helps if you have an "augmented make" that knows how to deal with
the s. prefixes, and if your Makefiles for documentation etc. contain

.DEFAULT:
	$(GET) $(GFLAGS) -p s.$@ > $@

mjf@mjm.mjm.com (Mark Fresolone) (03/17/91)

One significant advantage that RCS has over SCCS is the ability to
tag any version of a file with a "symbolic version" string.  By tagging,
say, all current versions of a set of files with the same "symbolic
version" string one can essentially identify a "release".  SCCS has no
such feature, and thus is often accompanied by locally written scripts
to extract all of the file versions which make up a configuration,
store them away, and if they're good (and not so simple), retrieve them.

There is also another similar feature in RCS that we use to identify
internal configurations such as "last stable version", or "current
unit test", called the RCS "state".

While these two features alone don't qualify RCS as a full "configuration
management" package, they are very useful, and are perhaps the most
significant RCS advantage over SCCS.

Mark Fresolone					mjf@mjm.com,  rutgers!mjm!mjf
Melillo Consulting/MJM Software			908 873-0075/Fax 908 873-2250

runyan@hpcuhc.cup.hp.com (Mark Runyan) (03/19/91)

>/ amir@pilat.Israel.Silvaco.COM (Amir J. Katz (Xpert)) 
>There is an alternative to SCCS, called RCS (Revision Control System).
>Questions:
>1. Is this a commercial product or public domain ?

It comes from GNU

>2. Where can I get more information about RCS ?

"RCS - A system for Version Control", Walter Tichy, _Software_Practice_and_
  Experience_, Vol 15(7), 637-654 (July 1985)

"Design, Implementation, and Evaluation of a Revision Control System", Walter 
  Tichy, _IEEE_, 58-67, (??? 1982)

>3. Is it better than SCCS ? If so, why ?

--- Repost of a previous response I made on the subject:

A simple questions that has a complicated and long answer.

Possible short answers.

1. SCCS is supported by AT&T.  RCS isn't.

2. RCS allows you treat a set of files as a family of files while SCCS is
   meant primarily for keeping the revision history of files.  RCS has
   the ability to use symbolic names to point to sets of revisions.

3. [religious argument] RCS has an easier interface for first time users.
   SCCS has more options for determining when a specific line of code
   was added to a system.

4. RCS files are directly editable.  SCCS files should only be acted on 
   by the SCCS tools.  (While you *may* edit an SCCS file, you will have
   to recalculate the checksum using the admin program.  Also, editing
   either RCS or SCCS files is a bad idea just because mistakes are so
   easy to make and so fatal to the history of the file).

5. RCS keeps history in files with a ",v" suffix.  SCCS keeps history in
   files with a "s." prefix.  Some Make programs recognize the "s."
   prefix while having trouble with ",v" suffix.  Your mileage will vary.

6. Locks are kept in separate files for SCCS.  A lock on an RCS file is 
   kept in the RCS file.

7. RCS stores its revisions so retrieval of the latest revision is quick
   and easy, but early revisions take longer.  SCCS stores revisions so
   that recovering any given revision takes a constant amount of time which
   increases with the number of revisions stored.  (RCS uses backward
   deltas.  SCCS uses a "merged delta" concept. SCCS does *NOT* use
   forward deltas).

8. You can translate SCCS to RCS, but not the other way.  

9. They use different keywords that are expanded in the text.  For SCCS
   the keyword "%R%" is replaced with the revision number if the file
   is checked out for reading.  In RCS, the keyword $Revision$ has the
   revision number added to it when the file is checked out (either
   locked or not).

Other than that (and a few more that others may throw in) they are essentially
the same.  As a comparison of the commands:

   SCCS Command                RCS Command             Explanation
 admin -i -nfile s.file          ci file,v     Checks in the file for the
						first time, creating the
						revision history file.
 get s.file                      co file,v     Check out a file for reading.
 get -e s.file                  co -l file,v   Check out a file for modification
 delta s.file                   ci file,v      Check in a file previously
						locked
 prs s.file                     rlog file,v    Print a history of the file.
sccsdiff -rx -ry s.file  rcsdiff -rx -ry file,v  Compare two revisions.
    ???                        rcs -l file,v   Lock the latest revision
    ???                        rcs -u file,v   Unlock the latest revision.
						Possible to break another's 
						lock, but mail is sent to
						the other person to explain
						why.