Return to rcs_functs.ms CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / new / rcs / doc

Annotation of 43BSDTahoe/new/rcs/doc/rcs_functs.ms, revision 1.1.1.1

1.1       root        1: .SH
                      2: Functions of RCS (Revision Control System)
                      3: .PP
                      4: RCS manages software libraries. It greatly increases programmer productivity
                      5: by providing the following functions.
                      6: .IP 1.
                      7: RCS stores and retrieves multiple revisions of program and other text.
                      8: Thus, one can maintain one or more releases while developing the next
                      9: release, with a minimum of space overhead. Changes no longer destroy the
                     10: original -- previous revisions remain accessible.
                     11: .RS
                     12: .IP a.
                     13: Maintains each module as a tree of revisions.
                     14: .IP b.
                     15: Project libraries can
                     16: be organized centrally, decentralized, or any way you like.
                     17: .IP c.
                     18: RCS works for any type of text: programs, documentation, memos, papers,
                     19: graphics, VLSI layouts, form letters, etc.
                     20: .RE
                     21: .IP 2.
                     22: RCS maintains a complete history of changes.
                     23: Thus, one can find out what happened to a module easily
                     24: and quickly, without having to compare source listings or
                     25: having to track down colleagues.
                     26: .RS
                     27: .IP a.
                     28: RCS performs automatic record keeping.
                     29: .IP b.
                     30: RCS logs all changes automatically.
                     31: .IP c.
                     32: RCS guarantees project continuity.
                     33: .RE
                     34: .IP 3.
                     35: RCS manages multiple lines of development.
                     36: .IP 4.
                     37: RCS can merge multiple lines of development.
                     38: Thus, when several parallel lines of development must be consolidated
                     39: into one line, the merging of changes is automatic.
                     40: .IP 5.
                     41: RCS flags coding conflicts.
                     42: If two or more lines of development modify the same section of code,
                     43: RCS can alert programmers about overlapping changes.
                     44: .IP 6.
                     45: RCS resolves access conflicts.
                     46: When two or more programmers wish to modify the same revision,
                     47: RCS alerts the programmers and makes sure that one modification won't wipe
                     48: out the other one.
                     49: .IP 7.
                     50: RCS provides high-level retrieval functions.
                     51: Revisions can be retrieved according to ranges of revision numbers,
                     52: symbolic names, dates, authors, and states.
                     53: .IP 8.
                     54: RCS provides release and configuration control.
                     55: Revisions can be marked as released, stable, experimental, etc.
                     56: Configurations of modules can be described simply and directly.
                     57: .IP 9.
                     58: RCS performs automatic identification of modules with name, revision
                     59: number, creation time, author, etc.
                     60: Thus, it is always possible to determine which revisions of which
                     61: modules make up a given configuration.
                     62: .IP 10.
                     63: Provides high-level management visibility.
                     64: Thus, it is easy to track the status of a software project.
                     65: .RS
                     66: .IP a.
                     67: RCS provides a complete change history.
                     68: .IP b.
                     69: RCS records who did what when to which revision of which module.
                     70: .RE
                     71: .IP 11.
                     72: RCS is fully compatible with existing software development tools.
                     73: RCS is unobtrusive -- its interface to the file system is such that
                     74: all your existing software tools can be used as before.
                     75: .IP 12.
                     76: RCS' basic user interface is extremely simple. The novice need to learn
                     77: only two commands. Its more sophisticated features have been
                     78: tuned towards advanced software development environments and the
                     79: experienced software professional.
                     80: .IP 13.
                     81: RCS simplifies software distribution if customers
                     82: maintain sources with RCS also. This technique assures proper
                     83: identification of versions and configurations, and tracking of customer
                     84: modifications. Customer modifications can be merged into distributed
                     85: versions locally or by the development group.
                     86: .IP 14.
                     87: RCS needs little extra space for the revisions (only the differences).
                     88: If intermediate revisions are deleted, the corresponding
                     89: differences are compressed into the shortest possible form.
                     90: .IP 15.
                     91: RCS is implemented with reverse deltas. This means that
                     92: the latest revision, which is the one that is accessed most often,
                     93: is stored intact. All others are regenerated from the latest one
                     94: by applying reverse deltas (backward differences). This
                     95: results in fast access time for the revision needed most often.

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.