Adaptive Detection of Design Flaws

AbstractCriteria for software quality measurement depend on the application area. In large software systems criteria like maintainability, comprehensibility and extensibility play an important role.My aim is to identify design flaws in software systems automatically and thus to avoid “bad” — incomprehensible, hardly expandable and changeable — program structures.Depending on the perception and experience of the searching engineer, design flaws are interpreted in a different way. I propose to combine known methods for finding design flaws on the basis of metrics with machine learning mechanisms, such that design flaw detection is adaptable to different views.This paper presents the underlying method, describes an analysis tool for Java programs and shows results of an initial case study

Visualization and Evolution of Software Architectures

Software systems are an integral component of our everyday life as we find them in tools and embedded in equipment all around us. In order to ensure smooth, predictable, and accurate operation of these systems, it is crucial to produce and maintain systems that are highly reliable. A well-designed and well-maintained architecture goes a long way in achieving this goal. However, due to the intangible and often complex nature of software architecture, this task can be quite complicated. The field of software architecture visualization aims to ease this task by providing tools and techniques to examine the hierarchy, relationship, evolution, and quality of architecture components. In this paper, we present a discourse on the state of the art of software architecture visualization techniques. Further, we highlight the importance of developing solutions tailored to meet the needs and requirements of the stakeholders involved in the analysis process

Towards Actionable Visualization for Software Developers

Abundant studies have shown that visualization is advantageous for software developers, yet adopting visualization during software development is not a common practice due to the large effort involved in finding an appropriate visualization. Developers require support to facilitate that task. Among 368 papers in SOFTVIS/VISSOFT venues, we identify 86 design study papers about the application of visualization to relieve concerns in software development. We extract from these studies the task, need, audience, data source, representation, medium and tool; and we characterize them according to the subject, process and problem domain. On the one hand, we support software developers to put visualization in action by mapping existing visualization techniques to particular needs from different perspectives. On the other hand, we highlight the problem domains that are overlooked in the field and need more support

Analyzing feature implementation by visual exploration of architecturally-embedded call-graphs

ABSTRACT Maintenance, reengineering, and refactoring of large and complex software systems are commonly based on modifications and enhancements related to features. Before developers can modify feature functionality they have to locate the relevant code components and understand the components' interaction. In this paper, we present a prototype tool for analyzing feature implementation of large C/C++ software systems by visual exploration of dynamically extracted call relations between code components. The component interaction can be analyzed on various abstraction levels ranging from function interaction up to interaction of the system with shared libraries of the operating system. The user visually explores the component interaction within a multiview visualization system consisting of various textual and a graphical 3D landscape view. During exploration the 3D landscape view supports the user firstly in deciding early whether a call relation is essential for understanding the feature and, secondly, in finding starting points for fine-grained feature analysis using a top-down approach

Visualizing three-dimensional graph drawings

viii, 110 leaves : ill. (some col.) ; 29 cm.The GLuskap system for interactive three-dimensional graph drawing applies techniques of scientific visualization and interactive systems to the construction, display, and analysis of graph drawings. Important features of the system include support for large-screen stereographic 3D display with immersive head-tracking and motion-tracked interactive 3D wand control. A distributed rendering architecture contributes to the portability of the system, with user control performed on a laptop computer without specialized graphics hardware. An interface for implementing graph drawing layout and analysis algorithms in the Python programming language is also provided. This thesis describes comprehensively the work on the system by the author—this work includes the design and implementation of the major features described above. Further directions for continued development and research in cognitive tools for graph drawing research are also suggested

Comprehending Software Architecture using a Single-View Visualization

Software is among the most complex human artifacts, and visualization is widely acknowledged as important to understanding software. In this paper, we consider the problem of understanding a software system's architecture through visualization. Whereas traditional visualizations use multiple stakeholder-specific views to present different kinds of task-specific information, we propose an additional visualization technique that unifies the presentation of various kinds of architecture-level information, thereby allowing a variety of stakeholders to quickly see and communicate current development, quality, and costs of a software system. For future empirical evaluation of multi-aspect, single-view architectural visualizations, we have implemented our idea in an existing visualization tool, Vizz3D. Our implementation includes techniques, such as the use of a city metaphor, that reduce visual complexity in order to support single-view visualizations of large-scale programs

3D Hierarchical Edge Bundles to Visualize Relations in a Software City Metaphor

International audienceSoftware 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 to 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

Visualization of the Static aspects of Software: a survey

International audienceSoftware is usually complex and always intangible. In practice, the development and maintenance processes are time-consuming activities mainly because software complexity is difficult to manage. Graphical visualization of software has the potential to result in a better and faster understanding of its design and functionality, saving time and providing valuable information to improve its quality. However, visualizing software is not an easy task because of the huge amount of information comprised in the software. Furthermore, the information content increases significantly once the time dimension to visualize the evolution of the software is taken into account. Human perception of information and cognitive factors must thus be taken into account to improve the understandability of the visualization. In this paper, we survey visualization techniques, both 2D- and 3D-based, representing the static aspects of the software and its evolution. We categorize these techniques according to the issues they focus on, in order to help compare them and identify the most relevant techniques and tools for a given problem