using the standard editor, which provides the usual syntactic formatting
and coloring and standard editor features such as code completion. At intermediate levels of zoom the code becomes visible, first in a skeletal form
(in the style of Seesoft, 6 a well-known
software visualization tool from the
early 1990s), then as readable text.
For a tour of Code Canvas’s features, let’s replay our initial story.
Jane’s development environment
shows an overview map of the whole
project, called the HOME canvas. Its
layout is as familiar to her as her hometown, since she has been moving around
both of them for years. To start her task
of understanding her project’s dependency on the unsupported library, she
searches for uses of the library. The
search results are overlaid on the map
in yellow boxes (as shown in Figure 3)
in addition to being listed in a separate
window. She immediately sees the two
parts of the code that depend on the library. She zooms into one of them to
look closer at exactly which classes are
implicated and then clicks on an individual search result to look at the code
After exploring this way for a while,
she decides to focus on just the relevant
code, so she creates a new “filtered canvas” in a new tab that contains the subset
of the code containing the search results,
maintaining the spatial relationships
that help her stay oriented. As on the
HOME canvas, the code on the filtered
canvas is shown inside boxes representing the relevant classes and interfaces.
This filtered canvas acts as the class diagram Jane previously drew on her notepad, except here the search results and
class diagram are automatically kept in
sync and are persisted together.
Joe knocks on the door and asks Jane
a question. She clicks over to the HOME
canvas tab, zooms out, and points at
parts of it to support what she’s saying.
The HOME canvas is shared among all
team members, precisely to provide a
common ground around which the team
can have discussions. To explain the
feature that is puzzling Joe, Jane sets a
debugger breakpoint and runs the pro-
gram. When the breakpoint is reached,
Code Canvas shows the call stack us-
ing a series of red execution arrows, like
those in Figure 3. Jane then creates a sec-
ond filtered canvas, focused on this call
stack. She zooms out to give Jim a tour
of the parts of the code involved in the
feature. When Joe asks detailed ques-
tions about the algorithms, Jane zooms
in on the relevant code. When the con-
versation with Joe is over, Jane simply
closes the new tabs and returns to the
one where she was working, which looks
exactly as she left it.
Based the work practices we observed
in our field studies, we believe making
a code map central to the user interface of the development environment
promises to reduce disorientation, answer common information needs, and
anchor team conversations. Spatial
memory and reasoning are little used
by software developers today. In a lab-based evaluation of a previous version
of our code-map design, we showed
that developers form a reliable spatial
memory of a code map during 90-min-
ute sessions of programming tasks. 4
By exploiting these cognitive resources, code maps will allow developers
to be better grounded in the code,
whether working solo or collaboratively. We believe this will fundamentally change and improve the software
Code Spelunking Redux
George V. Neville-Neil
Visualizing System Latency
The Woes of IDEs
1. bragdon, a., reiss, s.P., Zeleznik, r., Karumuri, s.,
Cheung, W., Kaplan, J., Coleman, C., adeputra,
F., laViola Jr., J.J. Code bubbles: rethinking the
user interface paradigm of integrated development
environments. In Proceedings of the 32nd
International Conference on Software Engineering
2. Cherubini, M., Venolia, G., deline, r. building
an ecologically valid, large-scale diagram to
help developers stay oriented in their code. In
Proceedings of the IEEE Symposium on Visual
Languages and Human-Centric Cowmputing
3. Cherubini, M., Venolia, G., deline, r., Ko, a.J. let’s go
to the whiteboard: How and why software developers
use drawings. In Proceedings of the SIGCHI
Conference on Human Factors in Computing Systems
4. deline, r., Czerwinski, M., Meyers, b., Venolia,
G., drucker, s., robertson, G. Code thumbnails:
using spatial memory to navigate source code.
In Proceedings of the IEEE Symposium on Visual
Languages and Human-centric Computing (2006).
5. deline, r., rowan, K. Code Canvas: Zooming toward
better development environments. In Proceedings
of the International Conference on Software
Engineering (New Ideas and Emerging Results).
6. eick, s.C., steffen, J.l., sumner Jr., e.e. 1992.
seesoft: a tool for visualizing line-oriented
software statistics. IEEE Transactions on Software
Engineering 18, 11 (1992), 957-968.
7. Ko, a.J., deline, r., Venolia, G. Information needs
in collocated software development teams. In
Proceedings of the 29th International Conference on
Software Engineering (May 2007).
8. sillito, J., Murphy, G. C., de Volder, K. 2008. asking
and answering questions during a programming
change task. IEEE Transactions on Software
9. storey, M.a., best, C., Michaud, J., rayside, d.,
litoiu, M., Musen, M. sHriMP views: an interactive
environment for information visualization and
navigation. In Proceedings of the Conference on
Human Factors in Computing Systems (May 2002).
10. Wettel, r., lanza, M. Visualizing software systems
as cities. In Proceedings of the IEEE International
Workshop on Visualizing Software for Understanding
and Analysis (2007).
Robert DeLine ( http://research.microsoft.com/~rdeline)
is a Principal researcher at Microsoft research, working
at the intersection of software engineering and human-computer interaction. His research group designs
development tools in a user-centered fashion: they
conduct studies of development teams to understand their
work practice and prototype tools to improve that practice.
Kael Rowan ( http://research.microsoft.com/~kaelr) is a
senior research software design engineer at Microsoft
research, focusing on the next generation of software
development including software visualization and
spatial layout of source code. His background has gone
from operating system internals and formal software
verification to modern user interfaces and HCI.
Gina Venolia ( http://research.microsoft.com/~ginav) is a
senior researcher with Microsoft research in the Human
Interactions of Programming group. Her research focuses
on building systems that make knowledge flow more
freely among people. she is studying distributed software
teams and developing systems that exploit spatial
memory to support navigation and team awareness.