1581000
Extracting and representing cross-language dependencies in diverse software systems
This paper presents an approach for dealing with multi-language software systems. Much of the focus of reverse engineering tools is in analyzing software systems written in one programming language. Nowadays, the abundance of new technologies and languages used to ease application development raises new challenges for reverse engineers. Therefore, this paper focuses on finding cross-language dependencies in such diverse, heterogeneous software systems. Our approach uses source navigator extractors to produce the facts inside each language. Then, we show an example for finding Java Native Interface (JNI) dependencies between facts from Java and C/C++ code. The integrated facts are produced in GXL form, and conform to a unified schema introduced in the paper. This approach is useful from several perspectives. It illustrates how to retrieve the dependencies from software systems written in more than one programming language. Also, the generated facts conform to the GXL format, which is accepted by many reverse engineering tools. The usefulness and scalability of the approach are tested in a case study.
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.
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.
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.
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
14659694
Hybrid term indexing for different IR models
Retrieval effectiveness depends on how terms are extracted and indexed. For Chinese text (and others like Japanese and Korean), there are no space to delimit words. Indexing using hybrid terms (i.e. words and bigrams) were able to achieve the best precision amongst homogenous terms at a lower storage cost than indexing with bigrams. However, this was tested with conjunctive queries. Here, we extended the weighted Boolean models using fuzzy and p-norm measures, as well as the vector space model using the cosine measure, for processing hybrid terms. Our evaluation shows that all IR models using hybrid terms achieve better average precision over those using words. Across different recall values, the weighted Boolean model using fuzzy measures with hybrid terms achieve consistently about 8% higher than those using words. The vector space model using the cosine measures with hybrid terms achieved the best improvement in the average recall and precision.
33950497
An Effective Method for Chinese Grammar Rule Learning
A new method of Chinese grammar rules learning is put forward in this paper. The key point of this method is to use part-of-speech (POS), semantic and contextual information together in learning and expressing Chinese grammar rules. In this way, not only Context Free Grammar (CFG) rules can be learnt, but also the ambiguous structures in POS can be identified automatically. Furthermore, non-ambiguous semantic rules and forbidden rules can be produced from ambiguous rules by using semantic and contextual information. Experimental results demonstrate that the complexity of Chinese parsing is greatly reduced using the different rules learnt by our method.
7201872
Investigating Reverse Engineering Technologies for the CAS Program Understanding Project
Corporations face mounting maintenance and re-engineering costs for large legacy systems. Evolving over several years, these systems embody substantial corporate knowledge, including requirements, design decisions, and business rules. Such knowledge is difficult to recover after many years of operation, evolution, and personnel change. To address the problem of program understanding, software engineers are spending an ever-growing amount of effort on reverse engineering technologies. This paper describes the scope and results of an ongoing research project on program understanding undertaken by the IBM Toronto Software Solutions Laboratory Centre for Advanced Studies (CAS). The project involves a team from CAS and five research groups working cooperatively on complementary reverse engineering approaches. All the groups are using the source code of SQL/DS™ (a multimillion-line relational database system) as the reference legacy system. Also discussed is an approach adopted to integrate the various tools under a single reverse engineering environment.
1805653
Domain-retargetable reverse engineering
A user programmable approach to reverse engineering is described. The approach uses a scripting language that enables users to write their own routines for these activities, making the system domain-retargetable. The environment supported by this programmable approach subsumes existing reverse engineering systems by being able to simulate facets of each one and provides a smooth transition from semi-automatic to automatic reverse engineering.<<ETX>>
2219807
Computing Pose Sequences Directly from Videos
An innovative extended Kalman filter (EKF) algorithm for pose tracking has been proposed in this paper. It has the advantages of both structure and motion-based (SAM-based) and traditional model-based pose estimation algorithms. With no prior information about the scene, the pose sequence can be computed directly from images while the updating of the 3-D structure is not necessary. To achieve the goal, a constant velocity motion model is used as the dynamic system and the trifocal tensor point transfer function is applied to the measurement model of the filter. The resulting algorithm is stable, accurate and efficient. An empirical comparison with existing EKFs which deal with the same problem has been made and shows that our approach outperformed the others. The proposed method has been tested with various video sequences to demonstrate its performance in real situations.