Last updated: Sunday 6.05.2001 12:07:44 EEST
1 Introduction
1.1 Background
1.2 Overall description
1.3 Software project constrains
1.4 Abbreviations and used terms
2 Schema and notation
2.1 Notation used in UML visualisation
2.2 Schema
3 Information description
4 Scenarios
4.1 GXL
4.2 Layout
4.3 Viewing
4.4 Selections
4.5 Filtering
4.6 Zooming
5 Features
Reverse-engineering can be a daunting task. Complex software with minimal or no documentation can be difficult to understand. Understanding is the key to reverse-engineering. Visualization helps, because it makes it easier to understand software, even when no written documentation is available.
Problem in the past has been the interoperability of different re- and reverse-engineering tools: they cannot efficiently exchange data. Also, current visualization tools have serious limitations. UML is not used and viewing of relations between various components is limited.
Thus enter Venice, a next generation reverse-engineering visualization tools. It uses familiar UML notation with a few additions and is capable of nicely showing relations between components buried deep in different branches of modular software system.
Venice is a web based interactive viewing system for reverse-engineering data at the architectural level. It will show the dependencies and relationships between various modules of the software system being visualized. Venice has sophisticated visualization, zooming and information filtering capabilities, which are required for effective reverse-engineering. Notation for visualization will be an extension of UML, with a limited, but useful set of symbols.
Reverse-engineering data will come from XML-based GXL-files that can be stored at a central server. Visualization layout data will be saved in different files, and same reverse-engineering data can be viewed with multiple visualization layouts, though not at the same time.
Venice is available as a Java applet, with nothing but visualization capabilities, and a Java application, which can also save visual layout information. This way a lead engineer can layout the data as wanted, and all others can view, but not save, the data.
The viewer can filter out unneeded parts of the diagrams by using different filtering techniques such as "Filter selected". Using filtering the viewer can focus on particular subsystems.
One of the main capabilities of Venice is it's ability to view hierarchical components. For example, packages show their contents when zoomed close enough and at that time all the relationships going into the packages and classes in that package will be explicitly shown.
The notation is not strictly UML. Venice shows interfaces a little differently from the standard UML notation. This is because it is not clear how to use UML to visualize software architectures.
Venice is a viewing system with the ability to save the visual layout. In addition to that, the user can edit the graph by exploding existing packages and by grouping packages and components to form new packages.
The system should be as independent from the schema and visualization notation as possible. It might be possible to remap schema elements and the elements they are visualized. Also, even the schema could be changed. Types of nodes and dependencies are defined in a file in addition with their color information.
Notation used in Venice is derived from UML. The GXL-schema used describes how different notation elements can be combined. All visualization is shown according to the schema. Notation elements are displayed with different colors depending on their type. User can also select a black and white presentation where types of the elements will be shown with labels.
Package is a container for other model elements. Package has the ability to export interfaces.
Visual representation:
Component is representation for identifiable, selfcontained pieces of implementation. A component could be for example a class or a function.
Visual representation:
Interface is a specifier for externally visible operations of a component. A component can require or offer an interface. The concept of an required interface is an extension on UML.
Visual representation:
Interface realization is way of showing an interface in greater detail. Interface realization shows also the operations related to a certain interface.
Visual representation:
Dependecy indicates a semantical relationship between two model elements. Dependencies used in Venice have similar semantics as UML's usage dependency; Model element requires the presence of another model element.
Visual representation:
Generalization is a taxonomic relationship between a more general element (the parent) and a more specific element (the child) that is fully consistent with the first element and adds additional information.
Visual representation:
Schema defines the meaning of the input graph. Instance of the schema can be stored in GXL-format
GXL model and schema are inputs for the system. Outputs are UML visualization, layout data and modified model. The Applet has only UML visualization as output.
Venice reads GXL files and interprets them according to the schema. Venice does not validate the documents, but it rejects all files it cannot parse. The application version can load and save GXL models anywhere in the users file system.
When the program loads the GXL data, it will make a default layout. This layout may not be t he best possible, but the user can change and save it for later use.
Components and packages can be moved and resized. The viewer will show the most detailed dependency possible.
System has two viewing states: Black and white state and color state. In black and white state all information is presented with these two colors. In color state different dependency types are presented with unique colors.
Show / Hide content of a package.
Move external dependencies of selected package to outer level. Here the operation is applied on Package B.
Move external dependencies of multiple selected packages or components to upper level. Here the operation is applied on Package B and Component C.
Move external dependencies of multiple selected packages or components to outer level. This command only moves external dependencies. All inter package dependencies are not touched and only selected item is rewrited (see component b to package F dependency witch is not moved to upper level). Here the operation is applied on Package B and Component C.
Move external dependencies of selected component to upper level. Here the operation is applied on Component C.
All external dependencies are showed at outer level.
User can expand interface to see the content.
User can hide dependencies to a selected package and only show offered and required interfaces.
User can select multiple nodes and show only offered and required interfaces and dependencies between those interfaces.
User can hide all interfaces but still see all dependencies between nodes.
With this command user can see information about selected node. Command can be used to see information about every visible element also dependencies. If dependency is a composite of multiple dependencies, this command shows information about every single dependency included. All information is get from the GXL model.
User can rearrange layout of the system. If user moves a node on top of another, moved node hides everything that is under it.
User can select some nodes and group them inside a new package. When nodes are grouped all external dependencies will be moved to the level of the new package.
User can show or hide the labels of selected components.
User can select if the node types are shown in color or as labels.
Selection is used to select one or many nodes. Operations can then be limited to affect only the selected subset of nodes in the architectural model.
Nodes can be selected by clicking them with the mouse. Selected nodes will have different appearance than unselected nodes. User can select nodes by selecting a rectangular area with the mouse or by selecting nodes with the mouse. All nodes that are under or touch the rectangular area selected are selected. Nodes can be added to the current selection by clicking nodes with shift-key down. Removing nodes from current selection can be done the same way by clicking on a selected node. Nodes can by deselected by clicking on empty areas in the Venice window. Selections are always made in the level that the first selection was made. Behaviour of Venice is shown in greater detail in the scenarios.
The following scenarios show some basic usescases. X-letter is used to show the position where the user starts a rectangular selection. Selected nodes are indicated with small rectangles on the edges of the selection area.
Selection is made with shift-key down.
Selection is made by typing the name of the node in a textfield.
Invert selection command selects all nodes that are currently not selected in the current view.
Unselect everything command unselects all nodes from the current selection.
Filtering is a method used to limit the information presented in the Venice window. All filtering commands, except unfilter all, affect only selected the nodes. If no selections are made command filter by type, affects all node in the current view. If a node is filtered all its dependencies to other nodes are also filtered. Filtering also filters interfaces provided by the node in question. Individual filtering operations can't be undone, however it is possible to cancel the effects of filtering operations by using the command show everything. Commands filter related and filter unrelated affect only the nodes that they are connected to.
Filter unselected is a shortcut for invert selection + filter selected.
Filter by type is a shortcut operation for select by type + filter selected.
Show everything shows all nodes. This command can be used to show previously filtered nodes
User can zoom in and out while viewing the system. When nodes get big enough node content becomes visible.
User can resize a node by dragging it from its corners. When resized everything inside the node will be resized also. So resizing is kind of zooming applied only to the selected node.
With this feature user can zoom into selection. View is zoomed to such a level where selected nodes can be viewed as big as possible. If selection is done by name and all selected nodes are not in the view, with this feature view is zoomed out such a level where all selected nodes can fit to screen. If user has selected a node and then is moving around the view so that the selected node is outside of the screen, with this feature user can return to original view.
Because features have been added to the middle of the feature list, but old features cannot be relabeled, the feature list isn't in straight ascending order.
GXL features
Layout features
Viewing features
Selecting features
Filtering features
Zooming features