Project plan | Time usage reports | Change log | Meeting minutes | Functional specification | Technical design document | Implementation document | Testing document | User's Manual | Final report

Software Engineering Project:
Venice

UML Visualization Tool

Requirements

Last updated: Sunday 6.05.2001 12:07:44 EEST

Contents

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

1 Introduction

1.1 Background

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.

1.2 Overall description

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.

1.3 Software project constraints

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.

1.4 Abbreviations and used terms

2 Notation and schema

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.

2.1 Notation used in UML visualisation

Package

Package is a container for other model elements. Package has the ability to export interfaces.

Visual representation:

Component

Component is representation for identifiable, selfcontained pieces of implementation. A component could be for example a class or a function.

Visual representation:

Interfaces

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

Interface realization is way of showing an interface in greater detail. Interface realization shows also the operations related to a certain interface.

Visual representation:

Dependency

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

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:

2.2 Schema

Schema defines the meaning of the input graph. Instance of the schema can be stored in GXL-format

schema UML

3 Information description

Information flow representation

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.

4 Scenarios

4.1 GXL

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.

4.2 Layout

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.

4.3 Viewing

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.

Open/Close package

Show / Hide content of a package.

Move dependencies to upper/lower level

Dependencies up (scenario 1)

Move external dependencies of selected package to outer level. Here the operation is applied on Package B.

Dependencies up (scenario 2)

Move external dependencies of multiple selected packages or components to upper level. Here the operation is applied on Package B and Component C.

Dependencies up (scenario 3)

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.

Dependencies up (scenario 4)

Move external dependencies of selected component to upper level. Here the operation is applied on Component C.

Transparent

All external dependencies are showed at outer level.

Show/Hide interface content

User can expand interface to see the content.

Show offered and required interfaces

User can hide dependencies to a selected package and only show offered and required interfaces.

Show offered and required interfaces of selected nodes

User can select multiple nodes and show only offered and required interfaces and dependencies between those interfaces.

Show / Hide interfaces, show dependencies

User can hide all interfaces but still see all dependencies between nodes.

Show node information

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.

Moving nodes

User can rearrange layout of the system. If user moves a node on top of another, moved node hides everything that is under it.

Package grouping/ungrouping

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.

Show / hide labels

User can show or hide the labels of selected components.

Show colors

User can select if the node types are shown in color or as labels.

4.4 Selections

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.

Making selections

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.

Package A is selected by clicking on Package A

Component A is selected by clicking on Component A

Selection is made by dragging a rectangular area with the mouse

Selection is made by dragging a rectangular area with the mouse

Selection with shift-key down

Selection of two packages

Everything is selected

Selection is made with shift-key down.

Select related

Select unrelated

Selection by type 1 (two components selected)

Selection by type 1 (two components selected)

Select by name

Selection is made by typing the name of the node in a textfield.

Invert selection

Invert selection command selects all nodes that are currently not selected in the current view.

Unselect everything

Unselect everything command unselects all nodes from the current selection.

4.5 Filtering

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 selected

Filter unselected

Filter unselected is a shortcut for invert selection + filter selected.

Filter related

Filter unrelated

Filter by type

Filter by type is a shortcut operation for select by type + filter selected.

Show everything

Show everything shows all nodes. This command can be used to show previously filtered nodes

4.6 Zooming features

Zoom in/out

User can zoom in and out while viewing the system. When nodes get big enough node content becomes visible.

Resizing

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.

Zoom to selection

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.

5 Features

Feature list - basic commands

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

  1. Read GXL-file
  2. Write GXL-file

Layout features

  1. Make layout
  2. Save layout
  3. Load layout

Viewing features

  1. Open/Close package
  2. Move dependencies to upper/lower level
  3. Transparent - Move all external dependencies to upper level
  4. Show/Hide interface content
  5. Show/Hide required interfaces
  6. Show/Hide offered interfaces
  7. Hide interfaces, show dependencies
  8. Show node information
  9. Move nodes
  10. Group/Ungroup selected packages
  11. Show / hide labels
  12. Show colors

Selecting features

  1. Select
  2. Select all
  3. Select related
  4. Select unrelated
  5. Select by type
  6. Select by name
  7. Invert selection
  8. Unselect

Filtering features

  1. Filter selected
  2. Filter unselected
  3. Filter related
  4. Filter unrelated
  5. Filter by type
  6. Show everything

Zooming features

  1. Zoom in/out
  2. Resize nodes
  3. Zoom to selection