Augmenting IDEs with Runtime Information for Software Maintenance

Object-oriented language features such as inheritance, abstract types, late-binding, or polymorphism lead to distributed and scattered code, rendering a software system hard to understand and maintain. The integrated development environment (IDE), the primary tool used by developers to maintain software systems, usually purely operates on static source code and does not reveal dynamic relationships between distributed source artifacts, which makes it difficult for developers to understand and navigate software systems. Another shortcoming of today's IDEs is the large amount of information with which they typically overwhelm developers. Large software systems encompass several thousand source artifacts such as classes and methods. These static artifacts are presented by IDEs in views such as trees or source editors. To gain an understanding of a system, developers have to open many such views, which leads to a workspace cluttered with different windows or tabs. Navigating through the code or maintaining a working context is thus difficult for developers working on large software systems. In this dissertation we address the question how to augment IDEs with dynamic information to better navigate scattered code while at the same time not overwhelming developers with even more information in the IDE views. We claim that by first reducing the amount of information developers have to deal with, we are subsequently able to embed dynamic information in the familiar source perspectives of IDEs to better comprehend and navigate large software spaces. We propose means to reduce or mitigate the information by highlighting relevant source elements, by explicitly representing working context, and by automatically housekeeping the workspace in the IDE. We then improve navigation of scattered code by explicitly representing dynamic collaboration and software features in the static source perspectives of IDEs. We validate our claim by conducting empirical experiments with developers and by analyzing recorded development sessions

Software visualization in a multiscale environment

Thesis (M.S.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 1994.Includes bibliographical references (leaves 65-67).by Fred Basas.M.S

Development of a 3d tool for visualization of different software artifacts and their relationships

Este trabajo se enfoca en el desarrollo de una herramienta de visualización de software que permite analizar diferentes artefactos de software como código fuente y bases de datos relacionales. Por su naturaleza, la herramienta creada propone una metáfora basada en desarrollos anteriores del campo de visualización de software. La primera parte del documento de tesis presenta un estado del arte en el área de visualización de software, esto incluye la forma en cómo esta área aporta al proceso de evolución de software, punto muy importante en la ingeniería de software. Posteriormente se presenta la fundamentación básica de SeeIT 3D (nombre de la herramienta desarrollada): su metáfora, métricas, mecanismos para entrada de datos y tecnologías que hacen parte de la arquitectura interna. Luego, con el fin de validar la funcionalidad de la herramienta y dar soporte a los fundamentos en los que se basa, se evaluaron un conjunto de proyectos de código abierto escritos en lenguaje Java, que por su tamaño medio e historia bien definida en el área que representan, proveen un buen marco de evaluación. Finalmente como resultado del trabajo de tesis es posible concluir que la visualización de software realmente da un buen soporte a las tareas asociadas al proceso de evolución de software, brindando mecanismos que permiten comprender más fácilmente los artefactos producidos durante el desarrollo de software. De igual manera se concluyen que SeeIT 3D es una buena aproximación y un avance en el campo dadas sus capacidades. / Abstract.This work is focused in the development of a software visualization tool that is able to analyze different software artifacts such as source code and relational databases. Because of its nature, the tool proposes a metaphor based on previous works developed in the software visualization field. The beginning of the thesis document presents a state of art of software visualization; it includes how visualization supports the process of software evolution. After that the basis of SeeIT 3D (name of the developed tool) is presented e.g. the metaphor, metrics, input mechanism and technologies that conform its internal architecture. In order to validate the functionality of the tool and give support to the concepts it is based on, a set of open source projects written in Java language was evaluated. These projects have a medium size and a well-defined history in the field they represent that provide an adequate evaluation framework for the tool. Finally as a result of the thesis work it is possible to conclude that software visualization really provides enough support for the task associated with the evolution process of software systems. It is provided by giving mechanisms that allow understanding the produced software artifacts easily. It is also possible to concluded that SeeIT 3D is a good approximation and a step forward in the field due to its capabilities.Maestrí

Visualization of graphs and trees for software analysis

A software architecture is an abstraction of a software system, which is indispensable for many software engineering tasks. Unfortunately, in many cases information pertaining to the software architecture is not available, outdated, or inappropriate for the task at hand. The RECONSTRUCTOR project focuses on software architecture reconstruction, i.e., obtaining architectural information from an existing system. Our research, which is part of RECONSTRUCTOR, focuses on interactive visualization and tries to answer the following question: How can users be enabled to understand the large amounts of information relevant for program understanding using visual representations? To answer this question, we have iteratively developed a number of techniques for visualizing software systems. A large number of these cases consists of hierarchically organized data, combined with adjacency relations. Examples are function calls within a hierarchically organized software system and correspondence relations between two different versions of a hierarchically organized software system. Hierarchical Edge Bundles (HEBs) are used to visualize adjacency relations in hierarchically organized data, such as the aforementioned function calls within a software system. HEBs significantly reduce visual clutter by visually bundling relations together. Massive Sequence Views (MSVs) are used in conjunction with HEBs to enable analysis of sequences of relations, such as function-call traces. HEBs are furthermore used to visually compare hierarchically organized data, e.g., two different versions of a software system. HEBs visually emphasize splits, joins, and relocations of subhierarchies and provide for interactive selection of sets of relations. Since HEBs require a hierarchy to perform the bundling, we present Force-Directed Edge Bundles (FDEBs) as an alternative to visually bundle relations together in the absence of a hierarchical component. FDEBs use a self-organizing approach to bundling in which edges are modeled as flexible springs that can attract each other. As a result, visual clutter is reduced and high-level edge patterns are better visible. Finally, in all these methods, a clear depiction of the direction of edges is important. We have therefore performed a separate study in which we evaluated ten representations (including the standard arrow) for depicting directed edges in a controlled user study

Embedding Spatial Software Visualization in the IDE: an Exploratory Study

Software visualization can be of great use for understanding and exploring a software system in an intuitive manner. Spatial representation of software is a promising approach of increasing interest. However, little is known about how developers interact with spatial visualizations that are embedded in the IDE. In this paper, we present a pilot study that explores the use of Software Cartography for program comprehension of an unknown system. We investigated whether developers establish a spatial memory of the system, whether clustering by topic offers a sound base layout, and how developers interact with maps. We report our results in the form of observations, hypotheses, and implications. Key findings are a) that developers made good use of the map to inspect search results and call graphs, and b) that developers found the base layout surprising and often confusing. We conclude with concrete advice for the design of embedded software maps.Comment: To appear in proceedings of SOFTVIS 2010 conferenc