[Uml-devel] u2 ideas

[Andrew Sutton]

i've been doing some research for my software viz project today, struggling to 
find references to vizualization techniques for UML. there's not many. i did 
find some interesting stuff though... this will be a long email. there's a 
couple ideas here ;)

one of the main components of my research is improving navigation of models 
and diagrams. there really isn't anything about this that i can find anywhere 
- if anybody knows of any novel techniques for this, please let me know. i'd 
be very appreciative...

anyway, i see navigation breaking down in 2 ways.
	1. navigating model element to another diagram that shows it
	2. navigating around a diagram
there's also view navigation (like moving from the use case view to the 
logical view), but i had an idea this morning that deals with that. it's kind 
of an odd idea, but it should work just fine.

anyways, consider your typical UML tool. you have a tree view with some model 
elements and you have a diagram that shows relations and what not. you could 
right click on an entry in the tree view and select a diagram that shows the 
object that you've clicked on. alternatively, you could select an object and 
go to a diagram semantically related to the object that you clicked on (like 
a sequence diagram for related use case). for UML, this navigation uses the 
PresentationElement class. however, we probably want this relationship to 
exist outside of UML so we can apply the techniques to other metamodels. 
we'll have to generalize the capability at the reflective level. now, that's 
interesting :)

we also have this concept of the 4+1 view (or n+1 view, i guess). it's 
basically a little diagram that has a box with the use case view in the 
middle and a development view, physical view, logical view and whatever in 
boxes connected to the outside. what if u2 had a sort of internal metamodel 
that understood how to create "view diagrams" of that type. the views could 
have an actual notation (a box) in a diagram. because of this and the 
modifications at the reflective level to support the above, they could also 
be used to implment navigation between views.

so what then, is a view? well, a view is basically some subset of the model 
(all the various UML objects and relations). in other words, it could be used 
to create the tree view for the view - conveniently eliminating the 
abnormally large tree views that we find when we have use cases, classes and 
deployments all in the same model. so switching views could switch the 
contents of the tree view - or better yet create a new top level window or a 
new view tab with the tree view and some diagram.

continuing on, we have the problem of diagram organization and navigation. 
traditional systems include diagrams as objects in the tree view. i'm not 
certain if this is actually the most productive way to do it. i read this 
paper about a tool for finding pictures taken with a digital camera. it was 
basically a giant tree map that thumbnailed all the various pictures into a 
window. when you selected a box on the tree map, it would zoom into the box 
and zoom the thumbnails. it was interesting. it might be worthwhile to 
support a diagram navigation view like that. its called photomesa and can be 
found at: http://www.cs.umd.edu/hcil/photomesa

to change directions suddenly - i found another uml tool that looked 
interesting. they promise of this tool is the focus on usability as opposed 
to formalization. it's a company called ideogramic 
(http://www.ideogramic.com) or something like that. anyways, there were two 
ideas i took from their work.
	1. a radar view - basically a really zoomed out window that can be used for 
navigating to different areas of diagram (we've all played real time strategy 
games before - we should be familiar with the radar view).
	2. coloring uml objects
1 is pretty self explanatory. i think it could be really useful as an optional 
view for a diagram.

2 required more investigation. it turns out that peter coad (the borland guy) 
wrote a book called Java Modeling in Color with UML. the first chapter 
discusses some research involving color and cognition and what have you. the 
basic idea is based on archetypes. if a UML stereotype is a subtype of 
something, then an archetype is the supertype. coad identifies 4 archetypes:
	- moment-interval
	- role
	- description
	- party, place or thing
essentially, each archetype gets a color. i was thinking that this could be a 
UML issue, but it might be worth implementing it at the reflective layer as 
well - if we want to do this. we could allow the user to define multiple 
archetypes and associate them to collors. then for any object in the system, 
be able to apply the archetype to color the graph - or we could build it as 
an extension to UML. either or.

i could continue on and discuss my ideas about layout and graph aesthetics, 
but eh.. that's another couple pages and i don't think i'm there just yet :)

andy