February 21, 2001

New TrueCM Release

TrueCM Release 0.70 was posted earlier today. Release 0.70 represents a significant advance over the initial TrueCM release just seven months ago. Release 0.70 incorporates customer feedback and functionality advances that make TrueCM a solid choice for advanced version control of your products. Key improvements include:

• Dramatically improved GUI usability
• Graphical diff and merge support
• Better performance
• More documentation, including some on-line help for key dialogs
• RCS and SoftBench CM to TrueCM migration tool and documentation
• Increased stability
• Significant automated command-line test suite
• Lots of little things taken care of so you don't have to

CM Concept: Change Coordination

In any software development effort where multiple copies of the source exist, some means beyond good intentions is required to insure that changes to any source are appropriately propagated to all copies. The prototypical problem is concurrent changes where one change is overwritten by the other. Several fundamental approaches, with analogs in database theory, have been adopted to prevent changes from being lost.

The most basic approach taken by CM tools involves serializing all changes to a given item using a one-at-a-time strict-locking protocol as typified by SCCS. With strict locking, each file has a lock associated with it, and only the holder of the lock can make changes to that file. Changes happen one at a time to a given file, and the lock is released when a user commits their changes.

A popular alternative, the concurrent-locking protocol, allows multiple locks to be granted concurrently and thus multiple users may work in parallel. Serialization is deferred until commit time. The difference to the user appears only when multiple users actually make changes concurrently. The first user to commit does so as simply as in the strict-locking protocol. However, additional lock holders find that a merge is required before they can commit. Typically, the implementation records, in the lock, the revision retrieved. And if, at commit time, it is no longer current, a merge is required to update the lock before allowing a commit.

At the other extreme from the one-at-a-time approach, is the all-files-all-the-time approach. Essentially, this no-locking approach does away with explicit locking and grants an implicit lock to every copy of every file. Any copy of any file can be changed at any time. The CM solution is then charged with knowing the derivation of every file so it can insure that merges happen appropriately at commit time and changes do not get lost.

These three protocols employ one, many and N locks respectively to facilitate change coordination with a given development. Many environments explicitly or implicitly encourage serial development.

A significant alternative to serialized development is parallel development. In parallel development, changes may be committed at any time onto different branches, with merging delayed until the branch as a whole is merged into the main line.

The approach most suitable for a given team depends on many factors:

How closely and frequently do users wish to incorporate changes from team members. Frequent sharing is facilitated by the serial approach (a simple checkin (commit) makes the individual change visible), while the parallel approach is more suitable for sharing between teams where a set of changes should be published together.

Strict and concurrent locking provide visibility into who is doing what (especially if lock-time comments are recorded), which the no-locking approach does not facilitate. Strict locking delays some changes compared to the no-locking and concurrent-locking protocols, but has the advantage of simplicity and avoiding any need for merge.

TrueCM offers elements of both serial and parallel approaches. Strict-locking serializes changes to a snapshot with multiple workspaces. Within a workspace, TrueCM recognizes that a changed workspace file needs to be checked in (or merged) even if not locked. Between snapshots, parallel development is the norm. And with TrueCM's advanced snapshot technology, copying changes (of all kinds) between snapshots is fast, simple and done right.

Your feedback is welcomed. Send to support@truebluesoftware.com.

Newsletter Subscriptions

To be added or removed from the True Blue Software News mailing list, send your request to support@truebluesoftware.com.

View previous newsletter. View next newsletter.