Thursday, January 12, 2012

SVN is dead. Long Live SVN

I prefer GIT, but SVN is widespread too. Even though SVN is not very old (it is only 12 years old) but it represents a clone of, rather than a re-imagining of, the antiquated CVS tool (released around 1989). CVS was itself a reworking of the (at the time) popular RCS tool first seen around 1982. RCS inherited its good looks from SCCS, created in 1972 for an IBM System/370.

(Dodo credit Wikimedia Commons)

So the core concepts that frame up SVN are over forty years old. The workflows have changed with each re-implementation, but the basic approach to version control is pretty similar. Vaguely, the way these tools work can be characterized by a few features:

  1. there is a single central point of update 
  2. changes are tracked one file at a time
    • it is left to the user to use labeling and other tool features to ensure that sets and subsets of files corresponding to systems and modules are self-consistent and sane configurations 
    • histories must be computed in a more or less unbroken chain
  3. filesystem level changes, and special file types, are not tracked well, or not at all
    • renames are not well tracked
    • file history can easily be lost 
  4. higher level constructs for configuration versioning are missing 
    • no symbolic tagging 
  5. branching is clumsy, heavyweight, long-lived, and error-prone
  6. data and metadata access is rigid and fragile, but fast
    • repositories are exposed to corruption from trivial user level actions
    • SVN is both faster and more robust, but still trivially easy to corrupt by network errors and faulty clients
OK, maybe this is being a bit unfair, incomplete, abstract, and irrelevant as judged by an SVN expert.  I admit to having completely lost interest in the SCCS evolutionary branch of VCS's when Tom Lord's Arch (tla) arrived on the scene in 2001.
(Original finch image credit Wikipedia Commons)

The vine that was TLA died but not before sparking a vibrant ecosystem of competing Distributed Revision Control systems.  My recollection could have gaps, but to my mind Tom Lord never really got the credit he deserved for this innovation. Mercurial and GIT are two modern representatives of this evolutionary genus. 

(Cheetah credit Wikimedia Commons)

While the SCCS->RCS->CVS->SVN branch has thrived in the open source community, it remains a rather stilted lineage. This isn't because SVN is a mature tool now (although it is).  Rather, it is because SCCS had fixed in place a large number of decision points that were not (or could not be) revisited even when its descendants broadened and matured the design. Up to a gross approximation of workflow, SCCS == RCS == CVS == SVN. Further diversification has a very high cost and low payback, and so no richness of form will arise from that fount.

For a more positive spin, read about the advantages of a distributed VCS on ThinkVitamin.