Purpose of VCSs

There are two reasons why people used VCSes

1. For Backup

   As a backup mechanism. Remember the assignment where you had to code in 30 features for satisfying all the requirements. After 20 features, you find that the code works. You code in feature number 21, changing most of the code here and there while doing so. Suddenly, you realize that most of the first 20 features stopped working. You do not even get credits for what you managed to finish.

   Many people keep creating backup tarballs of their code. This not only clutters the directory, but also isn't very space-efficient. Instead of storing just the changes, you ended up storing the entire directory. VCSs elegantly solve this problem.

2. For Collaboration and Easy Merging

   VCS[Version Control System]s are used to ease out collaboration among different developers who are working on the same codebase. Older VCSs like CVS and SVN worked on the basis of a centralized repository that contained the master-codebase. If you are a developer, you checkout the codebase into a local repository, make the changes in the local copy and when done, commit the code which copies it back to the central master-codebase.

   If this did not exist, there wouldn't be productivity. Assume the case where Alice makes changes to files 1 and 2 while Bob makes changes to files 3 and 4. Now, Alice and Bob in turn would have copied from some codebase. So both Alice and Bob here have different current-versions of the code. If we did not have VCS only one of the two would be able to code at a given point of time. The other would have to wait till the first finished writing. This is a terrible waste of time if the files that Alice and Bob modified do not conflict with each other.

   This is the problem that version control systems solve. They even allow merging changes to the same file as long as the lines where the changes occur do not overlap. In this case, the user is alerted to first fix the conflicts using other tools.

   Modern VCSs

   We have come a long way since the time RCS and CVS were used [They are still used today, but it is strongly adviced that one uses a DVCS for any new project.]. Git, Mercurial, Monotone, Darcs among several others are Distributed Version Control Systems or DVCS in short. There is no master-codebase [though that can be achieved through an agreement among developers]. In these DVCSes, each repository is standalone. So your repository can be cloned from by another person. This is different from the original SCMs where all check-outs were done only from the central codebase. These leads to a more free and flexible development model. Huge codebases like the Linux Kernel, the Mozilla Project and Python have now moved to DVCSs