Re: FW: Multiple checkouts with FrameMaker?

["Steven J. Owens" <puff -at- netcom -dot- com>]

> From: Laura Tarwater [mailto:ltarwater -at- yahoo -dot- com]
> I just started working in a development environment with FM books,
> using Microsoft's Visual Source Safe as a document control mechanism
> (inherited from the programmers). With this setup, it seems that only
> one person can have a book checked out at one time. This has been
> causing some workflow problems, as you might imagine.
> 
> Is there a way with this current setup that will allow different people
> to check out different chapters of the same book at the same time? Our
> graphics imported by reference especially don't seem to like this.

Darren Barefoot writes:
> We have a very similar system in place for our Development office. It's sort
> of no-frills, but SourceSafe has proved reliable and (as the name kind of
> implies) has saved our butts more than once. I can only answer your first
> question: No, you if each chapter is a file, there is no way via SourceSafe
> to have two people modifying it simultaneously. 

     I think she was asking about how to set it up so each chapter
could be checked out independently of the rest of the book, so two
writers could work on different chapters of the same book.  I've never
worked with FrameMaker under revision control systems, only with plain
old text files (revision control systems are widely used in
programming projects) but in general it should be possible, unless
there's some FrameMaker-specific issue.

> In fact, I suspect this is the case regardless of what (if any)
> document control mechanisms you use.
>
> It's prudent and fairly standard to have one person at a time
> working a file.

     This is generally true, but there are systems for doing 
concurrent versioning control - the most well-known one is CVS,
though I remember reading about one called Aegis, several years
ago.  CVS (Concurrent Versioning System) typically runs on UNIX
systems and is an added layer on top of RCS (Revision Control
System).  

     With CVS, you check out a copy of the entire file set, work one
what you need to work on, and then fire off a command to have CVS
integrate your set of changes into the master archive.  CVS is smart
enough (actually this is the part that RCS does) that only the changed
parts of your copy of the file set get added back in, and it keeps a
running record of changes, so you can generate a complete version of
the archive as it looked at any point.

     CVS is also smart enough to try to cope with situations where two
users worked on the same file.  This is, in fact, it's raison d'etre
(did I spell that right?).  If the changes are distinct enough - say
one user changed the first page while another added several pages onto
the end - CVS can combine the changes.  If they're too muddled, CVS
will refer the problem to a human.

     Naturally, such concurrent versioning is a little easier to do
with programming languages, which generally have more explicit
low-level organization.  Written natural language is much subtler and
you could easily introduce content conflicts - page one says "See the
note at the end of this chapter" but the new pages mean the note is
now in the middle of the chapter.  None of this frees you of the
obligation of coordinating what you're doing with your teammates.  You
can still mess it up by not working together.  But CVS makes the whole
process a lot easier.
 
Steven J. Owens
puff -at- netcom -dot- com