18706172
Connecting technical communicators with technical developers
Most program documentation is written by developers for developers. This often results in documentation that is less than satisfactory in terms of quality, relevance, and longevity of information to developers who will be responsible for subsequent enhancements to the product. This paper outlines an approach to producing effective program documentation by connecting technical communicators and technical developers in a pair-wise manner. This approach is modeled on the development methodology advocated by eXtreme Programming (XP). Programmers who adopt XP work in pairs, and thus are in constant communication with one another. By pairing a technical communicator with a technical developer, many of the same benefits can be gained. Rather than eschewing program documentation, the paired communicator and developer instead produce high-quality documentation during the development process, with little extra effort, resulting in a more maintainable software application. The paper also describes some recent experiences in pairing a senior person and a junior person in communicator and developer roles to enhance program documentation of a long-lived and popular research application.
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.
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
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.
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.
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.
62300434
How do program understanding tools affect how programmers understand programs?
Abstract In this paper, we explore the question of whether program understanding tools enhance or change the way that programmers understand programs. The strategies that programmers use to comprehend programs vary widely. Program understanding tools should enhance or ease the programmer's preferred strategies, rather than impose a fixed strategy that may not always be suitable. We present observations from a user study that compares three tools for browsing program source code and exploring software structures. In this study, 30 participants used these tools to solve several high-level program understanding tasks. These tasks required a broad range of comprehension strategies. We describe how these tools supported or hindered the diverse comprehension strategies used.
7493579
CLARE—a Prolog database machine
The CLAuse Retrieval Engine (CLARE) is a coprocessor system which based on two-stage filtering, for handling large sets of disc resident clauses in Prolog database applications. The overall architecture and the timing measurements of the first stage CLARE hardware are reported. The timing measurements shows that the first stage CLARE hardware can perform search operations on data transferring at a rate up to 4.5 million double bytes per second.
34471388
Compressing and Restoring Multiple Images Using Variable Threshold Values
1165688
A Chinese dictionary construction algorithm for information retrieval
In this article we propose a method for constructing, from raw Chinese text, a statistics-based automatic dictionary. The method makes use of local statistical information (i.e., data within a document) to identify and discard repeated string patterns, which, at an earlier stage, were substrings of legitimate words. Global statistical information (which exists throughout the entire corpus) and contextual constraints are then used for further filtering. The method can be used to alleviate the out-of-vocabulary (OOV) problem, which is commonly found in dictionary-based natural language information-processing applications, e.g., word segmentation. It can handle text corpora dynamically and, further, it does not impose any strict requirements on the size and quality of the training corpora. Based on our method, we constructed Chinese dictionaries from different Chinese corpora. We then applied the words in the constructed dictionaries to indexing in information retrieval (IR). Retrieval performance using such indexes was compared to the same, but based on indexes produced by static dictionaries. Three Chinese corpora using various character-encoding schemes and language styles were used in the experiments. The results show that retrieval using indexes based on the constructed dictionary is effective. This implies that fully automatic Chinese dictionary construction based on dynamic data sources, e.g., from the Internet, for the purposes of IR is feasible. Drawing on the experiment, we were able to make some interesting observations: (1) using only a portion of a dictionary is enough to produce good retrieval performance, e.g., a dictionary consisting of only the 500 highest-frequency strings extracted from the NTCIR 2 Chinese corpus produced as good a retrieval result as using a more complete dictionary with over 100K entries; and (2) complete word segmentation is not a strict requirement for achieving practical information retrieval.
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.