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 itself.

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.

conclusion

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 development experience.

 

Related articles on queue.acm.org

Code Spelunking Redux George V. Neville-Neil http://queue.acm.org/detail.cfm?id=1483108

Visualizing System Latency
Brendan Gregg
http://queue.acm.org/detail.cfm?id=1809426
The Woes of IDEs
Jef Raskin
http://queue.acm.org/detail.cfm?id=864034

References

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 (2010).

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 (sept. 2007).

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 (May 2007).

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). May 2010.

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 Engineering.

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.