Runtime Architectural Visualization
Current practice in software engineering adopts a slew of visualization techniques for abstracting the complexity of software system structure, therefore supporting higher understandability. While techniques for visualizing software structure vary
in appearance and in the semantic elements used, they are predominantly
-- even if they attempt to capture dynamic aspects of software operation. This newly-initiated project is focused on developing the next generation of architectural visualization techniques that both integrate animated elements showing runtime system
behavior and also explore fundamentally different types of visualization approaches that leverage color and three-dimensional shapes to better support understanding the behavior and interactions of software module.
To date, our efforts have been focused on prototyping and experimenting with dynamic visualizations that both augment existing visualization methods with animation to depict runtime activty but also work that breaks the conventional box-and-arrow
paradigm used in techniques ranging from the once-ubiquitous flowchart to the currently-ubiquitous Unified Modeling Language class diagram.
An initial research direction focuses on the use of a particle system metaphor to better support discovery and insight into the structure of a software system and the relationships between its modules.
One application of this approach casts software components as particles that move based on a handful of simple rules related to activity and message exchange in the software system being visualized at runtime. From these simple rules, behavior
emerges that hints at the structure and activity of software components. Disparate components separate while components with structural closeness and close communication channels form animated affinities. The speed of movement is also a
semantically-relevant concept, with particles representing components that exhibit higher activity darting quickly across the screen and inactive particles drifting slowly.
Another experimental approach we are pursuing considers an initial visualization state that parallels a static architectural diagram.
Components are structurally tethered in the visualization to their starting points, which capture structural relationships. As the runtime behavior of the system is integrated into this visualization, components pull, grow, and shrink based on event
messages passed across architectural components -- in essence, the implicit functional interactions between modules. This visualization approach uses speed, size, color, and shading to represent a variety of properties of a system as they changes
over time, including emitting and receiving events.