One of the most powerful tools available to an information systems professional are version control systems. These software packages are designed to help track changes made to line oriented text documents. Although most commonly used by teams of programmers to manage source code, these systems are useful for far more than just this one application. Unfortunately, version control systems are also some of the most underutilized tools available to IS folks. Applying RCS and SCCS describes how one can productively use two of the most popular of these tools. Hopefully the availability of this information will help encourage the tools and methods this book describes.
The book starts out by describing source and project control, and throughout it explains many of the fundamental concepts of configuration management that are necessary for proper maintenance of software development projects. There's a lot more to be said about configuration management that is printed here, however there are many good books on this subject, so the authors should be commended for not taking up the reader's attention with an incomplete effort.
For each concept, the authors explain the general theory behind what they are trying to communicate, and then elaborate on how this is implemented separately using the two most popular and widely available version control systems available, RCS, the Revision Control System, and SCCS, the Source Code Control System. Because of this, the structure of the book flows naturally, while at the same time, the reader doesn't have to spend time studying the syntax of a system they don't use. Further, even someone who doesn't use either system can efficiently extract considerable information of value from this book. A lot of times this multi-track writing approach doesn't work so well, but the authors do a creditable job of pulling it off here.
Frankly, the subject of the book is a fairly narrow one, and this is not at all a slight. Frankly, I wish more authors would narrow the focus of their work so that they can write with more detail and provide real world examples to the reader, and we are given this opportunity in this book. Because of its narrow focus, Applying RCS and SCCS provides a great deal of specific good advice and concrete examples that would have had to be omitted in a broader work. We're fortunate that this is not the case.
Once the issues in using RCS and SCCS have been dealt with, the authors turn toward the topic of extending these systems. To do this, they introduce their own extension of these tools, which they call TCCS. Although this illustrates their concepts well, I wonder if they wouldn't have been better off using an existing, if less theoretically applicable, extension, like CVS, that is already widely in use. I doubt this book has persuaded too many people to adopt TCCS as is, so this section probably isn't as valuable to much of the book's potential audience as is the rest of it. No matter, this section can easily be skimmed without detracting from the rest of this work.
The only other items that could even be considered flaws in this book are that the authors don't spend much time talking about non-programming applications for version control systems, and the lack of a detachable quick reference card in the book. In the former case, this is not a big deal, as large software projects are by far the most complex version control environment one is likely to encounter, and it's not too hard for system administrators and document writers to figure out how to use these tools to manage their less complex environments from the information given. As to the other issue, several of the O'Reilly books that have been published recently have come with detachable quick reference cards that I believe are of questionable utility. I would actually find cards that summarized the command options for RCS and SCCS useful, so I'm a bit surprised that they weren't included.
The book is well written, and the material is well worth the time it takes to understand it. Version control tools are extremely powerful and useful, and, frankly, every information systems professional should be intimately familiar with them. It's my opinion that everyone who uses RCS or SCCS, or anyone who does not currently use a version control system should read this book and begin using one of these tools immediately. Further, any programmer who uses version control, even if it's not one of the tools covered by this book, would be well served to look over the general sections on version control issues and project management in general.
Applying RCS and SCCS is a solid book on important tools available to the information systems professional. The structure of the book permits efficient learning of those concepts that are most valuable to the specific reader while providing a narrow enough focus and sufficient depth to impart a solid understanding of the theory and practice of document control. If there is a chance that the topic of the book might seem useful, it will almost certainly be well worth reading. I give this topic my strongest recommendation, and this book does not let us down.
Click here to return to the index of reviews.