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.
29660826
Issues in accessing Web sites from mobile devices
Mobile devices such as PDAs and cellular phones that offer Internet access are proliferating. Due to the many unique characteristics of these devices, such as their small screen size and limited network connectivity, existing Web sites may have to undergo significant evolution to support this type of mobile client. The paper outlines some of the issues in accessing Web sites from mobile devices, such as the Apple Newton, the Compaq iPAQ, and WAP-enabled cell phones. These issues are based on our experiences as both users of mobile devices and as content providers.
1185231
Rigi: A Visualization Environment for Reverse Engineering
The Rigi reverse engineering system provides tNo contrasting approaches for presenting software structures in its graph editor. The first displays the structures through multiple, individual NindoNs. The second (neNer) approach, Simple Hierarchical MultiPerspective (SHriMP) views, employs fisheye views of nested graphs. We compare and contrast these tNo interfaces for visualizing software graphs, and provide results from user experiments.
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
11555065
Reverse Engineering Scripting Language Extensions
Software systems are often written in more than one programming language. During development, programmers need to understand not only the dependencies among code in a particular language, but dependencies that span languages. In this paper, we focus on the problem of scripting languages (such as Perl) and their extension mechanisms to calling functions with a C interface. Our general approach involves building a fact extractor for each scripting language, by hooking into the language interpreter itself. The produced facts conform to a common schema, and an analyzer is extended to recognize the cross-language dependencies. We present how these statically discovered dependencies can be represented, visualized, and explored in the Eclipse environment
207701477
Reverse engineering: a roadmap
By the early 1990s the need for reengineering legacy systems was already acute, but recently the demand has increased significantly with the shift toward web-based user interfaces. The demand by all business sectors to adapt their information systems to the Web has created a tremendous need for methods, tools, and infrastructures to evolve and exploit existing applications efficiently and cost-effectively. Reverse engineering has been heralded as one of the most promising technologies to combat this legacy systems problem. This paper presents a roadmap for reverse engineering research for the first decade of the new millennium, building on the program comprehension theories of the 1980s and the reverse engineering technology of the 1990s.
17549193
Accurate 3-D Motion Tracking with an Application to Super-Resolution
Many of the existing image processing applications, in particular the construction of super-resolution videos, require an accurate high-speed motion tracking algorithm. This paper proposes an efficient recursive approach that recovers 3D motion from a stereo image sequence with high precision based on the trifocal tensor. In the computation process, neither the 3D structure of the scene nor its reconstruction is necessary. The validity of the proposed algorithm is demonstrated by applying it to upgrade the resolution of real stereo images. Empirical comparisons show that our novel approach outperformed traditional work in terms of both the accuracy of motion estimation and the quality of super-resolved images
11611476
Conceptual graphs as schemas for semi-structured databases
As the World Wide Web grows dramatically in recent years, there is increasing interest in semi-structured data on the web. Semi-structured data are usually represented in graph format, many graph schemas have then been proposed to extract schemas from those data graphs. Conceptual graphs, which use incremental conceptual clustering method to extract schemas, have initially been proposed in 2000. In this paper, we revise the original algorithm to generate a conceptual graph by proposing some new operators in the construction process. The results have shown that with the revised algorithm the quality of the conceptual graphs has been improved in terms of query optimization.
43638341
Temporal Representation and Classification in Chinese
Temporal information is a significant semantic carrier in natural languages. In a broader sense, when we speak of the temporal information contained in sentences, we do not simply mean those explicit specifications, such as time clauses or phrases associated with the actions addressed. It also includes the information which is implicitly embedded in verbs. Thus, modelling of the temporal aspects of a language is more complicated than a physical time-dependent system. Over the past years, temporal information processing and extraction have received increasing attentions. Nevertheless, only a few researchers have investigated these areas in Chinese. The aim of this paper is to investigate both the explicit expressions and the inherent temporal properties of Chinese sentences. Furthermore, an algorithm to automatically classify a situation described by a sentence into three temporal categories, namely event, process and state, is proposed. This algorithm is the fundamental building block for effective Chinese temporal information processing.
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.
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.