[Twisted-Python] UML Whiteboard Concept

[Jason L. Asbahr]

(You may see this email twice.  It's been 24 hours since I
 mailed the original message, but it hasn't made it to the
 list yet...)


Twisted people,

I wanted to share some thoughts on a UML Whiteboard concept
I've been kicking around.  BUT FIRST, some ravings:

I just got back from SIGGRAPH, which was mind blowing.  Some
amazing art projects and emerging technology projects both
simple and complex.  There was also the expo area, which was
more of the usual trade show style, but all neat.  :-)  One
cool type of product on display in the expo was the 3D object
printer.  There were two companies, one using a silica powder
and "sugar water" solution to create 3D objects, the other
using what appeared to be liquefied plastic of some sort.
Given a detailed mesh, these machines can create objects which
have internal moving parts (no gears shown yet, but they did
have spheres within spheres and an item which had one ring
inside another with ball bearings between them, done in a
single printing process...)  And the silica powder models
will absorb liquid, which they use to change the physical
properties of the resulting object.  By soaking the object
in a glue-like liquid, it becomes very rigid and strong
(one piece supporting the weight of the salesman demonstrating
it), and by soaking it in a rubber-like liquid it becomes
somewhat flexible and squishy (kinda like Nerf material).

Cool stuff!  Anyway....

I'm thinking of designing a new UML diagramming tool because
I'm really unsatisfied with the existing ones.  This future
tool would be client-server, a collaborative UML diagramming
whiteboard, with versioning.  I'm thinking of an "extreme
programming" version of a UML diagramming tool, if you can
imagine that, something very lightweight but damn useful
for design collaboration and brainstorming sessions.

Interoperability with Rational Rose or TogetherJ (using XMI,
the XML standard for UML) would be an important later goal.

Components that would be used to assemble the tool:

- Server and remote object protocol:
          Twisted, http://www.twistedmatrix.com (natch :-)

- Client: wxPython, http://www.wxpython.org, and
          wxOGL, the wxWindows version of the
          Object Graphics Library canvas library

Of course, multiple client implementations could exist using
other toolkits.

I'm imagining that the whiteboard would support multiple documents
open at the same time, allowing users to cut and paste and to compare
documents.  (Not being able to have multiple documents open on my
desktop was something that frustrated me when I was using Rational
Rose...)

I want to avoid an explicit hand-off of editing control, turn taking
seems like an additional burden on remote collaboration -- one that
should emerge from the interaction of the participants rather than
being forced on them by the tool.  Instead, I imagine that users
will be granted an implicit lock on objects they select for editing
(a text field, a class, a method-invocation line).

Perhaps the tool should have two selection modes -- select-for-
highlighting and select-for-editing.  The first mode would be
for drawing attention to an element, say left click to highlight
and the graphic gets emphasized on everyone's display.  The
second mode would be the implicit lock mode, achieved by double
clicking or right-clicking.

Additionally, many of the systems which the UML tool would use
would also be useful for other applications.  Multiuser object
manipulation, the locking mechanism, object versioning, partial
object transmission, and so on.

In the foggy, distant future I'd love to have a design tool
that actually worked seamlessly with my code development.
New classes and methods typed into an editor would be added
to the design model as I typed them, and new methods and
classes created in code as I drew them in the tool.  Source
files per se would be the exported data of the tool, internally
code would be represented in a structured format at various
levels of granularity (package, class, method).  Smalltalky.

Resonant with the manhole concept, definitely.

Here is my current list of references for this project, FYI:

[ References ]

UML Specs
http://www.celigent.com/omg/umlrtf/artifacts.htm

A kick-ass collection of resources on object oriented programming:
http://www.eecs.lehigh.edu/~glennb/oose/oose.htm

FreeCase project
http://www.freecase.seul.org/
Client / server, documents of concepts to borrow

UML Pad
http://web.tiscali.it/ggbhome/umlpad/umlpad.htm
(maybe dead)

Dia
http://www.lysator.liu.se/~alla/dia/
Viseo-like drawing tool

OpenThorn
http://members.nbci.com/openthorn/
wxWindows Rose Clone (closed source?)

CLIP-based UML Patterns extractor:
http://www.geocities.com/ResearchTriangle/Node/2005/

UML Tool Survey Report Summary:
http://www.unicorn.cz/lat/distribution/_downloads/es-srovnani_case_nastroju-
yphise.pdf

---

And here's a quick brainstorm of a list of use cases:

[ Use Cases ]

Application Management:
- User launches diagramming client
- Client connects to Twisted server
- Client connects to Twisted service

Document Management:
- User creates new diagram
  - User creates new state diagram
  - User creates new sequence diagram
  - ...
- User saves diagram
  - Diagram automatically saved on edit?
  - Diagram automatically versioned?
- User opens diagram

Document Editing:
- User drags new glyph instance onto
  diagram
- User selects an existing glyph instance
  - NOTE: this implicitly locks the object
- User moves glyph instance
- User deletes glyph instance
- User drags connection between two
  glyph instances

Utility:
- Client requests index of documents
- Client requests document
- Server transmits index of documents to client
- Server transmits document to client

Thoughts?

Jason