Concurrent Versions System

Short description: Historical centralized version control system

Concurrent Versions SystemDeveloper(s)| The CVS Team

|

Initial release| November 19, 1990; 35 years ago (1990-11-19)
Stable release|

1.11.23[1] / May 8, 2008; 18 years ago (2008-05-08)

Preview release|

1.12.13[2] / September 28, 2005; 20 years ago (2005-09-28)

Written in| C
Operating system| Unix-like, Windows
Type| Revision control
License| GPL-1.0-or-later[3]
Website| cvs.nongnu.org

Concurrent Versions System (CVS, or Concurrent Versioning System) is a version control system originally developed by Dick Grune in July 1986.[4]

CVS operates as a front end to Revision Control System (RCS), an earlier system which operates on single files. It expands upon RCS by adding support for repository-level change tracking, and a client-server model.[5]

Released under the terms of the GNU General Public License, CVS is free software.

## Contents

* 1 Design
* 2 Operation
* 3 Portability
* 4 History
* 5 Adoption and successors
* 6 See also
* 7 Notes
* 8 References
* 9 External links

## Design

CVS operates as a front end to Revision Control System (RCS), an older version control system that manages individual files but not whole projects. It expands upon RCS by adding support for repository-level change tracking, and a client-server model.[5] Files are tracked using the same history format as in RCS, with a hidden directory containing a corresponding history file for each file in the repository.

CVS uses delta compression for efficient storage of different versions of the same file. This works well with large text files with few changes from one version to the next. This is usually the case for source code files. On the other hand, when CVS is told to store a file as binary, it will keep each individual version on the server. This is typically used for non-text files such as executable images where it is difficult to create compact deltas between versions.

CVS excludes symbolic links because when they are stored in a version control system they can pose a security risk. For instance, a symbolic link to a sensitive file can be stored in the repository, making the sensitive file accessible even when it is not checked in. In place of symbolic links, scripts that require certain privileges and conscious intervention to execute may be checked into CVS.[citation needed]

## Operation

CVS labels a single project (set of related files) that it manages as a module. A CVS server stores the modules it manages in its repository. Programmers acquire copies of modules by checking out. The checked-out files serve as a working copy, sandbox or workspace. Changes to the working copy are reflected in the repository by committing them. To update is to acquire or merge the changes in the repository with the working copy.

CVS uses a client–server architecture: a server stores the current version(s) of a project and its history, and clients connect to the server in order to "check out" a complete copy of the project, work on this copy and then later "check in" their changes. CVS servers can allow "anonymous read access",[6] wherein clients may check out and compare versions with either a blank or simple published password (e.g., "anoncvs"); only the check-in of changes requires a personal account and password in these scenarios. Several developers may work on the same project concurrently, each one editing files within their own "working copy" of the project, and sending (or checking in) their modifications to the server. To avoid conflicts, the server only accepts changes made to the most recent version of a file. Developers are therefore expected to keep their working copy up-to-date by incorporating other people's changes on a regular basis. This task is mostly handled automatically by the CVS client, requiring manual intervention only when an edit conflict arises between a checked-in modification and the yet-unchecked local version of a file. Clients can also use the "update" command to bring their local copies up-to-date with the newest version on the server. Clients can also compare versions, request a complete history of changes, or check out a historical snapshot of the project (e.g.: based on a given date). If the check-in operation succeeds, then the version numbers of all files involved automatically increment, and the server writes a user-supplied description line, the date and the author's name to its log files. CVS can also run external, user-specified log processing scripts following each commit. These scripts are installed by an entry in CVS's `loginfo` file, which can trigger email notification or convert the log data into a Web-based format.

CVS can also maintain different "branches" of a project. For instance, a released version of the software project may form one branch, used for bug fixes, while a version under current development, with major changes and new features, can form a separate branch. CVS assumes that the majority of work takes place on the trunk, and that branches should generally be short-lived or historical. When used as designed, branches are easily managed and branch operations are efficient and fast.[7][8]

## Portability

The server software normally runs on Unix (although at least the CVSNT server also supports various flavors of Microsoft Windows), while CVS clients may run on any major operating system platform.

## History

Grune recalled:[9]

> I created CVS to be able to cooperate with my students, Erik Baalbergen and Maarten Waage, on the ACK (Amsterdam Compiler Kit) C compiler. The three of us had vastly different schedules (one student was a steady 9-5 worker, the other was irregular, and I could work on the project only in the evenings). Their project ran from July 1984 to August 1985. CVS was initially called cmt, for the obvious reason that it allowed us to commit versions independently.

Grune publicly released the code on June 23, 1986.[10]

The code that eventually evolved into the current version of CVS started with Brian Berliner in April 1989, with later input from Jeff Polk and many other contributors. Brian Berliner wrote a paper introducing his improvements to the CVS program—which describes how the tool was extended and used internally by Prisma, a third-party developer working on the SunOS kernel, and was released for the benefit of the community under the GPL.[11] On November 19, 1990, CVS version 1.0 was submitted to the Free Software Foundation for development and distribution.[12]

The latest version was released on 8 May 2008.[13]

## Adoption and successors

> In the world of open source software, the Concurrent Version System (CVS) has long been the tool of choice for version control. And rightly so. CVS itself is free software, and its non-restrictive modus operandi and support for networked operation—which allow dozens of geographically dispersed programmers to share their work—fits the collaborative nature of the open-source world very well. CVS and its semi-chaotic development model have become cornerstones of open-source.[14]

Over time, developers have created new version control systems based on CVS in order to add features, alter the operational model, and improve developers' productivity. CVS replacement projects include CVSNT and Subversion.[15][16]

## See also

* Comparison of version-control software
* Cervisia
* OpenGrok
* StatCVS
* TortoiseCVS
* ViewVC

## Notes

1. ↑ Stable CVS Version 1.11.23 Released!
2. ↑ CVS Feature Version 1.12.13 Released! * Security Update *
3. ↑ "Contents of /ccvs/README". https://cvs.savannah.nongnu.org/viewvc/cvs/ccvs/README?view=markup.
4. ↑ "CVS--Concurrent Versions System v1.12.12.1: Overview". http://ximbiot.com/cvs/manual/cvs-1.12.12/cvs_1.html.
5. ↑ 5.0 5.1 Stopak, Jacob (November 30, 2019). "The Evolution of Version Control System (VCS) Internals". https://initialcommit.com/blog/Technical-Guide-VCS-Internals.
6. ↑ "Opening The Source Repository With Anonymous CVS, USENIX 1999". 1999. http://www.openbsd.org/papers/anoncvs-paper.pdf.
7. ↑ Collins-Sussman, Ben; Greg Ward (September 2004). "Subversion Users: Re: Performance (Subversion vs. CVS)". subversion-users. http://svn.haxx.se/users/archive-2004-09/0681.shtml.
8. ↑ West, Adrian (July 2004). "cvs branchtag performance fix". http://www.adrianwest.org/cvs_perf_fix/cvs_perf_fix.htm.
9. ↑ "Concurrent Versions System CVS". https://dickgrune.com/Programs/CVS.orig/.
10. ↑ Dick Grune (July 3, 1986). "CVS, an RCS front-end (cvs)". Newsgroup: mod.sources. Usenet: 122@mirror.UUCP. Retrieved September 14, 2016.
11. ↑ "CVS II: Parallelizing Software Development - Berliner (ResearchIndex)". http://citeseer.ist.psu.edu/berliner90cvs.html.
12. ↑ "[cvs Contents of /ccvs/NEWS"]. http://cvs.savannah.gnu.org/viewvc/cvs/ccvs/NEWS?view=markup&revision=1.1.
13. ↑ "Concurrent Versions System - News: Stable CVS Version 1.11.23 Released! [Savannah"]. http://savannah.nongnu.org/forum/forum.php?forum_id=5309.
14. ↑ Ben Collins-Sussman, Version Control with Subversion For Subversion 1.1, 2005
15. ↑ "Subversion FAQ: Why does this project exist?". Subversion. http://subversion.apache.org/faq.html#why.
16. ↑ "Dispelling Subversion FUD". Ben Collins-Sussman. http://www.red-bean.com/sussman/svn-anti-fud.html.

## References

* David Thomas; Andrew Hunt (2003). Pragmatic Version Control Using CVS. The Pragmatic Programmers. ISBN 0-9745140-0-4. https://archive.org/details/pragmaticversion00thom.
* Jennifer Vesperman (2006). Essential CVS (2e ed.). O'Reilly. ISBN 0-596-52703-9.
* Per Cederqvist (2002). Version Management with CVS. ISBN 0-9541617-1-8. http://www.network-theory.co.uk/docs/cvsmanual/. Retrieved 2009-11-25.
* Karl Franz Fogel; Moshe Bar (2003). Open Source Development with CVS. ISBN 1-932111-81-6. http://cvsbook.red-bean.com/. Retrieved 2002-02-05.

## External links

* Official website
* Version Management with CVS: manual for CVS 1.12.13, by Per Cederqvist et al.

* v
* t
* e

Version control software

Years, where available, indicate the date of first stable release. Systems with names in italics are no longer maintained or have planned end-of-life dates.

Local only|

| Free/open-source|

* RCS (1982)
* SCCS (1972)

|

Proprietary|

* PVCS (1985)
* QVCS (1991)

Client–server|

| Free/open-source|

* CVS (1986, 1990 in C)
* CVSNT (1998)
* QVCS Enterprise (1998)
* Subversion (2000)

|

Proprietary|

* AccuRev SCM (2002)
* Azure DevOps
* Server (via TFVC) (2005)
* Services (via TFVC) (2014)
* ClearCase (1992)
* CMVC (1994)
* Dimensions CM (1980s)
* DSEE (1984)
* Endevor (1980s)
* Integrity (2001)
* Panvalet (1970s)
* Perforce Helix (1995)
* SCLM (1980s?)
* Software Change Manager (1970s)
* StarTeam (1995)
* Surround SCM (2002)
* Synergy (1990)
* Team Concert (2008)
* Vault (2003)
* Visual SourceSafe (1994)

Distributed|

| Free/open-source|

* ArX (2003)
* BitKeeper (2000)
* Codeville (2005)
* Darcs (2002)
* DCVS (2002)
* Fossil (2007)
* Git (2005)
* GNU arch (2001)
* GNU Bazaar (2005)
* Mercurial (2005)
* Monotone (2003)
* Veracity (2010)

|

Proprietary|

* Azure DevOps
* Server (via Git) (2013)
* Services (via Git) (2014)
* TeamWare (1992)
* Code Co-op (1997)
* Plastic SCM (2006)

Concepts|

* Baseline
* Branch
* Changeset
* Commit
* Data comparison
* Delta compression
* Fork
* Gated commit
* Interleaved deltas
* Merge
* Monorepo
* Repository
* Tag
* Trunk

* Category
* Comparison
* List

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Concurrent Versions System. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Software:Concurrent_Versions_System&oldid=452600"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template