Navigating Software Architectures withConstant Visual Complexity

Wanchun Li, Peter Eades, Seok-Hee HongSchool of Information Technologies

University of SydneySydney, Australia

Email: {lpaul, peter, shhong@it.usyd.edu.au}

Abstract— Visualizing software architecture faces the chal-lenges of both data complexity and visual complexity. Thispaper presents an approach for visualizing software architecture,which reduces data complexity using the clustered graph modeland navigates pictures of clustered graphs with constant visualcomplexity. A graph drawing algorithm is introduced to generatevisualizations of clustered graphs. A semantic fisheye view ofa clustered graph is proposed for conserving constant visualcomplexity. Animation is used to present smooth transitionof visualizations. A case study is investigated to navigate thearchitecture of the Compiler c488.

I. I NTRODUCTION

Software architecture refers to the structure of a programor a computer system, which comprises software elements, theproperties of those elements, and the relationships among thoseelements [1]. It is the “blue-print” for building a successfulsoftware system. Visualization can help software architects todesign, analyze, and evaluate software architectures quicklyand effectively. Visualization of software architecture hasbeen studied by researchers from diverse areas such as vi-sual languages, software engineering, and graph visualiza-tion [12] [19] [8] [5] [4] [18].

Software architectures are typically relational and are usu-ally modeled by graphs. Many research efforts have beendedicated to visualizing and navigating graphs, especiallyhierarchies [3]. The visualization and navigation of softwarearchitectures faces the challenge of complexity in two ways:

(a) Data complexityarises from the sizes of graphs thatmodel software architectures. Such graphs usually havehundreds or thousands of nodes and edges.

(b) Visual complexitymeasures the complexity of a screenpresented to the user. Issues of visual complexity arisefrom limitations on human processing capacity. The ca-pacity of short-term memory is limited to a small amountof information [17]. When navigating an informationspace, humans retain only a small amount of informationas one screen is replaced by another. Visual complexityis a significant issue in a dynamic environment, when asoftware architect browses, analyzes and edits a design.

Many visualization techniques have been proposed to ad-dress the problem of data complexity. Software architecturescan be modelled using “clustered graphs” [6]: this is a hierar-chy in which the bottom level is a graph whose nodes represent

single files or classes, and higher levels represent packagesand subpackages. This paper proposes a new algorithm forgenerating visualizations of software architectures that aremodeled by clustered graphs.

The two challenges are related: by reducing data complexity,visual complexity is reduced as well. However, the problemof visual complexity is subtle. One can clearly reduce visualcomplexity by reducing the number of nodes displayed onany one screen; in fact, one can reduce it to just one node.However, this does not solve the problem, because the lessinformation on the screen the longer it takes for a humanto browse the architecture. Pulo [15] and Li [9] propose thenotion of “constant visual visual complexity”: that the visualshould be constant as a navigation proceeds. A visualizationsystem that conserves constant visual complexity avoids vi-sual overload caused by increasing visual complexity, whileusers can receive visual information with reasonable cognitiveload. This paper addresses the issue of navigating softwarearchitectures in a similar way.

In the next section we review notions of clustered graphs,graph drawing, fisheye views, and visual complexity. Next wegive a reference model for navigating clustered graphs, andintroduce a semantic fisheye view of a clustered graph; the aimis to give a strategy for conserving constant visual complexity.We also give an animation method for smoothing the transitionbetween screens.

II. PRELIMINARIES

A. Graphs and Clustered Graphs

Graph theoretic notions are from [2]. A clustered graphC =(G,T ) consists of a graphG, and a rooted treeT (called thecluster tree) whose leaves are exactly the nodes ofG. Theleaves ofT are leaf-clustersof C and non-leaf nodes ofT aresuper-clustersof C; both leaf-clusters and super-clusters arereferred to asclusters. The root ofT is also referred to as theroot-cluster.

An abridgementis a logic abstraction of a clustered graph,in which each super-cluster can have one of two states,openedand closed, and every descendent of a closed super-clusteris closed. Figure 1 shows a clustered graph and one of itsabridgements, in which child-clusters of cluster 2 and 4 areclosed.

C2

C3

C1

(a) A clustered graph

C2

C3

C1

(b) An abridgement of 3(a)

Fig. 1. A clustered graph and one of its abridgements

B. Force-directed Graph Drawing Algorithms

One general approach to the problem of graph visualizationis the force-directed method[2], in which a graph layout ismodeled as a physical system. A minimal energy, orbalanced,state of the force system defines a layout of the embeddedgraph. Force-directed algorithms are simple to understand andimplement, and produce reasonable results.

C. Dynamic Graph Drawing

Many graph drawing systems are in dynamic environmentswhere the drawing changes in response to interaction by usersor other processes. Here the important issue ispreserving themental map. The mental map refers to a representation of adrawing’s geometric structure in a user’s mind. Theorthogonalordering model[14] can be used to measure the mental map.Preserving orthogonal ordering means preservingup, down,left, andright; for details see [14]

D. Semantic Fisheye View

The visual complexity of large structures can be reducedby semantic fisheye viewtechniques [7]. The basic idea isto provide a balance between local detail and global context.These methods use aDegree of Interest (DOI)function tomeasure how related a point in the structure is to the focus.A generalized DOI function is proposed in [7] as:

DOIfisheye(x|y) = API(x)−D(x, y) (1)

where

x is a nodethe focus node isyAPI(x) is a priori importance of node x,D(x,y) is the distance between x and y.A successful semantic fisheye view depends on the quality

of the DOI function. A good DOI function of a tree structureis:

DOIfisheye(x|y) = −dtree(x, root)− dtree(x, y) (2)

wheredtree(x, root) is the distance from point x to the rootdtree(x, y) is the distance from point x to the focus y.

We can adapt this function for clustered graphs.

From (2), the focus and its direct ancestors are of the mostinterest in a tree structure because they have the largest DOI. Asemantic fisheye view of a tree is in thezero-orderif it consistsof the nodes of the most interesting subset. A semantic fisheyeview is in thefirst-order if it includes the next most interestingsubset, which are the siblings of the focus and of the focus’sdirect ancestors.

More details on semantic fisheye views can be found in [7].

E. Visual Complexity

When humans process information, information is firstcollected by sensory memory, and then is passed to short-term memory. Short-term memory reorganizes the informationreceived. After being processed by short-term memory, infor-mation is passed to the long-term memory. Note that eachindividual memory has its own format of storing information,and it reorganizes the received information. During the reor-ganization, much information is lost.

Short-term memory is used in most human informationprocessing tasks. However, its capacity is limited [13] and itdecays quickly [11]. Thus a user can manage only a limitedamount of information at a time, and a visualization of a graphshould control visual complexity under a reasonable level toease user’s cognitive load.

Visual complexity in a picture of a software architecture canbe measured by a combination of two factors [10]:

• The diversity of visible elements such as nodes, edges,labels and colors

• Features of the underlying layout, such as symmetry,dimensionality, etc.

III. N AVIGATING CLUSTEREDGRAPHSWITH CONSTANT

V ISUAL COMPLEXITY

This section introduces describes a reference model fornavigating clustered graphs. As an implementation of thisvisualization model, a semantic fisheye view of a clusteredgraph is proposed for conserving constant visual complexityduring navigation. We also describe an animation for smoothtransition of between screens.

A. A Reference Model for Navigating Clustered Graphs

A reference model for navigating clustered graphs is pro-posed in [10]. The reference model consists of three compo-nents:clustered graph, abridgement, and view. In a visual-ization system according to this model, a clustered graph isrepresented by one of its abridgements. Aview is a visualmapping that assign spatial and graphical properties to anabridgement.

Users interact with a view, by sending messages to com-ponents of the abridgment to update the abridgement. Inresponse, the system generates a view of the updated abridge-ment. The choice of the next abridgement and its view isan abstraction strategy. This should choose an abridgementaccording to three requirements:

1) Adequate information supply: the view should containenough information to represent the clustered graph.

2) Mental map requirements: the context of the previousview should be preserved.

3) Constant visual complexity: the visual complexity shouldbe limited.

B. The Semantic Fisheye View of a Clustered Graph

Hereafter, “fisheye view” refers to semantic fisheye view.There are two distance functions in a clustered graph: thedistance in the underlying graph, and the distance in the clustertree. We can combine these to define a DOI function. If weassume that all nodes have the samea priori importance(See II-D), then we can define thegraph DOI of a nodexto be the negative of the the graph distance between a nodex and a focusy. With this function, afirst-order fisheye viewcontains the nodes whose graph distances to a focus are oneor zero. Figure 2 shows a sample of a first-order fisheye viewof a graph with the solid node as the focus.

(a) A graph (b) A fisheye view

Fig. 2. A sample of the first-order fisheye view of a graph

Similarly we can define a clueter tree DOI. Combining thetwo, we get a fisheye view of a clustered graphC = (G,T ).

Figure 3 is a sample of a first-order fisheye view of aclustered graph with the solid cluster as the focus. In thisclustered graph, clusters under clustersc1 are the focus and itssiblings. All siblings of a focus belong to the first-order fisheyeview of the cluster tree. Two child-cluster of clusterc2 belongsto the first-order fisheye view of the underlying graph, but theother two are unrelated clusters (anunrelated clusteris onethat does not belong to a specified fisheye view). The clustersunder clusterc3 are closed because they are unrelated. Theunrelated cluster is clustered under a newly createdpseudo-cluster, which is specially created for containing unrelatedcluster and is represented here by an oval.

c1 c2

c3

(a) A clustered graph

C1

C2

C3

(b) A fisheye view

Fig. 3. A sample of the first-order fisheye view of a clustered graph

C. An Abstraction Strategy

We use a simple abstraction strategy that maintains the firstorder fisheye view.

(a) Initial View (b) Responded ViewV1

(c) Responded ViewV2 (d) Responded ViewV3

Fig. 4. Applying the first order fisheye view as an abstraction strategy

We illustrate the strategy with an example shown in Fig-ure 4. In these diagrams, the shaded opened cluster is theopened focus cluster. Figure 4(a) is the initial view.

The user opens the cluster (we name itc1 for discussion),and Figure 4(b) shows the viewV1 of the abridgementA1

returned by the system. Figure 4(c) shows another respondedview V2, of which the corresponding responded abridgementA2.

The user opens another cluster (we name itc2) as the focus,obtaining viewV2. Clusters that are not in the fisheye view

of A1 are closed, and the closed clusters are clustered undera pseudo-cluster.

Figure 4(d) shows a subsequent viewV3, in which a newfocus is opened. InV3, the child clusters of the focus aredisplayed and the unrelated clusters with respect to the fisheyeview of A2 are closed. Note that all descendant clusters ofc1

are unrelated clusters, and they are closed. Some descendantclusters ofc2 are unrelated clusters, and they are clusteredunder a newly created pseudo-cluster. Other descendant clus-ters ofc2 are clusters of the fisheye view ofA2, and they aredisplayed.

D. Animation

Smooth transition is presented by an animation that consistsof three stage. The first stage shows the process of decreasingthe size of unrelated clusters. The second stage shows theprocess of clustering unrelated clusters under a pseudo-cluster.The third stage shows opening child-clusters of a focus.

Figure 5 shows the keyframes of smooth transition fromFigure 4(b) to Figure 4(c). Figure 5(a) is a key frame thatshows the drawing of responded viewV1 presented in Fig-ure 4(b). Figure 5(b) shows a user opens clusterc2 as a newfocus. In this keyframe, the unrelated clusters are compressed.Figure 5(d) shows all the compressed unrelated clusters areclosed under a newly created pseudo-cluster is enlarged to adefault size. Figure 5(e) shows that all existing clusters aremoved to their final positions and the child-clusters of thefocus are displayed. Figure 5(f) is the drawing of respondedview V2 presented in Figure 4(c).

IV. A N ALGORITHM FOR GENERATING V ISUALIZATIONS

OF SOFTWARE ARCHITECTUREGRAPHS

A graph drawing algorithm is an essential facility for auto-matically generating visualizations of software architectures.This section proposes one such algorithm.

A. The Requirements

A layout algorithm for navigation should satisfy threerequirements: avoiding node overlapping, producing compactoutput and preserving the mental map.

1) Avoiding Node Overlapping:A drawing with node over-lapping cannot convey information effectively. Node over-lapping might occur when a user opens a super-cluster indrawings of clustered graphs. Figure 6 shows a sample thatoverlapping occurs in a dynamic environments. Figure 6(a) isa drawing of a clustered graph, and Figure 6(b) is a drawingof the clustered with a clustered is opened. In Figure 6(b) theopened cluster is enlarged, and its child-clusters are displayed.The enlarged cluster and several of its child-clusters overlaptheir neighbour clusters.

2) Producing Compact Output:An opened super-clustercan be closed during navigation. When a super-cluster isclosed, its child-clusters are disappear, and its size is de-creased. If the closed cluster keeps its original size or position,the space of drawing might be wasted.

(a)

Key

fram

e1(b

)K

eyfr

ame2

(c)

Key

fram

e2(d

)K

eyfr

ame4

(e)

Key

fram

e5(f

)K

eyfr

ame6

Fig

.5.

Key

fram

esof

smoo

thtr

ansi

tion

from

Fig

ure

4(b)

toF

igur

e4(

c)

(a) A layout in a dynamic en-vironment

(b) A node is opened and overlapping occurs

Fig. 6. Node overlapping occurs in a dynamic environment

3) Preserving Mental Map:Preserving the mental mapis a fundamental issue in a dynamic environment of graphvisualization. We measure mental map using theorthogonalordering model(see citeMentalMapPaper).

B. An Adaptive Spring Algorithm: ODNLS

The main issue in drawing clustered graphs is recursivelyremoving node overlapping. We first introduce an adaptivespring algorithm that removes node overlapping in drawings ofa classic graph and preserves the orthogonal order in dynamicdrawing environments. This algorithm is calledOrthogonalDynamic Natural Length Spring (ODNLS) Algorithm. Thenwe use ODNLS in a divide-and-conquer approach to drawclustered graphs.

1) ODNLS Avoids Node Overlapping:ODNLS calculatesthe spring forces using adynamic natural lengthinstead of anatural length with a constant value (see Section II-B). Givena pair of nodesv1 andv2, there is anoverlap free distancekf

for the pair of nodes

kf = l1/2 + l2/2

wherel1 is the length of diagonal ofv1,l2 is the length of diagonal ofv2.

A dynamic natural lengthkd is determined by both thenatural lengthk and the overlap free distancekf as following

kd = max(k′, k)

When the spring mechanism system calculates the forcesbetween a pair of nodes,kd is used to determine the strength ofthe forces. If there is overlapping between a pair of nodes, then

dv1,v2 < kd, and the spring force repels them. Ifdv1,v2 > kd,then the nodes are not overlapping but the edge connectingthem is longer than necessary, and the spring force attractsthe two nodes.

2) ODNLS Preserves the Orthogonal Order:An extra forceis added in order to keep theorthogonal ordering. The extraforce has both repulsive effect and attractive effect in thisspring system.

Given a pair of nodesv1 and v2, andv1 is above and leftto v2. Let Vhorizontal be a set of nodes that are in betweenthe pair in thex direction, andVvertical be a set of nodesthat are in between the pair in they direction. Supposevleft

and vright are the left-most node and right-most node ofVhorizontal respectively, andvtop andvbottom are the highestand lowermost nodes ofVvertical respectively.

If the pair are repelled by the spring force, the ex-tra force moves up/down/left/right all the nodes that areup/down/left/right to the pair. If the pair are attracted by thespring force, andv2 is moved to a position that is left tovright,then the extra force moves it to the position that is right ofvright. If v2 is moved to a position that is upper than any nodeof vbottom, then the extra force moves it to the position that islower thanvbottom. Similar effects are executed onv1. Thus,orthogonal ordering are preserved.

C. Using ODNLS to Draw Clustered Graphs in DynamicEnvironments

In our drawings, the clustering relations are represented byrectangles. SupposeC = (G,T ) is a clustered graph andΓis its drawing. Letcs be a super-cluster, and letcchildren bethe set of child-clusters ofcs. In Γ, cs is drawn as a rectangleR, and cchildren are drawn as rectangles that are completelyinside the contour ofR, and all the other clusters ofC arecompletely outside the contour ofR.

Figure 7 shows a clean layout of Figure 6(b) generated inthis way.

Fig. 7. A clean layout of Figure 6(b) generated by ODNLS

There are two steps to draw clustered graphs using ODNLSin a divided-and-conquer way. In the first step, ODNLS is usedto compute a layout of the child-clusters of a super-clustercs

opened by users. The drawing ofcs is the minimum rectanglethat completely contains the layout of its child-clusters. Thesecond step is to iterate ODNLS to draw the ancestor-clustersof cs from its parent-cluster to the root cluster. Note that there

is no need to compute the drawing of a cluster if it is not achild-cluster ofcs and its depth in the cluster tree is largerthan the depth ofcs.

V. CASE STUDY: NAVIGATING THE ARCHITECTURE OF

COMPILER C488

This section investigates the proposed concepts in a casestudy of navigating of the architecture of the compiler c488.

A. Overview

The compiler c488 is an example software package shippedwith Swagkit, which is a toolkit to extract, abstract and presentsoftware architectures [16]. Its architecture is modeled by aclustered graph, in which super-clusters represent packagesand subpackages, leaf-clusters represent single files, and theedges represent the relations of link or reference. This clus-tered graph has 234 clusters and 424 edges.

Experiments were carried out to compare the visual com-plexity of the first-order fisheye views of a clustered graph tothat of an incremental drawing without filtering clusters duringnavigation. A view generated in an incremental drawing iscalled anincremental view. The visual complexity is calculatedas the number of visualized clusters on a screen.

The experiment began with the initial views of a clusteredgraph, and successively chose a random cluster as the focuscluster to explore until all super-clusters were opened. Thenthe experiment interacted with the clustered graphs with thesame number of interactions, but responded with the first-order fisheye views. Note that we cannot use the same foci tonavigate the same clustered graph, because a fisheye view canclose some clusters and create pseudo-clusters, and generatea different abridgement of the fisheye view from that of anincremental view.

B. Experiments Results

The results show that number of visualized clusters ofthe fisheye views are always less than 50, while that ofthe incremental views sharply increases until all 234 clustersare opened. We can deduce that the first order fisheye viewof clustered graphs can conserve a constant level of visualcomplexity and thus avoid increasing cognitive load.

Table 1 illustrates the incremental views of navigatingthe architecture of c488. In each of these pictures, a newfocus cluster is opened, and child-clusters of the focus aredisplayed on the screen. The number of clusters visualizedis continuously increasing, and the size of drawings becomeenlarged.

Table 2 illustrates the the fisheye views. In fisheye view1, a cluster is opened as the focus, and its child-clusters aredisplayed on the screen. In fisheye view 2, another cluster isopened as a new focus. The child-clusters of the new focusare presented on the screen, and unrelated clusters are filtered.A pseudo-cluster is created to contain these filtered nodesthat are under the same super-cluster if the super-cluster hassome child-clusters that belong to the fisheye view of the new

focus. In the following fisheye views, the same operations areexecuted to form the views.

Table 3 shows the animation process of generating thefirst order fisheye views during navigation. The process ofanimation is described in Section III-D.

VI. CONCLUSION

This paper investigates the issues of complexity of visualiz-ing software architecture. The clustered graph model is used toreduce data complexity, while a navigation model is proposedto solve the visual complexity. To assist the navigation model,the semantic fisheye view of a clustered graph is proposed as alogic abstraction strategy, and a layout algorithm is introducedfor generating visualization of clustered graph in dynamicenvironments. A case study of navigating the architectureof compiler c488 is investigated, and the experiment resultsshow that the semantic fisheye view of a clustered graph canpreserve constant visual complexity during navigation.

In this paper, we measure visual complexity of a visualiza-tion of graph in our case study using the number of clusters.Our future work is to find a fine-grain measurement metricsfor visual complexity.

REFERENCES

[1] L. Bass, P. Clements, and R. Kazman.Software Architecture in Practice.Addison-Wesley, 2003.

[2] G. Di Battista, P. Eades, R. Tamassia, and I. Tollis.Graph Drawing:Algorithms for the Visualization of Graphs. Prentice Hall, 1998.

[3] S. K. Card, J. D. MacKinlay, and B. Shneiderman.Readings inInformation Visualization—Using Vision to Think. Morgan KaufmannPublishers, 1999.

[4] S. Chen and P. Greenfield. Qos evaluation of jms: an empirical approach.In Electronic Proc. of the 37th Hawwaii International Conference onSystem Sciences, page 276, 2004.

[5] L. Feijs and R. De Jong. 3d visualization of software architectures.Communications of the ACM, 41-12, 1998.

[6] W. Feng. Algorithms for Drawing Clustered Graphs. PhD thesis,University of Sydney, 1997.

[7] G. W. Furnas. Generalized fisheye views. InCHI‘86, pages 16–23,1986.

[8] A. E. Hassan and R. C. Holt. A visual architectural approach tomaintaining web applications.Annals of Software Engineering - SpecialVolume on Software, 163, 2003.

[9] W. Li. Navigating clustered graphs. Master’s thesis, University ofSydney, 2005.

[10] W. Li, S. Hong, and P. Eades. A framework for visualising large graphs.In 9th International Conference of Information Visualisation, 2005.

[11] G. Loftus and E. Loftus.Human Memory: the Processing of Information.Lawrence Erlbaum Associates, Inc, 1976.

[12] S. Mancoridis and R. C. Holt. A framework for specifying andvisualizing architectural designs. Technical Report 300, University ofToronto, June 1994.

[13] I.A. Miller. The magical number seven, plus or minus two: Some limitson our capacity for processing information.The Psychologocial Review,63, 1956.

[14] K. Misue, P. Eades, W. Lai, and K. Sugiyama. Layout adjustment andthe mental map.Journal of Visual Language and Computing, 6, 1995.

[15] K. Pulo. Structural Focus + Context Navigation of Relational Data.PhD thesis, University of Sydney, 2005.

[16] SWAG. http://swag.uwaterloo.ca/swagkit/.[17] Colin Ware. Information Visualization : Perception for Design. Morgan

Kaufmann, 2004.[18] K. Zhang. Software Visualization, Series on Software Engineering and

Knowledge Engineering, Vol.7. World Scientific Co., Singapore, 1996.[19] K. Zhang. Software Visualization - From Theory to Practice. Kluwer

Academic Publishers, Boston, 2003.

a) Incremental view 1 b) Incremental view 2 c) Incremental view 3

d) Incremental view 4 e) Incremental view 5 f) Incremental view 6

Table 1. Screenshots of incremental views

a) Fisheye view 1 b) Fisheye view 2 c) Fisheye view 3

d) Fisheye view 4 e) Fisheye view 5 f) Fisheye view 6

Table 2. Screenshots of fisheye views

a) b) c)

d) e) f)

g) h) i)

j) k) l)

m) n) o)

Table 3: Screenshots of animation