How do I do distributed UML development (à la FOSS)?

Question

I have a UML project (built in IBM's Rational System Architect/Modeler, so stored in their XML format) that has grown quite large. Additionally, it now contains several pieces that other groups would like to re-use. I come from a software development (especially FOSS) background, and am trying to understand how to use that as an analogy here. The problem I am grappling with is similar to the Fragile Base Class problem.

Let me start with how it works in an object-oriented (say, Java or Ruby) FOSS ecosystem:

1. Group 1 publishes some "core" package, say "net/smtp version 1.0"
2. Group 2 includes Group 1's net/smtp 1.0 package in the vendor library of their software project
3. At some point, Group 1 creates a new 2.0 branch of net/smtp that breaks backwards compatibility (say, it removes an old class or method, or moves a class from one package to another). They tell users of the 1.0 version that it will be deprecated in one year.
4. Group 2, when they have the time, updates to net/smtp 2.0. When they drop in the new package, their compiler (or test suite, for Ruby) tells them about the incompatibility. They do have to make some manual changes, but all of the changes are in the code, in plain text, a medium with which they are quite familiar. Plus, they can often use their IDE's (or text editor's) "global-search-and-replace" function once they figure out what the fixes are.

When we try to apply this model to UML in RSA, we run into some problems. RSA supports some fairly powerful refactorings, but they seem to only work if you have write access to all of the pieces. If I rename a class in one package, RSA can rename the references, but only at the same time. It's very difficult to look at the underlying source (the XML) and figure out what's broken. To fix such a problem in the RSA editor itself means tons of clicking on things -- there is no good equivalent of "global-search-and-replace," at least not after an incomplete refactor.

They real sticking point seems to be that RSA assumes that you want to do all your editing using their GUI, but that makes certain operations prohibitively difficult.

Does anyone have examples of open-source UML projects that have overcome this problem? What strategies do they use for communicating changes?

Answer 1

Packages be remote model references i.e. stored in it's own emx not directly included. Then just share the models via CVS/SVN and manage them separately? Changes will propagate that way, models can reference across modeling files they do not need to be all in one file.

If you have already though of the above, please expand on the needs. Does it need to be real-time and/or outside of RSM for developers that do not have the tool. Can you provide an example of what "breaks" or requires "tons of clicking on things"? I have grappled with the problem before and have solved it in several ways depending on my needs and constraints.

1. (The way above)
2. Break project into small files, but it is one larger model. (Solves only a few issues)
3. Write a eclipse/RSM plug-in to keep things in sync, this is for limited, but important cross project linkages. For example, have a shared set of components or assets that the models need to re-use.

Again with more information I can provide a better answer, the FOSS references only let me guess that you want loose coupling/object re-usability/extension, but real RSM examples might help more. I can update my answer if you tweak your question and let me know.