Principles of Agile Version Control: From Object-oriented Design to Project-oriented Branching

In this article, the authors explore translation of object-oriented design principles to codelines, branching, and promotion. In addition, they expand on the concept of moving from task-based development (TBD) to project-oriented branching (POB).


Last month we looked at several principles of object-oriented design and tried to translate them into principles of version-control for task-based development with workspaces, changes, and baselines. This month we extend our translation efforts from OOD principles to codelines, branching, and promotion. The result is that we expand our scope from task-based development to project-oriented branching.

Principles of Object-Oriented Design

The principles of object-oriented design (OOD) address the need to minimize the complexity and impact of change by minimizing dependencies through the use of loosely coupled and highly cohesive classes, interfaces, and packages. These are the logical containers of software functionality. These logical entities are realized in physical containers of version control (configuration elements) in the form of files, libraries, components, and are as follows:


Principles of Class Design


The Single Responsibility Principle

A class should have one, and only one, reason to change.


The Open-Closed Principle

A class should be open for extension (of its behavior) but closed against modification (of its contents).


The Liskov Substitution Principle

Derived classes must be substitutable for (require no more, and ensure no less than) their base classes.


The Dependency Inversion Principle

Depend on abstract interfaces, not on concrete details.


The Interface Segregation Principle

Make fine grained interfaces that are client specific.


The Law Of Demeter
(Principle of Least Assumed Knowledge)

Objects and their methods should assume as little as possible about the structure or properties of other objects (including its own subcomponents).


The DRY Principle

Don't Repeat Yourself! Every piece of knowledge should have one authoritative, unambiguous representation within the system

Principles of Package Design


The Release Reuse Equivalency Principle

The granule of reuse is the granule of release.


The Common Closure Principle

Classes that change together are packaged together.


The Common Reuse Principle

Classes that are used together are packaged together.

Principles of Package Coupling


The Acyclic Dependencies Principle

The dependency graph of packages shall contain no cycles.


The Stable Dependencies Principle

Depend in the direction of stability.


The Stable Abstractions Principle

Abstractness increases with stability.



About the author

Brad Appleton's picture Brad Appleton

Brad Appleton is a software CM/ALM solution architect and lean/agile development champion at a large telecommunications company. Currently he helps projects and teams adopt and apply lean/agile development and CM/ALM practices and tools. He is coauthor of the book Software Configuration Management Patterns, a columnist for the CMCrossroads and AgileConnection communities at,  and a former section editor for The C++ Report. You can read Brad's blog at

About the author

Robert Cowham's picture Robert Cowham

Robert Cowham has long been interested in software configuration management while retaining the attitude of a generalist with experience and skills in many aspects of software development. A regular presenter at conferences, he authored the Agile SCM column within the CM Journal together with Brad Appleton and Steve Berczuk. His day job is as Services Director for Square Mile Systems whose main focus is on skills and techniques for infrastructure configuration management and DCIM (Data Center Infrastructure Management) - applying configuration management principles to hardware documentation and implementation as well as mapping ITIL services to the underlying layers.

CMCrossroads is one of the growing communities of the TechWell network.

Featuring fresh, insightful stories, is the place to go for what is happening in software development and delivery.  Join the conversation now!