Index


RISC World

Working in Sync

Paul Webb looks at the Concurrent Version System tool.

Introduction

In a situation where the management of large and collaborative development projects is becoming the norm, RISC OS users will have increasing need of an effective project management tool.

Fortunately, help is at hand in the shape of the Concurrent Version System (CVS) tool which is available as a port by John Tygat.

Background

CVS is generally thought of as a tool which is only of use to software developers whereas the program may also be used to manage projects involving website creation or some form of technical writing.

CVS is also very useful for developers who wish to keep a record and repository of a project at various stages in its inception. This facility is invaluable both for debugging purposes and for reverting to a version which, on reflection, is considered to be superior to the current version. In a similar vein, CVS allows project participants to make changes to the same part of a document or program concurrently. Indeed, CVS's ability to deal with concurrent edits is one one of its more powerful features which sets it apart from alternative management tools like the Revision Control System (RCS) or the Source Code Control System (SCCS). Finally, CVS may be used on a standalone machine as well as over a network and is available for a range of platforms including Windows, Mac and the various flavours of UNIX. There is even a JAVA client which can be obtained from www.ice.com/java/jcvs/.

The CVS Process in a Nutshell

The RISC OS port of CVS can be obtained from http://gallery.uunet.be/John.Tygat/cvs/ . The program can either be run as a command line utility or via the more customary GUI. Figure one shows CVS running from a TaskWindow whilst Figures Two and Three provide some indication of the facilities which are available in GUI mode.


Figure 1


Figure 2


Figure 3

In common with any complex tool, mastering all of the program's features can seem daunting but an understanding of a restricted range of its capabilities is sufficient to the task of getting started with the program. Assuming that a repository which holds the master copy of the project has already been created by the project maintainer, a hypothetical CVS session involving two writers might proceed as follows:

  1. Writer A withdraws or checks out a working copy of the project from the repository or library.

  2. Writer A can then begin work on the project. This may involve adding new material, deleting some of the existing material or re-organising the document's structure. Whatever writer A does, CVS is up to the task of monitoring any changes.

  3. Writer A then decides to terminate the session and consequently 'commits' or 'checks in' the working copy into the repository together with a 'log' of what has been done during that session.

  4. In a situation where writer B is working on similar parts of the document, committal of B's copy may result in what is known as a 'conflict'. If this occurs, the onus will be on B to resolve any conflicts before the process can be resumed. Thus CVS actually encourages co-workers to talk to each other about the project before further progress can be made!

  5. The changes are then applied to both A and B's working copies.

So you should now have some appreciation of the basic CVS process in action together with an awareness of key CVS terms lke checking out, committal and so forth. Indeed, it is important to realise just how much more versatile CVS is in comparison with the Revision Control System or the Source Code Control System. RCS users have for example to unlock a file before releasing it to other users. This approach is problematic where a team of developers wish to work on the same parts of a project simultaneously. CVS is therefore aptly named as it allows for true concurrent working.

A Step by Step Guide

If you intend to work with the command line version of CVS, the procedure is described below. Irrespective of your intentions, CVS usage essentially involves employing the same syntax which is as follows:

    *cvs <cvs command>

In common with most UNIX-derived tools, each command can take a combination of switches which may be global or command specific. The phrase 'cvs' will therefore be followed by range of keywords like import, update, diff or commit. You may not have encountered the import command before but it is basically used to import a project into a repository. So working with CVS as a project participant is not that difficult but there are a few features of this port which may puzzle seasoned RISC OS users. Because of CVS's UNIX pedigree, files and directories are identified by unixified file and directory naming conventions. Thus a repository on a SCSI HardDisc would be created - as John Tygat suggests - with the first of the two commands which are listed below.

   cvs -d :local:/SCSI::MyHardDisc/$/cvs/cvsroot init
   cvs -d :local:SCSI::MyHardDisc.$.cvs.cvsroot init

A Simple Example

So that's the whirlwind tour of CVS completed but what about an example which illustrates some of CVS's power? Suppose that we have created the following piece of C code which, for the sake of argument, we have called HiRisc:

void
main()
{
  printf("Hello RISC World Readers!\n");
}

If we adapt the file slightly by adding a line to the program then the program listing would read as follows:

void
main()
{
  printf("Hello RISC World Readers!\n");
  printf("And hello to all RISC OS users\n");
}

And if we apply CVS's 'context diff' facility to both files then the program generates the following output. Note that '-' or '+' respectively denote deletions or additions.

main()
{
 printf("Hello RISC World Readers!\n");
+ printf ("And hello to all RISC OS users\n");
}

Clearly therefore, CVS users have at their disposal a truly marvellous facility which is a Godsend when managing large projects. Of course, for the sake of readability, the output from this example has been ruthlessly edited but interested readers should find out about 'hunks' - a technique which CVS uses to identify diffs across a range of text.

Of course, CVS can be used just as effectively from the GUI interface although there will be an inevitable loss in functionality. If working with CVS in this way the user must first set up a New Project which can be done from the 'New Project' window (Figure Two). The various CVS actions can then be activated from the 'CVS Action' Window (Figure Three). As if this were not enough, the interface also allows the user to set a range of options like communication compression which makes zip compression available when in pserver transport mode.

Obviously, this article has only scratched the surface of what is possible with CVS but RISC OS users are also able, if they so desire, to access repositories over networks using the :server and :pserver transports although Acorn's internet stack v5 will be required.

Resources

The URL for CVS has already been alluded to in this article but you will also need a few other uilities in order to get started with CVS including RISC OS 3.1 or above. The program also makes use of filenames in excess of ten characters which means that you will require Richard Atterer's raFS from http://informatik.tu-muenchen.de/~atterer/riscos.html or Jason Tribbeck's LongFiles from www.tribbeck.com in the absence of RISC OS 4. CVS similarly requires a current version of the Acorn Toolbox Modules which are available from RISCOS Limited's website at www.riscos.com/devsupport/public.

Insofar as instructional material is concerned, there is little need to lay out hard cash in order to achieve CVS mastery. An on-line manual which is known to CVS aficionados as the 'Cedarqvist' is for example available in TeXinfo format from www.loria.fr/~molli/cvs/ and may be processed with armTeX and the TeXinfo macros. Moreover, the book Open Source Development with CVS is largely available for free from www.cvsbook.red-bean.com/ with the exception of a few chapters in HTML, Info, PostScript and TeXinfo formats. Indeed, this book is supplied with the RISC OS port as is a very informative document by the port author which describes how CVS on our platform differs from its UNIX predecessor.

There are also a variety of news groups which are pertinent to this program including gnu.cvs.help, gnu.cvs.bug and comp.software.contg-mgmt. In addition, the official CVS website at www.cyclic.com/cvs/ also contains a wealth of information. Finally, PC Card users can also make use of the CVS Windows port whilst both Windows and ARMLinux users can use Emacs and the special emacs interface pcl-cvs. Emacs for Windows 95 and NT is available from www.tardis.ed.ac.uk.

Signing Off

So just how useful is CVS? In a word, it's indispensable regardless of whether it's used for record-keeping or for project collaboration. There is lttle doubt that writing software, web pages and technical documents in a collaborative context is an intensive and error-prone process unless each co-worker is exceptionally well organised. CVS provides one possible solution to this situation so why not check it out?

Paul Webb

Index