Software Visualization 101+

Software Visualization 101+
Michele Lanza

REVEAL @ Faculty of Informatics
University of Lugano, Switzerland

immersive
ﬁne-grained
software
software evolution
visualization
synchronous
next-gen visual
development
programming

software ecosystems

bug analysis/prediction

holistic evolution

Immersive Software Visualization

‣ R. Wettel, M. Lanza; Program Comprehension through Software Habitability. In
ICPC 2007 (15th IEEE International Conference on Program Comprehension),
pp. 231 - 240, IEEE CS Press, 2007
‣ R. Wettel, M. Lanza; Visualizing Software Systems as Cities. In VISSOFT 2007
(4th IEEE International Workshop on Visualizing Software for Understanding and
Analysis), pp. 92 - 99, IEEE CS Press, 2007
‣ R. Wettel, M. Lanza; Visually Localizing Design Problems with Disharmony
Maps. In Softvis 2008 (4th ACM International Symposium on Software
Visualization), pp. 155 - 164, ACM Press, 2008
‣ R. Wettel, M. Lanza; Visual Exploration of Large-scale System Evolution. In
WCRE 2008 (15th IEEE Working Conference on Reverse Engineering), pp. 219
- 228, IEEE CS Press, 2008
Richard Wettel
‣ R. Wettel, M. Lanza; CodeCity: 3D Visualization of Evolving Large-Scale
Software. In ICSE 2008 (30th ACM/IEEE International Conference on Software
Engineering), pp. 921 - 922, ACM Press, 2008.

CodeCity

[Software is] anything
but hardware, [...] the "soft"
part is the intangible objects
inside the computer.

/***************************************************************************/ if(i<0||E-S&&b[E]&&y-E<2&E-y<2)m=I; /* K capt. or bad castling */
/* micro-Max, */ if(m>=l)goto C; /* abort on fail high */
/* A chess program smaller than 2KB (of non-blank source), by H.G. Muller */
/***************************************************************************/
/* version 3.2 (2000 characters) features: */
/* - recursive negamax search */
/* - quiescence search with recaptures */
/* - recapture extensions */ if(h=d-(y!=z)) /* remaining depth(-recapt.)*/
/* - (internal) iterative deepening */ {v=p<6?b[x+8]-b[y+8]:0; /* center positional pts. */
/* - best-move-first 'sorting' */ b[G]=b[H]=b[x]=0;b[y]=u&31; /* do move, strip virgin-bit*/
/* - a hash table storing score and best move */ if(!(G&M)){b[F]=k+6;v+=30;} /* castling: put R & score */
/* - full FIDE rules (expt minor ptomotion) and move-legality checking */ if(p<3) /* pawns: */
{v-=9*(((x-2)&M||b[x-2]!=u)+ /* structure, undefended */
#define F(I,S,N) for(I=S;I<N;I++) ((x+2)&M||b[x+2]!=u)-1); /* squares plus bias */
#define W(A) while(A) if(y+r+1&S){b[y]|=7;i+=C;} /* promote p to Q, add score*/
#define K(A,B) *(int*)(T+A+(B&8)+S*(B&7)) }
#define J(A) K(y+A,b[y])-K(x+A,u)-K(H+A,t) v=-D(24-k,-l-(l>e),m>q?-m:-q,-e-v-i, /* recursive eval. of reply */
J+J(0),Z+J(8)+G-S,F,y,h); /* J,Z: hash keys */
#define U 16777224 v-=v>e; /* delayed-gain penalty */
struct _ {int K,V;char X,Y,D;} A[U]; /* hash table, 16M+8 entries*/ if(z==9) /* called as move-legality */
{if(v!=-I&x==K&y==L) /* checker: if move found */
int V=112,M=136,S=128,I=8e4,C=799,Q,N,i; /* V=0x70=rank mask, M=0x88 */ {Q=-e-i;O=F;return l;} /* & not in check, signal */
v=m; /* (prevent fail-lows on */
char O,K,L, } /* K-capt. replies) */
w[]={0,1,1,3,-1,3,5,9}, /* relative piece values */ b[G]=k+38;b[F]=b[y]=0;b[x]=u;b[H]=t; /* undo move,G can be dummy */
o[]={-16,-15,-17,0,1,16,0,1,16,15,17,0,14,18,31,33,0, /* step-vector lists */ if(Y&8){m=v;Y&=~8;goto A;} /* best=1st done,redo normal*/
7,-1,11,6,8,3,6, /* 1st dir. in o[] per piece*/ if(v>m){m=v;X=x;Y=y|S&G;} /* update max, mark with S */
6,3,5,7,4,5,3,6}, /* initial piece setup */ } /* if non castling */
b[129], /* board: half of 16x8+dummy*/ t+=p<5; /* fake capt. for nonsliding*/
T[1035], /* hash translation table */ if(p<3&6*k+(y&V)==S /* pawn on 3rd/6th, or */
||(u&~24)==36&j==7&& /* virgin K moving sideways,*/
n[]=".?+nkbrq?*?NKBRQ"; /* piece symbols on printout*/ G&M&&b[G=(x|7)-(r>>1&7)]&32 /* 1st, virgin R in corner G*/
&&!(b[G^1]|b[G^2]) /* 2 empty sqrs. next to R */
D(k,q,l,e,J,Z,E,z,n) /* recursive minimax search, k=moving side, n=depth*/ ){F=y;t--;} /* unfake capt., enable e.p.*/
int k,q,l,e,J,Z,E,z,n; /* (q,l)=window, e=current eval. score, E=e.p. sqr.*/ }W(!t); /* if not capt. continue ray*/
{ /* e=score, z=prev.dest; J,Z=hashkeys; return score*/ }}}W((x=x+9&~M)-B); /* next sqr. of board, wrap */
int j,r,m,v,d,h,i=9,F,G; C:if(m>I/4|m<-I/4)d=99; /* mate is indep. of depth */
char t,p,u,x,y,X,Y,H,B; m=m+I?m:-D(24-k,-I,I,0,J,Z,S,S,1)/2; /* best loses K: (stale)mate*/
struct _*a=A; if(!a->K|(a->X&M)!=M|a->D<=d) /* if new/better type/depth:*/
/* lookup pos. in hash table*/ {a->K=Z;a->V=m;a->D=d;A->K=0; /* store in hash,dummy stays*/
j=(k*E^J)&U-9; /* try 8 consec. locations */ a->X=X|8*(m>q)|S*(m<l);a->Y=Y; /* empty, type (limit/exact)*/
W((h=A[++j].K)&&h-Z&&--i); /* first empty or match */ } /* encoded in X S,8 bits */
a+=i?j:0; /* dummy A[0] if miss & full*/ /*if(z==8)printf("%2d ply, %9d searched, %6d by (%2x,%2x)
if(a->K) /* hit: pos. is in hash tab */ n",d-1,N,m,X,Y&0x77);*/
{d=a->D;v=a->V;X=a->X; /* examine stored data */ }
if(d>=n) /* if depth sufficient: */ if(z&8){K=X;L=Y&~M;}
{if(v>=l|X&S&&v<=q|X&8)return v; /* use if window compatible */ return m;
d=n-1; /* or use as iter. start */ }
}X&=~M;Y=a->Y; /* with best-move hint */
Y=d?Y:0; /* don't try best at d=0 */ main()
}else d=X=Y=0; /* start iter., no best yet */ {
N++; /* node count (for timing) */ int j,k=8,*p,c[9];
W(d++<n|z==8&N<1e7&d<98) /* iterative deepening loop */
{x=B=X; /* start scan at prev. best */ F(i,0,8)
Y|=8&Y>>4; /* request try noncastl. 1st*/ {b[i]=(b[i+V]=o[i+24]+40)+8;b[i+16]=18;b[i+96]=9; /* initial board setup*/
m=d>1?-I:e; /* unconsidered:static eval */ F(j,0,8)b[16*j+i+8]=(i-4)*(i-4)+(j-3.5)*(j-3.5); /* center-pts table */
do{u=b[x]; /* scan board looking for */ } /*(in unused half b[])*/
if(u&k) /* own piece (inefficient!)*/ F(i,M,1035)T[i]=random()>>9;
{r=p=u&7; /* p = piece type (set r>0) */
j=o[p+16]; /* first step vector f.piece*/ W(1) /* play loop */
W(r=p>2&r<0?-r:-o[++j]) /* loop over directions o[] */ {F(i,0,121)printf(" %c",i&8&&(i+=7)?10:n[b[i]&15]); /* print board */
{A: /* resume normal after best */ p=c;W((*p++=getchar())>10); /* read input line */
y=x;F=G=S; /* (x,y)=move, (F,G)=castl.R*/ N=0;
do{H=y+=r; /* y traverses ray */ if(*c-10){K=c[0]-16*c[1]+C;L=c[2]-16*c[3]+C;}else /* parse entered move */
if(Y&8)H=y=Y&~M; /* sneak in prev. best move */ D(k,-I,I,Q,1,1,O,8,0); /* or think up one */
if(y&M)break; /* board edge hit */ F(i,0,U)A[i].K=0; /* clear hash table */
if(p<3&y==E)H=y^16; /* shift capt.sqr. H if e.p.*/ if(D(k,-I,I,Q,1,1,O,9,2)==I)k^=24; /* check legality & do*/
t=b[H];if(t&k|p<3&!(r&7)!=!t)break; /* capt. own, bad pawn mode */ }
i=99*w[t&7]; /* value of capt. piece t */ }

Part III
Software Visualization

“The use of the crafts of typography,
graphic design, animation, and
cinematography with modern
human-computer interaction and
computer graphics technology to
facilitate both the human
understanding and effective use of
computer software.”

John Stasko, 1998

“The use of the crafts of typography,
graphic design, animation, and
cinematography with modern
human-computer interaction and
computer graphics technology to
facilitate both the human
understanding and effective use of
computer software.”

z at ion
isu ali
ar ev
so ftw
n ot

A picture is worth a thousand words

ng
ro thousand words
w
A picture is worth a

Visualization is about stories

the
ith ly
g w eral
hin lit
th et
to ok ds too
L
UM and w or
t ho us

We are Visual Beings

70% of all brain inputs
come through the eyes

We see with our Brain

‣ 3 types of memory to process
visual information
‣ Iconic, the visual sensory register
‣ Short-term, the working memory
‣ (Long-term)

Iconic and Short-term Memory

‣ Iconic Memory is a buffer that retains information for less
than 1 second before passing it to short-term memory


‣ Perception of a limited set of attributes is very fast, automatic &
subconscious, therefore called pre-attentive


‣ Short-term Memory processes information as “chunks”


‣ Storage is temporary and of limited capacity (3-9 chunks)


‣ Storage is temporary and of limited capacity (3-9 chunks)
‣ This explains why charts are more expressive than tables

Pre-attentive Processing Attributes

Pre-attentive Attributes of Form

Orientation Line Length Line Width Size

Shape Curvature Added Marks Enclosure


Line Length Line Width Size



Line Width Size



Size



Curvature Added Marks Enclosure


Added Marks Enclosure


Enclosure

The Polymetric View Principle

number of attributes

number of
number of methods
lines of code

The X-Ray Eclipse Plugin xray.inf.usi.ch

6800+
downloads
Released
Nov 2007 free

Part V
Software Visualization++

The Class Blueprint

Initialize Interface Internal Accessor Attribute

invocation and access direction

Detailing the Class Blueprint

internal access
Access
external
Attribute
access Invocation

Regular Constant
invocations
Overriding Delegating

lines Method
Extending Setter

Initialize Interface Internal Accessor Attribute Abstract Getter

Schizophrenia

Regular Constant


Extending Setter

Abstract Getter

Wannabe

Regular Constant


Extending Setter

Abstract Getter

Gory Details

Regular

Overriding

Extending

Abstract

Constant

Delegating

Setter

Getter

“Software is intangible,
having no physical shape or size.”

Thomas Ball, Stephen Eick

“Software Visualization in the
Large”
In Computer, vol. 29, no.4, pp. 33-43,
IEEE Computer Society Press, 1996

How can we solve Ball’s
dilemma?
Metaphors..

“Habitability is the characteristic of source code
that enables programmers, coders, bug-ﬁxers,
and people coming to the code later in its life to
understand its construction and intentions and
to change it comfortably and conﬁdently.”

Richard Gabriel

“Patterns of Software: Tales from the
Software Community”, Oxford University
Press, 1998.

Visualizing Software as Cities

The City Metaphor

domain mapping

classes buildings

packages districts

system city

The City Metaphor

domain mapping

classes buildings

packages districts

system city

class metric building property
number of methods (NOM) height
number of attributes (NOA) width, length

package metric district property
nesting level color

Large-scale Program Comprehension

argoUML
0.28.1_01

packages
198

classes
2,975

lines
166,735

apache
cocoon
Aug 27 2009

packages
784

classes
4,008

lines
173,436

frostwire
r1223

packages
391

classes
5,798

lines
275,910

jitterbit
r31527

packages
945

classes
10,412

lines
263,645

openswing
r296

packages
268

classes
1,754

lines
112,495

apache bcel
5.2

packages
29

classes
550

lines
19,090

hsqldb
r 3154

packages
103

classes
1,209

lines
158,208

vuze
4.2.0.8

packages
610

classes
5,242

lines
456,064

ScumVM
(C++)

packages
18

classes
1,331

lines
~105,000

Jun
(Smalltalk)

packages
288

classes
2,2236

lines
~351,000

10 systems
(Java,Smalltalk,
C++)

packages
1,777

classes
17,090

lines
~1,272,000

ArgoUML’s ﬁlmstrip

Ver. 0.10.1 Ver. 0.12 Ver. 0.14 ModelFacade
9/10/2002 18/08/2003 5/12/2003

ModelFacade FacadeMDRImpl
NSUMLModelFacade Facade
Ver. 0.16 NSUMLModelFacade
19/07/2004 Facade

Ver. 0.18.1 Ver. 0.20
FacadeMDRImpl
30/04/2005 9/02/2006
Facade

Ver. 0.22 Ver. 0.23.4 Ver. 0.24
8/08/2006 10/12/2006 12/02/2007

The Time Machine

JMol

versions
57 (bi-monthly
snapshots)

time
1999-2007

ArgoUML Age Map

org.argouml.language.cpp STDCTokenTypes FacadeMDRImpl
NOA 152, NOM 0, AGE 4
Facade NOA 3, NOM 351, AGE 4
org.argouml.language.php NOA 1, NOM 339, AGE 5
org.argouml.language.csharp CPPParser
org.argouml.language.java
org.argouml.model

JavaRecognizer

JavaTokenTypes

org.argouml.uml.reveng.java

JavaTokenTypes

JavaRecognizer

Time Travel + Age Map

October 2000
March 2001
September 2001
JHotDraw
March 2002
August 2002 versions
January 2003 8
July 2003
time
January 2004
40 months

Jmol’s Feature Envy

Feature envy

Jmol’s Feature Envy

Feature envy

1,500 methods (25%)

ArgoUML.Model’s Shotgun Surgery Map

Facade AggregationKind VisibilityKind
NOM 140/337 NOM 3/3 NOM 4/4

PseudostateKind
NOM 6/6

Model
NOM 28/44
Shotgun surgery

CodeCity codecity.inf.usi.ch

2800+
downloads
Released
Mar 2008 free

CodeCity codecity.inf.usi.ch

CodeCity

2800+
downloads
Released
Mar 2008 free

Reﬂections
Software Visualization is

Reﬂections

a means to make the intangible tangible

Reﬂections


not so difﬁcult after all

Reﬂections



still in its infancy

Reﬂections



still in its infancy

an exciting research area

Software Visualization 101+

More Related Content

What's hot (17)

Viewers also liked (18)

Similar to Software Visualization 101+ (20)

Software Visualization 101+