Wayne Babich [2] identified three fundamental problems
that he had seen happen in the coordination of individual
people’s work in a team: shared data, simultaneous update
and double maintenance. The shared data problem happens
in situations where a problem is caused by the changes of
other people – changes that we were not aware of. The
simultaneous update problem happens when someone
accidently overwrites and removes someone else’s change.
The double maintenance problem happens when something
is copied – and changes are made to one of the copies. In
order to keep the two copies identical the exact same change
has to be made in the other copy too. We can never hope to
completely eliminate these problems, but by clever use of
processes and tools we can hope to be able to manage them.
Peter Feiler [8] distilled work models of version control
tools. They introduce the concept of a workspace to isolate
people from other people’s changes and unexpected Shared
Data problems. Tools perform concurrency checks to avoid
the Simultaneous Update problem by not allowing a commit
to the repository if someone else has already committed a
change. However, there are still subtle ways in which other
people’s changes can accidentally be removed. Merge
functionality helps manage the Double Maintenance problem
by automatically integrating the changes in one copy into
another copy. For the synchronization of people’s work early
tools provided locking mechanisms to stop parallel work on
the same components, but gradually moved towards a more
relaxed model that allows parallel work since there is tool
support to merge possible parallel changes. The transaction
model changed from a very simplistic model where people
were focused on single files that were committed one at a
time towards the concept of logical changes where a set of
changes are committed in one atomic operation.