]>
CVS Best Practices Vivek Venugopalan
vivekv at users.sourceforge.net
 0.2 2001-11-27 vv Incorporated first round of feedback and some minor fixes 0.1 2001-11-20 vv Created CVS Best Practices This article explores some of the best practices that can be adopted while using CVS as the configuration management tool in your software projects. Introduction
Henry David Thoreau (1817-1862) Men have become the tools of their tools.
This article outlines some of the best practices that can be adopted when &CVS; is used as the configuration management tool in your software project. &CVS; (&CVSAB;) is an &OPENSOURCE; configuration management tool that is now being looked at seriously by many commercial organizations as a viable alternative to other commercial &SCM; tools. This spotlight on &CVSAB; has led to the inevitable question of best practices for deploying &CVSAB; as the backbone &SCMAB; tool for large software development projects. Having answered this question many times verbally as a bunch of gotchas on &CVSAB;, it was time to put down on paper some of the best practices that will work well for &CVSAB; based projects. Copyright Information This document is Copyright © 2001 Vivek Venugopalan. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license can be found in . This document may be reproduced and distributed in whole or in part, in any medium physical or electronic, as long as this copyright notice is retained on all copies. Commercial redistribution is allowed and encouraged; however, the author would like to be notified of any such distributions. All translations, derivative works, or aggregate works incorporating this document must be covered under this copyright notice. That is, you may not produce a derivative work from this document and impose additional restrictions on its distribution. Exceptions to these rules may be granted under certain conditions; please contact the author at the address given below. In short, we wish to promote dissemination of this information through as many channels as possible. However, we do wish to retain copyright on the document, and would like to be notified of any plans to redistribute the same. Disclaimer No liability for the contents of this document can be accepted. Use the concepts, examples and other content at your own risk. As this is a new edition of this document, there may be errors and inaccuracies that may of course be damaging to your system. Proceed with caution, and although this is highly unlikely, the author(s) do not take any responsibility for that. All copyrights are held by their respective owners, unless specifically noted otherwise. Use of a term in this document should not be regarded as affecting the validity of any trademark or service mark. Naming of particular products or brands should not be seen as endorsements. You are strongly recommended to take a backup of your system before major installation and backups at regular intervals. New Versions The version number of this document is &DOCVERSION;. The latest version of this document can be obtained from My website The linux documentation project Credits The list of people who have provided inputs and information for this paper in no particular order are. Jens-Uwe Mager Jorgen Grahn Feedback Feedback is most certainly welcome for this document. Without your submissions and input, this document wouldn't exist. Please send your additions, comments and criticisms to the following email address : &MYEMAIL;. Focus Areas The focus areas for best practice are GUI Tools Use GUI tools for &CVSAB; client Developer Sandbox Keep System clocks in Sync Do not share the sandbox Do not work outside the sandbox Stay in sync with the repository Cleanup after completion Check-in often Server Configuration &CVSAB; Server side scripting &CVSAB; Server notification Branching and Merging Assign ownership to trunk and branches Tag each release Create a branch after each release Make bug fixes to branches only Make patch releases from branches only Change propagation Merge branch with the trunk after each release Software Builds Build early and build often Automate build process completely All necessary files must be checked in before a build Institutionalize in the Organization Implement change management Make &CVSAB; usage part of developer's objectives Collect metrics on &CVSAB; usage Using <acronym>GUI</acronym> Tools The traditional interface available for CVS is the command-line client. There has also been a slew of GUI client applications that can talk to a &CVSAB; server. These GUI clients provide a point and click interface to the &CVSAB; repository. This paper recommends using such GUI clients during the initial deployment of &CVSAB; in an organization. Developers typically use integrated development environments that have the CM tools integrated into them. These tools minimize the learning for the developers about the intricacies of &CVSAB; usage and instead allow them to be productive from day one. Developers who are accustomed to other CM tools will find the &CVSAB; command-line interface daunting. The adoption and usage of &CVSAB; can be improved by using GUI tools for &CVSAB; clients. GUI tools for &CVSAB; are available at www.cvsgui.org. GUI interfaces are available for most of the popular platforms (Windows, Mac and Linux). In addition, on the Windows platform there is an SCC extension that allows integration of &CVSAB; as the configuration control tool with popular IDE. Developer Sandbox The developer sandbox is where each developer keeps his or her working copy of the code base. In &CVSAB; this is referred to as the working directory. This is where they build, test and debug the modules that they are working on. A sandbox can also be the area where the staging build or the production build is done. Changes made in the work area are checked into the &CVSAB; repository. In addition, changes made in the repository by others have to be updated in the sandbox on a regular basis. The best practices related to developers sandbox are: Keep System clocks in Sync &CVSAB; tracks change to source files by using the timestamp on the file. If each client system date and time is not in sync, there is a definite possibility of &CVSAB; getting confused. Thus system clocks must be kept in sync by use of a central time server or similar mechanism. &CVSAB; is designed from ground up to handle multiple timezones. As long as the host operating system has been setup and configured correctly, &CVSAB; will be able to track changes correctly. Do not share the sandbox Sandboxes have to be unique for each developer or purpose. They should not be used for multiple things at the same time. A sandbox can be a working area for a developer or the build area for the final release. If such sandboxes are shared, then the owner of the sandbox will not be aware of the changes made to the files resulting in confusion. In &CVSAB;, the sandbox is created automatically when a working copy is checked out for a &CVSAB; project using the cvs checkout {project-name} command. In very large projects, it does not make sense for the developers to check-out the entire source into the local sandbox. In such cases, they can take the binaries generated by the build team on a regular basis for all those components of the application that is not changed by them and only check-out the parts that are built by the developer. For example, in a Java project, the build team can keep the results of their last successful build in a standard location in the form of JAR files on the network file servers. Individual developers will use a standard classpath setup that has the network drives mounted on standard paths. Thus the developers will automatically get the latest version of the files as required by them. Do not work outside the sandbox The sandbox can be thought of as a controlled area within which &CVSAB; can track for changes made to the various source files. Files belonging to other developers will be automatically updated by &CVSAB;. Thus the developer who lives within the sandbox will stand to gain a lot of benefits of concurrent development. This benefit cannot be achieved for work done outside a sandbox. Stay in Sync with the repository To gain the benefits of working within a sandbox as mentioned above, the developer must keep his or her sandbox in sync with the main repository. A regular cvs update with the appropriate tag or branch name will ensure that the sandboxes are kept up to date. Cleanup after completion Make sure that the sandbox is cleaned up after completion of the change. This can be done in &CVSAB; by using the cvs release command. This ensures that no old version of the code exists in the development sandbox. As explained previously, pre-built binaries from the build team can be used to ensure that all the parts of the application are available to the developer without the need for a complete compilation in the sandbox. Check-in Often To help other developers keep their code in sync with your code, you must check-in your code often into the &CVSAB; repository. The best practice would be to check-in soon as a piece of code is completed, reviewed and tested, check-in the changes using a cvs commit to ensure that your changes are committed to the &CVSAB; repository. &CVSAB; promotes concurrent development. Concurrent development is possible only if all the other developers are aware of the ongoing changes on a regular basis. One of the bad practices that commonly occur is sharing of source code files between developers by email. This works against most of the best practices mentioned above. To share source code updates between two developers, &CVSAB; must be used as the communication medium. This will ensure that &CVSAB; is aware of the code change and can track them. Thus, audit trail can be established if necessary. Server Configuration This section deals with best practices for &CVSAB; server side setup and configuration. Server side scripting Server side scripting refers to the ability to make &CVSAB; server execute certain scripts when an event occurs. I am currently not aware of any best practices in this area. Suggestions are welcome. Server Notification The &CVSAB; server can be configured to notify through e-mails in the event of a commit happening. This can be used to verify if code commits are occurring during the course of a release build. If such commits occur, based on the project policy, such commits can be ignored or the entire build automatically restarted. Branching and Merging Branching in &CVSAB; splits a project's development into separate, parallel histories. Changes made on one branch do not affect the other branches. Branching can be used extensively to maintain multiple versions of a product for providing support and new features. Merging converges the branches back to the main trunk. In a merge, CVS calculates the changes made on the branch between the point where it diverged from the trunk and the branch's tip (its most recent state), then applies those differences to the project at the tip of the trunk. Assign Ownership to Trunk and Branches The main trunk of the source tree and the various branches should have a owner assigned who will be responsible for. Keep the list of configurable items for the branch or trunk. The owner will be the maintainer of the contents list for the branch or trunk. This list should contain the item name and a brief description about the item. This list is essential since new artifacts are always added to or removed from the repository on an ongoing basis. This list will be able to track the new additions/deletions to the repository for the respective branch. Establish a working policy for the branch or trunk. The owner will establish policies for check-in and check-out. The policy will define when the code can be checked in (after coding or after review etc.,). Who is responsible to merge changes on the same file and resolve conflicts (the author or the person who recently changed the file). Identify and document policy deviations Policies once established tend to have exceptions. The owner will be responsible for identifying the workaround and tracking/documenting the same for future use. Responsible for merge with the trunk The branch owner will be responsible for ensuring that the changes in the branch can be successfully merged with the main trunk at a reasonable point in time. Tag each release After each release, the entire code base must be tagged with an identifier that can help in uniquely identifying the release. A tag gives a label to the collection of revisions represented by one developer's working copy (usually, that working copy is completely up to date so the tag name is attached to the latest and greatest revisions in the repository). The identifier for the tag should provide enough information to identify the release at any point in time in the future. One suggested tag identifier is of the form. release_{major version #}_{minor version #} Create a branch after each release After each software release, once the &CVSAB; repository is tagged, a branch has to be immediately created. This branch will serve as the bug fix branch for that release. This branch is created only if the release is not a bug fix or patch release. Patches that have to be made for this release at any point in time in the future will be developed on this branch. The main trunk will be used for ongoing product development. With this arrangement, the changes in the code for the ongoing development will be on the main trunk and the branch will provide a separate partition for hot fixes and bug fix releases. The identifier for the branch name can be of the form. release_{major version #}_{minor version #}_patches Make bug fixes to branches only This practice extends from the previous practice of creating a separate branch after a major release. The branch will serve as the code base for all bug fixes and patch release that have to be made. Thus, there is a separate repository sandbox where the hot fixes and patches can be developed apart from the mainstream development. This practice also ensures that bug fixes done to previous releases do not mysteriously affect the mainstream version. In addition, new features added to the mainstream version do not creep into the patch release accidentally. Make patch release from branches only Since all the bug fixes for a given release are done on its corresponding branch, the patch releases are made from the branch. This ensures that there is no confusion on the feature set that is released as part of the patch release. After the patch release is made, the branch has to be tagged using the release tagging practice (see ). Change Propagation Change propagation practices explore how changes made to one version of the application are migrated to other living versions of the application. Merge branch with the trunk after release After each release from a branch, the changes made to the branch should be merged with the trunk. This ensures that all the bug fixes made to the patch release are properly incorporated into future releases of the application. This merge could potentially be time consuming depending on the amount of changes made to the trunk and the branch being merged. In fact, it will probably result in a lot of conflicts in &CVSAB; resulting in manual merges. After the merge, the trunk code base must be tested to verify that the application is in proper working order. This must be kept in mind while preparing the project schedule. In the case of changes occuring on branches for a long period of time, these changes can be merged to the main branch on a regular basis even before the release is made. The frequency of merge is done based on certain logical points in the branch's evolution. To ensure that duplicate merging does not occur, the following practice can be adopted. In addition to the branch tag, a tag called {branch_name}_MERGED should be created. This is initially at the same level as the last release tag for the branch. This tag is then moved after each intermediate merge by using the -F option. This eliminates duplicate merging issues during intermediate merges. Software Builds This section deals with the best practices for software builds. Build is the process of creating the application binaries for a software release. They are done in a periodic manner in development teams to provide baseline binaries for daily work. Build Early and Build Often (<acronym>BEBO</acronym>) A slight variation of this adage has been around in the &OPENSOURCE; community called "Release Early and Release Often" for quite some time albeit for a different reason. BEBO helps a development team identify issues that can arise from checking in the wrong files. BEBO will address integration issues at the application level that might have slipped passed individual developer builds. It will also improve the team morale when they see a working version of the application. Builds must be done on a regular basis. There should be a dedicated resource(s) assigned to do the same. The entire project team must be trained to view the daily build as an important activity and not as a chore. Builds must be completed without any failures on a regular basis. Build failures must be a rare event and should be treated with utmost seriousness. The project team should ensure that successful builds are top priority on their agenda. The seriousness can be emphasised by setting up a penalty for breaking the build. Automate Build Process completely Another key practice for software builds is to automate the build process completely. The automation process must also include automatic retrieval of the right source files from the &CVSAB; repository. This ensures that the build process is completely repeatable and consistent. In addition, the chances of a build with the wrong version of the application source files are reduced to a large degree. By automating the build process, the task of building often becomes less burdensome. All necessary files must be checked before build This adage sounds trivial at first but this problem is very common even with experienced development teams due to oversight. The problem of oversight cannot be easily addressed since the onus is on the individual developer to ensure that his or her file has been checked in. This practice should be drummed into the team in the form of trainings and pre-build announcements to ensure that the right version of source code is available in the repository. Automated build process as explained above will help in catching this problem to a certain degree since they will automatically take the source code from the &CVSAB; repository and perform the software build. Any missed items will surface during the build process itself (makefiles etc.,) or during the regression testing of the product (older version of the file checked in). A penalty based system can be setup to handle wrong check-in. Having a kitty for a post project party to which each person who makes a wrong check-in will contribute a fixed amount will act a good penalty system. Institutionalize &CVSAB; in the Organization Here we will look at the best practices for institutionalizing &CVSAB; usage in the organization. Implement Change Management Process All organizations must implement a good Change management process (CMP). A good CMP will define how changes are received and recorded, tracked, executed and delivered. &CVSAB; provides version control for your project. Change management addresses the bigger picture of how enhancements and bugs are received, tracked and closed. &CVSAB; will play a smaller but a very important part in this entire picture. With a formal change management process in place in the organization, tools such as &CVSAB; will be looked at as aiding this process instead of acting as a general development overhead. Change management is quite a vast topic that cannot be done justice here. Please look up some websites on change management. Make &CVSAB; Usage part of Objectives To institutionalize &CVSAB;, it can be made as part of the annual objectives for the developer to use it as part of his or her project. In addition, it can also be made as part of the objective for the project manager to deploy &CVSAB; in his or her project. Compliance of this can then be reviewed as part of the appraisal cycle for the employee. Collect metrics on &CVSAB; usage &CVSAB; usage metrics can be collected in terms of percentage of deployment in the organization, project size handled etc., This information will spur other line managers and program managers to look at &CVSAB; as a tool that will aid them in their daily operations. Conclusion These best practices are meant to help software teams get a head start on using &CVSAB; for their development. The ideas presented here have to be constantly reviewed and evolved. I would like this to be a growing and evolving document. Please send your comments and ideas to &MYEMAIL; &GFDL-FILE;