Software developers have a pretty good thing going: Software configuration management (SCM) discipline and tools that bring order to the chaos of everyone working on the same thing at the same time. SCM comes relatively easily to software developers because the product of our efforts is software, and it seems only just that software be managed by other software. But these days, the fruits of many other fields are also rendered electronically. Can SCM be applied to these other kinds of content?
Some practices are so similar to software development that they naturally benefit from the application of SCM. Web site creation bears a strong resemblance to software development. Integrated circuit design, too, has a decidedly software bent. Modern chips are created and debugged entirely in software before the layout is projected onto the silicon.
Other fields aren't so software-ish, and using SCM is more speculative. For example, my sister is a product engineer for a jeans maker. Drawing from a designer's sample, her work results in instructions for mass production of the garment. Like software, these instructions undergo iterative refinement and cooperative contribution. The difficulties she faces managing her work—keeping track of which versions are in use where—echo those of software developers. Likewise, a friend of mine oversees the construction and maintenance of reservoirs at the local water utility. These reservoirs have many minor (and sometimes major) upgrades over their lives. On rare occasions, he has actually seen his metal and concrete tanks, but most of his engineering is done at the computer, managing the evolution of the plans that detail the reservoirs. Stretching further, we also see that many legal contracts are developed iteratively, and large-scale legal assaults (or defenses) are the sum efforts of many lawyers.
Can SCM help? The three biggest benefits of SCM are also the simplest, and they work for all content:
- SCM provides a repository, so we know where our product is.
- SCM provides versioning, so we can revisit the way things were.
- SCM provides history, so we know who contributed and what.
A central repository brings a benefit so profound it's hard to imagine a business where it wouldn't be critical. A repository provides the single destination for a worker's efforts, and checking changes into the repository formalizes the ritual in which workers offer their contributions. The simple answer "it's checked in" replaces a myriad of more mysterious possibilities. No longer is the finished work on a floppy disk, a hard drive, or in some directory on some machine—it's in the repository. Be they a secret new chip design, specifications for century-old jeans construction, or stacks of legal briefs, it's good to know where the company's assets are.
Being able to revisit past versions is equally critical. The obvious use, resurrecting a working version of a now broken program, is probably less important than the converse—being able to regress to a past, broken version to study its liabilities. At Perforce Software, we treat our End User License Agreement (EULA) as such, frequently reviewing old versions to ensure we're complying with earlier promises to customers.
And no one can do without history—being able to lay blame on the person who dragged something from bad to worse or (more constructively) to gain enlightenment from the person who made a good thing better. When the company's network backbone suddenly slows down (or better, speeds up), it's handy to have those router configurations under SCM's watchful eye.
There is a piece of SCM that defies easy application to nonsoftware—diffing and merging—which is of great assistance when reviewing the history of some source code. We can compare two versions line-by-line and usually make sense of it. Further, comparison by programs leads to merging by programs. But what about content from other domains, stored in proprietary formats? What can an SCM tool do?
A poor man's solution is to hook into whatever comparison mechanism is available for the given content. Microsoft Word, for example, does a half-decent job redlining legal contracts. But a better solution would be if content were stored in a universal format, so that a content-unaware SCM tool could make markups after a generic comparison. This may be possible if the world moves towards XML, as it is capable both of encoding content and of being decipherable by generic comparators. My water-utility friend says that countless hours are spent by engineers visually comparing related reservoir specifications: Automated redlined diffs would be a godsend.
When all you have is a hammer, as the saying goes, everything looks like a nail. SCM is a powerful hammer in the software development world, and deserves a swing wherever content looks like software. And XML sure makes the world look a lot like software.
