[Java-gnome-developer] UML Class diagram editor

[Mark H. <mh...@ti...>]

Hello everyone,

I'm quite interested in creating a new application (using java-gnome, of course)
and I'm wondering if anyone here is intrested in helping. It's a huge task, so I
might not even start without extra help. In fact, it's very huge. But there are
a lot of libraries out there to help us. ANTLR will be especially important. 

The basic idea is to create an app for editing UML diagrams, like Rational Rose,
or Visio (sorry, I don't know of any open source/free/ or even linux-based
alternatives). 

This new application would be slightly different to these as it would be far
more greatly linked to the source code. (and of course it would be open source
and gnome-based and ...)

Here are a few use cases, limited to class diagrams since we can't expect to
do everything straight away:
1) The user is designing a new application.
   They start by dragging classes into the screen
   They might then drag relationships between the classes, or add attributes or
   operations to the classes. I have ideas for other data to include, but this
   is just an overview
   They print, or save as html.

   To illustrate a particular point, they create an illustration diagram. This
   allows them to drag existing classes onto a new diagram, arrange them how
   they like, select how much information is shown for each (e.g. just show a
   few methods), add notes, etc.
   Again, this can be printed, etc.

   Now the clever bit. They go away, think about the design and review it. 
   After a few modifications, the software then generates code for this design.
   This includes all methods, fields, and even comments as javadoc. They then
   write their well-designed application

2) The user wants to draw the design of an existing application so that they can
modify the design.
   The application automatically generates full class information, including all
   fields and methods, as well as all javadoc information. It creates an
   overview class diagram, showing everything with their relationships as in the
   code. This is an unreadable mess (as you would expect -- far too much
   information)
   They then create a new illustration, as a copy of the class diagram. They
   remove irrelevant classes from the illustration (but not from the model), add
   comments, change what should be shown for each class and end up with a
   diagram illustrating how the software works. They use this to explain how the
   software works to the rest of their team

3) The user has source code and a class diagram, but wants to change the source
code
   (at this point, the user would either have to manually update the diagram, or
   leave it out of date, if using a competing product).
   The application scans the source code for changes. It detects them and asks
   the user what to do. They choose to have the model updated. They go to each
   illustration in turn and add classes, based on a list of classes newly added
   to the library.

4) The user wants to change the overall architecture of the software. This needs
redesign of the class diagrams. 
   They change the diagrams with drag and drop. This is reviewed by their team
   mates and a solution agreed upon. Their source code is automatically updated
   with stubs for the new parts and the old parts commented out.
  
What do you think? Interested in helping create this?

-- 
  .''`. Mark Howard
 : :' :
 `. `'  http://www.tildemh.com 
   `-   mh...@de... | mh...@ti...