Source Control Policy

Question

I am looking for an overview of various source control policies. I just stumbled upon the Main-Line policy and would like to get to know others before moving on to the team with the team.

Can someone provide a link to the review or even give me some policy names so that I can run Google on it?

Answer 1

Paper "streaming lines: branching patterns for parallel software development" - an excellent discussion of branching patterns, such as the "main line" pattern you mention - it lists options in the form of patterns along with a discussion of anti-patterns. One of the authors is Robert Orenstein of Perforce.

Answer 2

There are no empty commit messages.

Answer 3

In our project, we use several practical rules as a commit policy. These rules help us keep each revision ready for deployment. Our rules are similar to the KDE commit policy posted here: http://techbase.kde.org/Policies/SVN_Commit_Policy . Each commit should be (from a higher to a lower priority):

• Successfully verified (compiled, tested, reviewed, FxCop'ed, etc.).
• Atomic (should contain only one logical change, fe single fix, refactoring, etc.)
• No backup (no need to add unused code, do not comment on the code, delete it, prevent accidental format changes, etc.)
• Correctly and fully commented
• Relevant current development phase (for example, refactoring should not be allowed in version support branches).
• As little as possible to comply with the previous rules.

We developed a simple tool SvnCommitChecker, a witch helps us to check some of these rules before committing svn. I plan to bring it to sourceforge in the near future with an article on the benefits of keeping a good svn change history.

Answer 4

I really liked the book Practical . Although you may not be working with Perforce, I think that chapter 7 (“How software is developed”) and chapter 8 (Basic Codeline Management) can be very useful. You could save them on Google Books .

Perforce also has many great articles on this subject. "Software Life Cycle Modeling" describes the policy.
Perforce completes the technical documentation .

And no, I do not work with Perforce.

Good luck Thomas

Answer 5

These two are basically the same:
Version Control for Multiple Flexible Commands
Configuration Management Branching Strategy

We use this strategy to stabilize the backbone and allow developers to do everything they need on their branches.

There is some problem with Subversion, because it cannot handle circular merges , but it can work by removing the development branch after each reintegration back to the trunk (does not apply to other version control systems)

Answer 6

My favorite policy: "No posting commits that do not reference tickets + Auto Trac comments for each commit": http://trac.edgewall.org/browser/trunk/contrib/trac-post-commit-hook

Answer 7

Commit variables instead of each file.

This has the following advantages:

• You can see why this single line was changed in this exact file (aha, this was a fix for bug No. 123). If you commit a per file, commit messages tend to describe the changes made to the file that you can see with diff anyway. If you commit for a change, then commit messages usually explain why the change was made in the first place.
• It is much easier to return or merge corrections / corrections.
• This helps to organize your work better, since you clearly focus on the one error / function / change that you are working on. You finish when you're done.

Some people think that this policy produces more commits, but from my experience you get fewer commits in the end. For example, you are doing refactoring that affects 50 files. After refactoring, you have one message with the message "Refactored xyz subsystem."

For larger changes, you should consider the dev-branch-per-change policy.

Answer 8

Do not register / make any changes that disrupt the assembly.