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

Stellation (was Re: Bluesky: Fine Grain Locking)

From: Brad Appleton <brad_at_bradapp.net>
Date: 2004-06-02 08:47:55 CEST

On Tue, Jun 01, 2004 at 12:35:05PM -0700, andy.glew@amd.com wrote:
> I've occasionally heard people talk about VC
> systems based on the "deck of cards" paradigm
> - where you locked several particular regions,
> basically line numbers, typically scaled up
> to procedures, etc., of the source.

The "Delta Line Editor" (at Bell Labs) was one of the more
famous ones. It was used to VC a large telecom switching
program that was written in assembly language. One could
checkout/checkin at the granularity of lines, and line

Then in the late 80s and early 90s when CASE was hot, there
were some CASE tools (like ProCase and SmartCase), often for
Ada, that would allow logical (rather than physical) units of
fine-grained checkout such as procedure/method, data definition,
and class/package.

And of course in the Smalltalk world, with environments like
VisualWorks and tools like ENVY/Developer, it was the norm to be
able to checkin/checkout at the level of a method, or a class.

These days, fine-grained locking tends to try and apply to logical
elements rather than a line-range. It is becoming "en vogue" again
from two different drivers:
  1. MDA/MDD
  2. Formal Requirements Traceability

  As Model Driven Development/Architecture becomes more popular,
  there is a desire to be able to use the model and the modeling
  elements within it (instead of the file-system) as the way of
  navigating thru the source code. E.g.:
  - open up a particular model
  - double-click on a UML "package" to "zoom in"
  - then "double click" on a class to drill-down to its
    inheritance hierarchy
  - then double-click again to drill-down on the appropriate
    subclass, and see an expanded list of its methods and
  - then double-click on the method signature to view its
    source-code, and then decide if you want to checkout
    the code and modify it.
  This is of course reminiscent of some CASE tool functionality.
  Imagine a "plug-in" between the modeling tool and Eclipse to
  enable this sort of thing. And the modeling tool takes care of
  mapping modeling elements to files (with the help of some
  customizable project preference settings), as well as tracing
  logical build/link/execution dependencies between modeling
  elements and files (and other modeling elements).
I think this is the sort of thing the Eclipse Stellation project
had in mind (see http:www.eclipse.org/stellation)
2. Formal Requirements Traceability
  "Hi Tier" Requirements development+traceability tools (like
  Telelogic DOORS, or Rational RequisitePro) are becoming much
  more desirable than manual traceability matrix creation/updating
  for projects that mandate full formal requirements traceability.
  Basically it lets you "edit" a document where each
  "paragraph" is really an "object" in a database that can
  be separately versioned from the others, and that can have
  attributes (properties) and or links to any other object in
  the repository. links can be added (and attributed) between
  related requirements "objects", or between a requirement
  "object" and its corresponding objects it was decomposed into
  in a lower-level requirements document and/or a design document.
  Imagine for a moment if someone provided some kind of GUI
  editing environment for editing all the files in a particular
  directory of a subversion repository as if they were really a
  sequence of contiguous text sections in a single document. I
  could still do operations like search/replace/format across
  the entire document (all files in the directory) but could
  also checkout/checkin (and lock :) either the entire document
  and/or a particular "paragraph" that was really just a single
  file within the director, but which the GUI environment made
  it look as if it was a logical portion of a larger "artifact"
  that I could edit as a "whole".

For current state of the art and an opensource project (that
is part of the Eclipse Tools project), I recommend interested
parties take a peek at the "Stellation" project:

  *** The Stellation project: Advanced SCM for Collaboration
  *** http://www.eclipse.org/stellation
  *** news:eclipse.technology.stellation

It's actually pretty interesting IMHO. They have their own notion of
"lightweight branching" that is worth comparing to SVN.

Brad Appleton <brad@bradapp.net> www.bradapp.net
  Software CM Patterns (www.scmpatterns.com)
   Effective Teamwork, Practical Integration
"And miles to go before I sleep." -- Robert Frost
To unsubscribe, e-mail: users-unsubscribe@subversion.tigris.org
For additional commands, e-mail: users-help@subversion.tigris.org
Received on Wed Jun 2 08:49:11 2004

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.