What is Version Control?

When you save a document, the latest version is written to disk and the previously saved version is lost. To save without overwriting the old file, you can use Save As. Why do this? You might make a mistake and want to revert some or all of your document to its previous state. Or you might want to have a backup in case your Mac crashes and the file gets corrupted. With diligence and Save As, you can set up a kind of “unlimited undo” system for yourself.

This is a lot of work, however, and clutters your drive with old versions of your files. Making regular backups using a utility like Retrospect can automate the backup process and use your storage more efficiently. But with either method it’s easy to lose track of the different versions of your files. Is “My Document version 46” the one where I deleted the paragraph that I need to restore? Which day’s backup has the version I need?

Version control software is designed to make it easy to manage the different versions of your files. It remembers the revisions you make and lets you tag them with comments so you remember which version is which. It stores the versions in an ultra-compressed form, saving only the differences from one version to the next, so that it’s practical to keep all the versions on your hard disk. It lets you compare and restore different versions of your files. It lets you manage groups of related files so that you can easily restore previous working states of entire projects. Finally, version control software lets a group of people work on the same documents by controlling who can make changes to what, and ensuring that everyone has the latest versions of all the files.

Version control is widely used by programmers, who need to keep track of features they’ve added and bugs they’ve fixed. If something was working yesterday but is broken today, version control makes it easy to see what changed in the interim. But while most programmers consider version control essential, most people outside that community haven’t even heard of it. That’s a shame, because most people who create documents can benefit from version control. With VOODOO Personal 2.0, Uni Software Plus has updated their version control tool to make it accessible to all Mac users. It’s still perfectly suitable for programmers, though for projects involving many developers the VOODOO Server product is a better choice.

Mac Version Control Options

This review will focus on VOODOO Personal, but let me set the stage by describing where VOODOO Personal fits in with other Macintosh version control tools. Aside from VOODOO, the most popular such tools are probably Projector and CVS.

Projector is free and part of Apple’s MPW tool suite. It started life as a command-line tool, but several utilities (VisualProjector, CMProjector, BBEdit) now provide graphical interfaces to its more common features. Nevertheless, it remains somewhat difficult to use and I was unable to find any good documentation for it. Projector is Mac-only.

CVS (Concurrent Versions System) is an open-source version control tool that’s extremely popular in the Unix/Linux world. Unlike Projector and VOODOO Personal, CVS is a client-server system, which makes it easy for multiple users, possibly scattered across the Internet, to collaborate. Although only the client runs on Classic Mac OS and Windows, the server runs on Mac OS X. In fact, Apple uses it internally to manage the development of Mac OS X, and to make their sources for the Darwin kernel available to the world. CVS’s signature feature is its use of “optimistic” locking to let multiple people work on the same file at the same time. It then automatically merges their changes and signals whether it thinks human intervention will be required to complete the merge. (It seems like it would take magic for CVS to do this reliably, but in practice it has worked very well for me.) Note that because of its Unix origins, CVS has no knowledge of Mac resource forks.

FlashBack is sort of a “lite” version control tool from Aladdin. It tracks only individual files, not whole projects, and it stores a new version every time you save (rather than at a granularity you choose). Further, there’s no way to associate comments with versions to help remember which is which. When I reviewed FlashBack for ATPM, I found it competent as a form of undo but lacking polish. It’s certainly easier to use than the other options.

Rewind is a new utility from Power On Software. Like FlashBack, it provides automatic version-control-like functionality, trading some flexibility for increased ease of use. (I’ve not used it, but apparently you can install it and forget it’s there until you need to recover an old version.) The main difference compared to the other tools listed here is that Rewind works at the level of an entire hard disk. Rather than a version control tool, I would classify it as a kind of global, unlimited undo.

VOODOO: Version Control the Mac Way

VOODOO stands for “Versions Of Outdated Documents Organized Orthogonally,” and aside from its name there are two things that make it stand out. First, it’s the only tool I know of that supports orthogonal version management—more on that later. Second, it’s the only version control tool that feels like it was built for the Mac from the ground up.

VOODOO begins with the concept of a “project,” which is a group of related files and folders whose versions you want VOODOO to manage. There’s a tree-based graphical user interface that shows the structure of your project. The tree contains the files and folders in your project, which VOODOO refers to using terms like Component Node, Structure Node, and Version Group. The VOODOO terms are a bit confusing, but they hint at some of the program’s power. In Projector and CVS, the folder structure that you work with must match the logical structure of the version control database. VOODOO can operate this way too, but it also lets you associate version group nodes in its projects with arbitrary folders on disk. For instance, even though inside the project one folder may contain another, you could choose to save them both at the same level outside the project. This provides a great deal of flexibility, especially since each user of the project can have his own set of folder mappings. However, I have no need for this much control and prefer the simpler mode.

VOODOO’s Tree View of a Project

To organize your project, you must enter VOODOO’s Design Mode. Here you can add, move, and remove files and folders to manipulate the project’s logical structure. The interface is much easier to use than in other products: you can drag and drop within VOODOO, as well as drag items in from the Finder. There’s also a contextual menu plug-in for the Finder that lets you launch VOODOO and add the selected items to a particular project, all with a single click.

VOODOO’s “non-design” mode prevents you from making changes to the project’s structure. Instead, it lets you manage the different versions of your files. The Fetch command lets you save folders or files in your project to disk. You can choose which versions to fetch. The Store command lets you save your on-disk folders or files into the project. VOODOO remembers the date and time of each store and lets you add comments so you remember what you changed. Both of these important commands are also available from inside BBEdit, CodeWarrior, and the Finder (via contextual menu).

The non-design mode is also where you can compare versions of files. Select a version of a file in the tree view, and use one of the menu commands to compare it with the current on-disk version, or with an arbitrary file that you specify. If you want to compare two non-current versions of the same file, you’ll need to fetch one of them to disk first—unlike CVS there is no easy way to compare two arbitrary versions of the same file.

VOODOO knows what changed from one version of a file to a next, and to save space it saves only the changes between versions in its project. (In fact, its “diffing” engine is more space-efficient than CVS’s because it works at the byte-level instead of the line-level.) But while VOODOO knows what changed between versions, it depends on other applications to show you the changes. BBEdit, CodeWarrior, and Microsoft Word can compare text files and graphically show you the differences. ResCompare can compare resources. For most other file types, there are no specialized tools for viewing differences, so you’ll have to compare the two versions manually.

VOODOO’s History Window. Since only the iMovie file is selected in the tree view above, the History window filters out data revisions of the other files in the project.

The History window shows all the changes to a project. These include revisions of files (“data revisions”) and changes made in design mode (“structure revisions”). It also displays Bookmarks, which are project-wide markers that you define—for instance, the above screenshot shows bookmarks for the states of the ATPM Web site when ATPM 7.01 and 7.02 were released. The History window can easily become overwhelming when you have a project with many files or many versions (or both). Therefore, it provides lots of filtering options to help you manage all the information. The checkboxes let you choose which types of revisions are displayed and let you isolate changes that a particular user has made. To further refine the display, you can select items in the tree view; then the History window will filter out the data revisions that don’t pertain to your selection.

The History window isn’t just a passive list of your revisions and comments. You can select an item in the list and click the Turn Back button to roll the project back to one of its previous states. The tree view of the project updates accordingly, and then it is easy to compare the old state of the project with the version you’ve stored to disk.

Orthogonal Version Management

Readers familiar with version control will note that I have not yet mentioned branching. Branching is a common feature that’s supported by Projector, CVS, and many other version control tools. In place of branching, VOODOO supports “orthogonal” version management based on the concept of variants. The VOODOO developers use the retronym “intermixed” to refer to the branching style of version management. A complete discussion of the orthogonal and intermixed thought models is beyond the scope of this review, but I will try to explain the basic ideas of each. Interested readers are referred to chapter nine of the VOODOO manual and the ACM SIGSOFT paper referenced therein.

The intermixed style of version management focuses on files and their branches. For instance, one could create two branches of an HTML file, one for English and one for German. At any given time there would be a current English version of the file and a current German version of it. As another example, suppose a programmer releases version 1.0 of her software. Version control software can easily remember what the source files looked like at 1.0 and it can continue tracking changes as the programmer adds features for version 2.0. But suppose that a serious bug is discovered in version 1.0, and she must release version 1.0.1 to fix it. Version 1.0.1 will not be a newer version of the (unreleased) 2.0 code, rather it will be based directly on the 1.0 source. Typically she will create version 1.0.1 by branching from the 1.0 source.

Version 1.0.1 Created as a Separate Branch. The tick marks on the lines represent stores.

The main problem with intermixed version management is that it centers around files. Each file has its own set of branches. It’s possible to branch off from a branch, creating a complex tree structure of different current versions of a file. And different files in the same project might have branches that are logically equivalent but named differently because the branches were created in a different order. If you found the preceding sentences confusing, that’s probably good, because it indicates how difficult it is to keep track of things using intermixed version management.

VOODOO’s orthogonal version management is much simpler. A project can have variants, which might be called “English” and “German” as in our Web site example above. And each file can have multiple entries in the project, one for each variant. The key difference is that variants are project-wide. VOODOO knows that the German version of file A and the German version of file B are part of the German variant. This is not the case with branches where, for the most part, the user has to keep track of which branches are related. But the real payoff comes when you consider the evolution of a project over time. Instead of a complex tree structure of revisions and branches, VOODOO’s revisions and variants are orthogonal. This makes it easy to track the revisions of each file’s variants back through time.

With VOODOO, revisions and variants are orthogonal.
(Image from the VOODOO manual.)

VOODOO also uses variants for access privileges. Each user of a project can have a separate privilege level (none, read, write) for each variant.

Strengths and Weaknesses

Although VOODOO Personal 2.0 is easier to use than previous versions, I found its interface and terminology confusing. The manual is okay and the new tutorial is a good addition, but I wish that both were more extensive. However, despite these complaints, VOODOO is much easier to use than Projector or CVS.

When several people are working on a project, VOODOO can help ensure that only one person is working on a given file at the same time. To do this, you can tell VOODOO to lock files in the project when you fetch them and unlock them when you store back your changes. VOODOO is very flexible about locking. You can choose from Finder locking or ckid locking. Or you can use no locking at all. (Unfortunately, VOODOO does not support CVS-style automatic merging.) Finder locking is like the Locked checkbox in the Finder’s Get Info window; ckid locking stores version control information in a special resource of type ckid. This is the method that Projector uses, and it is a pseudo-Mac standard. Unfortunately, many applications are not “Projector-aware” and will not preserve ckid resources when you modify and save your files. VOODOO comes out ahead because it supports ckid resources but doesn’t rely on them.

Integration with BBEdit, CodeWarrior, and the Finder is good. Of the version control tools I’ve used, VOODOO definitely fits the best into my Mac workflow. VOODOO works great with Mac files containing resource forks. Unfortunately there is no Windows (or Unix) version of VOODOO, leaving cross-platform users out in the cold.

A final advantage of VOODOO is the way it stores its project files. Unlike Projector and CVS, the project database is a flat folder of numbered files. (Don’t worry, you never have to deal with them yourself.) Projector and CVS store their files in nested folders that mirror the logical structure of the project. Thus, while Projector and CVS have trouble dealing with massive reorganizations of a project’s hierarchy, VOODOO handles structure revisions with ease.

The biggest problem with VOODOO is that its graphical user interface feels half-baked. The History window is great at what it does, but there is no way to search it. CVS and Projector also lack a search feature, but at least they can produce a log file of all your changes and comments that can be searched with another tool. The tree view works, but I found it cumbersome to use. I would have much preferred something that worked like the Finder’s list view.

Storing files with VOODOO

The interface for storing files is similarly clumsy. When you store files, VOODOO uses solid or outlined check marks to show you which files have changed and which files don’t need to be stored. There’s no way to see a list of only the files that need to be stored—a big problem if you have a lot of files. This is made worse by the fact VOODOO doesn’t show the folder hierarchy; you have to click on a file’s name to see which file it actually is. That’s right: if you use VOODOO to manage a Web site with lots of “index.html” files, you’ll have a hard time telling them apart in the Store dialog. A final complaint about storing is that VOODOO only uses a file’s modification date to determine whether it needs to be stored. CVS compares the files to see whether they’re actually different.

VOODOO is about the same speed as Projector, but it’s much slower than CVS. That means you’ll spend a lot of time looking at its Windows-style progress bars; if you store a thousand files there’s a separate progress bar for each file, not one for the whole operation.

Conclusion

If you manage non-Mac files, such as a Web site, you should investigate both VOODOO and CVS to see which is better for you. VOODOO supports orthogonal version management and a unified interface. CVS has several clients to choose from, is cross-platform, and is more efficient for many tasks once you learn to use it. If you need version control to manage Mac files (e.g., with resource forks), VOODOO is probably the best choice. It’s much easier to use than Projector and, I’m told, more reliable.