By Topic

Visualizing Software for Understanding and Analysis (VISSOFT), 2011 6th IEEE International Workshop on

Date 29-30 Sept. 2011

Filter Results

Displaying Results 1 - 16 of 16
  • [Title page]

    Page(s): 1
    Save to Project icon | Request Permissions | PDF file iconPDF (195 KB)  
    Freely Available from IEEE
  • [Copyright notice]

    Page(s): 1
    Save to Project icon | Request Permissions | PDF file iconPDF (188 KB)  
    Freely Available from IEEE
  • E-Quality: A graph based object oriented software quality visualization tool

    Page(s): 1 - 8
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (1265 KB) |  | HTML iconHTML  

    Recently, with increasing maintenance costs, studies on software quality are becoming increasingly important and widespread because high quality software means more easily maintainable software. Measurement plays a key role in quality improvement activities and metrics are the quantitative measurement of software design quality. In this paper, we introduce a graph based object-oriented software quality visualization tool called "E-Quality". E-Quality automatically extracts quality metrics and class relations from Java source code and visualizes them on a graph-based interactive visual environment. This visual environment effectively simplifies comprehension and refactoring of complex software systems. Our approach assists developers in understanding of software quality attributes by level categorization and intuitive visualization techniques. Experimental results show that the tool can be used to detect software design flaws and refactoring opportunities. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Telling stories about GNOME with Complicity

    Page(s): 1 - 8
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (2629 KB) |  | HTML iconHTML  

    Traditionally, the target of software evolution research has been single software systems. However, in the recent years, researchers observed that software systems are often not developed in isolation, but within a larger context: the ecosystem level. Analyzing software evolution at the ecosystem level allows a better understanding of the evolution phenomenon, as the entire development context can be studied. Nonetheless, software ecosystem analysis is challenging because of the sheer amount of data to be processed and understood. We present Complicity, a web-based application that supports software ecosystem analysis by means of interactive visualizations. Complicity breaks down the data quantity by offering two abstraction levels: ecosystem and entity. To support a thorough exploration and analysis of ecosystem data, the tool provides a number of fixed viewpoints and the possibility of creating new viewpoints with given software metrics. We illustrate in a case study how Complicity can help to understand the GNOME ecosystem in a bottom-up approach, starting from a single project and contributor towards their impact on the ecosystem. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Abstract visualization of runtime memory behavior

    Page(s): 1 - 8
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (2760 KB) |  | HTML iconHTML  

    We present a system for visualizing memory reference traces, the records of the memory transactions performed by a program at runtime. The visualization consists of a structured layout representing the levels of a cache and a set of data glyphs representing the pieces of data in memory being operated on during application runtime. The data glyphs move in response to events generated by a cache simulator, indicating their changing residency in the various levels of the memory hierarchy. Within the levels, the glyphs arrange themselves into higher-order shapes representing the structure of the cache levels, including the composition of their associative cache sets and eviction ordering. We make careful use of different visual channels, including structure, motion, color, and size, to convey salient events as they occur. Our abstract visualization provides a high-level, global view of memory behavior, while giving insight about important events that may help students or software engineers to better understand their software's performance and behavior. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • 3D Hierarchical Edge bundles to visualize relations in a software city metaphor

    Page(s): 1 - 8
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (2595 KB) |  | HTML iconHTML  

    Software systems are often very complex because of their huge size and the tremendous number of interactions between their components. However, understanding relations between software elements is crucial to optimize the development and the maintenance process. A good way to ease this understanding of software relations is to use advanced visualization techniques to graphically see interactions between elements. Nevertheless representing those software relations is not an easy task and often leads to hard to understand clutter. We believe that combining both edge clustering techniques and real-world metaphors can help address this issue, producing easier-to-read visualizations that ease the cognitive process and thus significantly help understanding the underlying software. In this paper, we explain how we adapted the existing 2D Hierarchical Edge bundles technique to represent relations in a 3D space on top of city metaphors. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Constellation visualization: Augmenting program dependence with dynamic information

    Page(s): 1 - 8
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (1841 KB) |  | HTML iconHTML  

    This paper presents a scalable, statement-level visualization that shows related code in a way that supports human interpretation of clustering and context. The visualization is applicable to many software-engineering tasks through the utilization and visualization of problem-specific meta-data. The visualization models statement-level code relations from a system-dependence-graph model of the program being visualized. Dynamic, run-time information is used to augment the static program model to further enable visual cluster identification and interpretation. In addition, we performed a user study of our visualization on an example program domain. The results of the study show that our new visualization successfully revealed relevant context to the programmer participants. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Visually exploring multi-dimensional code couplings

    Page(s): 1 - 8
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (1600 KB) |  | HTML iconHTML  

    Dependencies and coupling relationships between code entities can be manifold. They form a graph structure with several different types of edges. Visualizing these graphs presents two challenges: the often large size of the graphs and the readable representation of the different edge types. In this paper we present a new node-link graph visualization technique addressing these challenges. Different types of edges are represented in multiple, small diagrams. These diagrams are placed side-by-side like the pictures of a comic strip. Among other things, edge bundling is applied to improve the scalability of the visualization. Elaborate interaction techniques with respect to focusing and merging data aim at providing help for comparing different edge types. A case study demonstrates how the visualization can be used to analyze a mid-size software project in practice. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A visual analysis and design tool for planning software reengineerings

    Page(s): 1 - 8
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (2414 KB) |  | HTML iconHTML  

    Reengineering complex software systems represents a non-trivial process. As a fundamental technique in software engineering, reengineering includes (a) reverse engineering the as-is system design, (b) identifying a set of transformations to the design, and (c) applying these transformations. While methods a) and c) are widely supported by existing tools, identifying possible transformations to improve architectural quality is not well supported and, therefore, becomes increasingly complex in aged and large software systems. In this paper we present a novel visual analysis and design tool to support software architects during reengineering tasks in identifying a given software's design and in visually planning quality-improving changes to its design. The tool eases estimating effort and change impact of a planned reengineering. A prototype implementation shows the proposed technique's feasibility. Three case studies conducted on industrial software systems demonstrate usage and scalability of our approach. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Visual support for porting large code bases

    Page(s): 1 - 8
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (4294 KB) |  | HTML iconHTML  

    We present a tool that helps C/C++ developers to estimate the effort and automate software porting. Our tool supports project leaders in planning a porting project by showing where a project must be changed, how many changes are needed, what kinds of changes are needed, and how these interact with the code. For developers, we provide an overview of where a given file must be changed, the structure of that file, and close interaction with typical code editors. To this end, we integrate code querying, program transformation, and software visualization techniques. We illustrate our solution with use-cases on real-world code bases. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A multi-level approach for visualization and exploration of reactive program behavior

    Page(s): 1 - 4
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (537 KB) |  | HTML iconHTML  

    This paper presents an approach for dynamic analysis and visualization of reactive program behavior. The objective is to understand the reactive behavior of complex programs for the purpose of finding unusual and possibly abnormal behavior, locating defects in the code, and finding causes of failures. Based on execution traces a multi-level analysis and visualization approach is proposed where, on one side, the behavior is analyzed to exhibit recurring execution patterns and their similarities and differences at a higher level of abstraction and, on the other side, program behavior can be explored in detail for giving explanations and showing causes of failures. The approach has been implemented as a tool chain for the analysis of PLC control programs. We discuss the key ideas of the approach, the implementation in a tool chain for PLC programs, and preliminary results from a case study. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Visualising concurrent programs with dynamic dependence graphs

    Page(s): 1 - 4
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (206 KB) |  | HTML iconHTML  

    Atropos is a software tool for visualising concurrent program executions intended to help students debug concurrent programs and learn how concurrency works. Atropos supports a slicing debugging strategy by providing a visualisation of dynamic dependence graphs that can be explored to trace the chain of events backwards from a symptom to its cause. In this paper, we present the reasoning behind the design of Atropos and summarise how we evaluated it with students. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Follow that sketch: Lifecycles of diagrams and sketches in software development

    Page(s): 1 - 8
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (266 KB) |  | HTML iconHTML  

    Informal visualization in the form of sketching and diagramming has long been an established practise of professionals working in the fields of design, architecture, and engineering. Less is known, however, about the sketching and diagramming practices of computer scientists and software developers. Through a series of interviews with computer science researchers who develop software, we probed the purpose, contexts, and media in which they created and re-created sketches and diagrams, and the ways in which these informal visualizations evolved over time. Through our analysis we created visualizations of the observed sketching and diagramming lifecycles, which can contribute to a better understanding of the roles of sketching and diagramming in software development. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • An interactive differential and temporal approach to visually analyze software evolution

    Page(s): 1 - 4
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (428 KB) |  | HTML iconHTML  

    Software evolution is one of the most important topics in modern software engineering research. It deals with complex information and large amounts of data. Software visualization can be helpful in this scenario, helping to summarize, analyze and understand software evolution data. This paper presents SourceMiner Evolution (SME), a software tool that uses an interactive differential and temporal approach to visualize software evolution. The tool is implemented as an Eclipse plug-in and has four views that are assembled directly from the IDE AST. The views portray the software from different perspectives. One view shows how metrics of a chosen software entity evolves over time. The other three views show differential comparisons of any two versions of a system structure, dependency and inheritance properties. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Visual exploration of program structure, dependencies and metrics with SolidSX

    Page(s): 1 - 4
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (2776 KB) |  | HTML iconHTML  

    We present SolidSX, an visual analysis tool for code structure, dependencies, and metrics. Our tool facilitates the understanding of large program code bases by simplifying the entire pipeline from data acquisition up to visualization and interactive querying. Secondly, SolidSX is an easy to use, scalable, and configurable visualization component for compound attributed graphs extracted by third-party tools, easy to integrate by developers in their own applications. We detail the architecture and functions of SolidSX, present examples for its two use-cases, and outline insights collected from tool usage in academia and industry. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • MosaiCode: Visualizing large scale software: A tool demonstration

    Page(s): 1 - 4
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (940 KB) |  | HTML iconHTML  

    A software visualization tool called MosaiCode is introduced and described. MosaiCode uses a Seesoft metaphor to support the visualization and understanding of various characteristics for large scale software systems. A usage scenario is given to demonstrate the tool. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.