[svn.haxx.se] · SVN Dev · SVN Users · SVN Org · TSVN Dev · TSVN Users · Subclipse Dev · Subclipse Users · this month's index

Re: SVN vs. AccuRev?

From: Damon Poole <damonbpoole_at_yahoo.com>
Date: Tue, 27 Jan 2009 21:08:08 -0800 (PST)


Thank you for the opportunity to compare and contrast AccuRev and CC/UCM .
:-) Apologies for the late reply, I only just stumbled upon this thread.

David Weintraub wrote:
> I am not familiar with AcuRev, but it appears to try to work in a
> similar way as ClearCase UCM. That is, developers don't work in the
> same area. Instead, they all have their own private branches, and
> deliver code to their project.
> I am not a fan of this type of work because it easily allows
> developers to ignore changes taking place in the project. Besides,
> every delivery is a merge which means each delivery is a chance for
> merge conflicts. I used ClearCase UCM on a small, but rapidly changing
> project, and I would end up resolving two or three merge conflicts
> each day.

While AccuRev and CC/UCM appear similar on the surface, they are in practice
very different. Working on a private branch in UCM is very much as you
describe. But not in AccuRev.

Consider for a moment how you work in any SCM system when you are not using
private branches. You have your own copy of files to work on. That's your
working copy. When other folks make changes, you don't see them until you do
an update. You are isolated from other people's changes. Also, when you make
changes to files, nobody sees your changes until you do a commit. Other
people are isolated from your changes. The version metadata of the files you
are working on are stored in your local file system (in CVS/SVN) .

For instance, if you have a repository with 500 files, each of those files
has a version level. If you create a working copy, then you have 500 files
in your working copy which are each at a particular version level. If
somebody then does a commit of 10 files, then you have ten files in your
working copy which are now a variant of the latest version in the
repository. On the other hand, if you edit 10 other files then nobody else
has those and now you have a 20 file variation.

In effect, the combination of the files that are out of date and your edits
is your own personal variant. Let's call it a "special branch."

The differences between this "special branch" and a regular branch are:

1) There is no named branch entity (but there is an implied branch you could
call "my files")

2) There is no branch meta data stored in the repository (but there is meta
data on your disk)

3) When you commit changes to files, there is no longer anything special in
your work area or in the repository. There is no discernible difference

4) When you do an update, you don't have to do anything special to see
changes that other people have made to files you have changed.

In other words, you use this "special branch" all the time in SVN without
even thinking about it. It is invisible.

Regarding merging though, I don't follow what you are saying. If you have
have a real conflict, then you will have that whether you are using a
private branch or not. If you don't have a conflict in UCM, you won't have
to textually/manually resolve anything, but you will still have to go
through the motions of doing a trivial merge.

So what does this all have to do with AccuRev? In AccuRev, every developer
does have their own private stream. However, it *behaves* exactly the same
as the "special branch" you are used to in CVS/SVN, but behind the scenes it
is implemented with a stream. It is invisible for all intents and purposes.
Instead of update/commit you do update/promote. No need for an extra merge
step, no fuss, no mess.

However, at the same time, your workspace stream is there if you want it.
Let's say you have just finished something and you aren't ready to commit it
just yet, but you want to version it. In AccuRev, you just do a keep to
create private versions. Do it as many times as you want. When you are done,
you do the commit (we call it promote) and it is just as though you never
had a private stream and it is just like you no longer have a private
stream. So, most of the time you might do update/commit and then sometimes
you will want update, keep, and commit. Some folks really like keep and they
will have update, keep, keep, keep, keep, keep, and commit (and then perhaps
a bit more keep).

When you create private versions you can then do things like revert back to
a prior keep, diff against prior keeps, annotate, see comments, let other
folks see your private versions, access your private versions over the web,
and generally do all of the operations that are usually only done against
public versions you can now do with your private versions.

FYI, AccuRev Inc has a lot of experience with CC, so while we learned a lot
from CC, we had no desire to create a CC clone. :-)


Damon Poole
CTO, AccuRev

View this message in context: http://www.nabble.com/SVN-vs.-AccuRev--tp20563602p21700093.html
Sent from the Subversion Users mailing list archive at Nabble.com.
To unsubscribe from this discussion, e-mail: [users-unsubscribe_at_subversion.tigris.org].
Received on 2009-01-28 06:17:03 CET

This is an archived mail posted to the Subversion Users mailing list.

This site is subject to the Apache Privacy Policy and the Apache Public Forum Archive Policy.