44975216
Workshop on graphical documentation for programmers
Programmers often use graphical forms of documentation that rely on software visualization techniques to make complicated information easier to understand. However, it is an open question exactly which types of graphical documentation are most suitable for which types of program understanding tasks (and in which specific usage contexts). This workshop will focus on this issue by exploring the suitability of three classes of graphical documentation (static, interactive, and editable) for selected program understanding tasks that are representative of common software maintenance and evolution scenarios. This workshop is a sequel to the workshop "Documentation for Software Engineers: What is Needed to Aid System Understanding?" which took place at SIGDOC 2001.
13347465
On evaluating the layout of UML class diagrams for program comprehension
UML class diagrams are helpful for understanding the structure of a software system. Algorithms and tools have been developed to generate UML class diagrams automatically for program understanding purposes. However, many tools often ignore perceptual factors in the layout of these diagrams. Therefore, users still have to spend much time and effort rearranging boxes and lines to make the diagram understandable. This paper presents key criteria and guidelines for the effective layout of UML class diagrams from the perspective of perceptual theories. Two UML tools have been analyzed and evaluated to illustrate how the criteria can be applied to improve the readability of class diagrams.
13402065
JRefleX: towards supporting small student software teams
The success of a software development project depends on the technical competency of the development team, the quality of the tools they use, and the project-management decisions they make during the software lifecycle. Instructors of software-engineering courses that involve small project teams are often overwhelmed with the task of monitoring the progress of multiple teams. Without adequate monitoring and advice on best practices, problems in the team's process or the developed product may go unnoticed until it is too late to be easily fixed. This paper introduces the JRefleX environment, with components built upon Eclipse, to support the education of small software teams.
5167918
Extracting Facts from Perl Code
Scripting languages are popular in software development, for rapid prototyping and flexible software integration. Still, there has been relatively more effort spent on reverse engineering for traditional languages, like C, C++, and Java. Certain scripting languages, such as Perl, are notoriously difficult to understand. Consequently, reverse engineering for Perl code is very much needed. Nevertheless, the subtle constructs of the language make it challenging to develop a reliable fact extractor from scratch. Thus, we use the Perl interpreter implementation itself, since it is authoritative for the meaning of some Perl construct. An extractor component is inserted into the interpreter, to consult the internal data structures, and generate the desired facts in a static extraction technique. The facts conform to a schema that is represented in GXL and EMF XML-based formats. A case study evaluated how the extractor processed all the Perl modules provided with the Perl distribution source code
18962931
Analyzing xfig using the Rigi tool suite
An experiment is conducted on how well expert users of program comprehension tools are able to perform specific program understanding and maintenance tasks on the xfig drawing program using these tools. The paper reports on the experiences of the users of the Rigi reverse engineering tool suite. Rigi is an interactive, visual tool designed to help developers better understand and redocument their software. Rigi includes parsers to read the source code of the subject software and produce a graph of extracted artifacts such as procedures, variables, calls, and data accesses. To manage the complexity of the graph, an editor allows the software engineer to automatically or manually collapse related artifacts into subsystems. These subsystems typically represent concepts such as abstract data types or personnel assignments. The created hierarchy can be navigated, analyzed, and presented using various automatic or user-guided graphical layouts.
12666551
Fused data-centric visualizations for software evolution environments
During software evolution, several different facets of the system need to be related to one another at multiple levels of abstraction. Current software evolution tools have limited capabilities for effectively visualizing and evolving multiple system facets in an integrated manner. Many tools provide methods for tracking and relating different levels of abstraction within a single facet. However, it is less well understood how to represent and understand relationships between and among different abstraction hierarchies, i.e. for inter-hierarchy relations. Often, these are represented and explored independently, making them difficult to relate to one another. As a result, engineers are likely to have difficulty understanding how the various facets of a system relate and interact. We describe preliminary results of a collaborative research project between industry and academia to enhance the inter-hierarchy visualization capabilities of an existing software evolution environment called "KLOCwork Suite". Specifically, we describe our efforts to add a "fused" visualization based on story board diagrams. This visualization integrates - or "fuses" - facets of architecture, behavior and data. We describe how these diagrams bridge currently isolated visualizations of system information, and argue how they can help drive architecture excavation tasks.
30764934
Ad Hoc Routing Protocol Performance Comparisons for Vehicular Ad Hoc Networks
6619418
The Software Bookshelf
Legacy software systems are typically complex, geriatric, and difficult to change, having evolved over decades and having passed through many developers. Nevertheless, these systems are mature, heavily used, and constitute massive corporate assets. Migrating such systems to modern platforms is a significant challenge due to the loss of information over time. As a result, we embarked on a research project to design and implement an environment to support software migration. In particular, we focused on migrating legacy PL/I source code to C++, with an initial phase of looking at redocumentation strategies. Recent technologies such as reverse engineering tools and World Wide Web standards now make it possible to build tools that greatly simplify the process of redocumenting a legacy software system. In this paper we introduce the concept of a software bookshelf as a means to capture, organize, and manage information about a legacy software system. We distinguish three roles directly involved in the construction, population, and use of such a bookshelf: the builder, the librarian, and the patron. From these perspectives, we describe requirements for the bookshelf, as well as a generic architecture and a prototype implementation. We also discuss various parsing and analysis tools that were developed and integrated to assist in the recovery of useful information about a legacy system. In addition, we illustrate how a software bookshelf is populated with the information of a given software project and how the bookshelf can be used in a program-understanding scenario. Reported results are based on a pilot project that developed a prototype bookshelf for a software system consisting of approximately 300K lines of code written in a PL/I dialect.
12936831
On designing an experiment to evaluate a reverse engineering tool
The Rigi reverse engineering system is designed to analyze and summarize the structure of large software systems. Two contrasting approaches are available for visualizing software structures in the Rigi graph editor. The first approach displays the structures through multiple, individual windows. The second approach, simple hierarchical multi-perspective (SHriMP) views, employs fisheye views of nested graphs. The paper describes the design of an experiment to evaluate these alternative user interfaces. Various results from a preliminary pilot study to test the experiment design are reported.
11319559
On inserting program understanding technology into the software change process
Program understanding technologies can be applied effectively in the analysis phase of a software change process. The analysis phase naturally follows a goal driven metaprocess. Described are issues involved with inserting program understanding technology into existing practice and into such a metaprocess. The implied processes of program understanding and reverse engineering tools play an important role. These issues pose major problems for the acceptance of redocumentation tools such as Rigi, an evolvable reverse engineering tool. An example using Rigi and its analysis methodology for change impact analysis is considered.
30089105
A fixed point theorem for o-minimal structures
We prove a definable analogue to Brouwer's Fixed Point Theorem for o-minimal structures of real closed field expansions: A continuous definable function mapping from the unit simplex into itself admits a fixed point, even though the underlying space is not necessarily topologically complete. Our proof is direct and elementary; it uses a triangulation technique for o-minimal functions, with an application of Sperner's Lemma. (© 2003 WILEY-VCH Verlag GmbH & Co. KGaA, Weinheim)