James H. Cross

Reverse engineering and design recovery: a taxonomy

The key to applying computer-aided software engineering to the maintenance and enhancement of existing systems lies in applying reverse-engineering approaches. However, there is considerable confusion over the terminology used in both technical and marketplace discussions. The authors define and relate six terms: forward engineering, reverse engineering, redocumentation, design recovery, restructuring, and reengineering. The objective is not to create new terms but to rationalize the terms already in use. The resulting definitions apply to the underlying engineering processes, regardless of the degree of automation applied.<<ETX>>

Computing Curricula 2005: The Overview Report

In 2001, the ACM and the IEEE-CS published Computing Curricula 2001 which contains curriculum recommendations for undergraduate programs in computer science. That report also called for additional discipline-specific volumes for each of computer engineering, information systems, and software engineering. In addition, it called for an Overview Volume to provide a synthesis of the various volumes. The Computing Curricula 2004 Task Force undertook the job of fulfilling the latter charge. The purpose of this session is to present the recently completed work of that Task Force, now known as Computing Curricula 2005 (CC2005), and to generate discussion among, and feedback from SIGCSE members about ongoing and future work.

Software process in the classroom: the Capstone project experience

A process-oriented perspective on large student projects guides students in integrating end-to-end life-cycle skills and provides consistency of experience among projects. After conducting 49 Capstone projects, the authors learned that they must cultivate a process culture, that agile processes provide a bridge from ad hoc programming assignments to organized project work, and that process requires a suitable infrastructure of tools and process expertise.

An extensible framework for providing dynamic data structure visualizations in a lightweight IDE

A framework for producing dynamic data structure visualizations within the context of a lightweight IDE is described. Multiple synchronized visualizations of a data structure can be created with minimal coding through the use of an external viewer model. The framework supplies a customizable viewer template as well as high-level APIs to a graph drawing library and the Java Debugger Interface. Initial classroom use has demonstrated the frameworks ease of use as well as its potential to as an aid to student learning.

A rule-based software test data generator

Rule-based software test data generation is proposed as an alternative to either path/predicate analysis or random data generation. A prototype rule-based test data generator for Ada programs is constructed and compared to a random test data generator. Four Ada procedures are used in the comparison. Approximately 2000 rule-based test cases and 100000 randomly generated test cases are automatically generated and executed. The success of the two methods is compared using standard coverage metrics. Simple statistical tests showing that even the primitive rule-based test data generation prototype is significantly better than random data generation are performed. This result demonstrates that rule-based test data generation is feasible and shows great promise in assisting test engineers, especially when the rule base is developed further. >

Experimental evaluation of animated-verifying object viewers for Java

Although many visualization techniques have been shown to be pedagogically effective, they are still not widely adopted. The reasons include: lack of suitable methods of automatic-generation of visualizations, lack of integration among visualizations, and lack of integration with basic integrated development environment (IDE) support. To effectively use visualizations when developing code, it is useful to automatically generate multiple synchronized views without leaving the IDE. The jGRASP IDE provides object viewers that automatically generate dynamic, state-based visualizations of objects and primitive variables in Java. Such seamless integration of a lightweight IDE with a set of pedagogically effective software visualizations is unique and is currently unavailable in any other environment. Multiple instructors have reported positive anecdotal evidence of their usefulness. We conducted formal, repeatable experiments to investigate the effect of these viewers for singly linked lists on student performance and we found a statistically significant improvement over traditional methods of visual debugging that use break-points.

A self-improving helpdesk service system using case-based reasoning techniques

Abstract Case-Based Reasoning (CBR) is the process of solving a given problem based on the knowledge gained from solving precedents. It is an effective technique in the area of customer services or helpdesks. That is, a CBR system is used to solve most of the commonly occurring customer problems. While the implementation techniques may vary, most CBR systems include the following five steps: case representation and storage, precedent matching and retrieval, adaptation of the retrieved solution, validation of the solution, and finally, casebase update to include the information gained from the new problem. This paper details the various implementation techniques for these five steps, while focusing on a particular helpdesk system, namely SmartUSA, developed for the Union Camp Corporation. This system solves a customers problem by filtering the problem description through an alias table to generate a brief description and then matching the brief description with the cases in the database. It has proved to be an effective and user-friendly system that has successfully handled different descriptions of the same problem and allowed for the casebase to be built in free-format (plain) text. This system has significantly reduced the workload and the response time in the customer services department of the Union Camp Corporation.

The Control Structure Diagram: An Overview and InitialEvaluation

A new graphical representation, the Control Structure Diagram (CSD), has been created to visualize software at both the source code and program design language (PDL) level. The primary impetus for creation of the CSD was to improve the comprehension efficiency of software and, as a result, improve reliability and reduce costs. The CSD has the potential to replace traditional prettyprinted source code. As part of the GRASP (Graphical Representations of Algorithms, Structures, and Processes) research project at Auburn University, the GRASP software engineering tool has been successfully developed. GRASP automatically generates CSDs from source code written in Ada, C, C++, Java, and VHDL. The emphasis to this point has been on the automatic generation of the CSD to support development, maintenance, reverse engineering and reengineering through the use of GRASP. GRASP has been applied successfully to numerous programs ranging in size from several hundred to several thousand lines of source code and is efficient and sufficiently flexible for use in a production setting. To demonstrate the potential benefits of the CSD and its automatic generation using GRASP, a series of empirical studies has been planned and initiated. First, as reported in this article, the perceived usefulness of the CSD was evaluated using a preference instrument based on eleven performance characteristics in which a comparison was made with other well-known graphical representations for algorithms. Statistical analysis indicated numerous significant differences with a clear preference for the CSD in seven of the eleven performance characteristics. Further empirical studies, currently being implemented, will examine the effect of the CSD and GRASP on objective measures such as comprehension efficiency and effectiveness.

Extraction and use of class dependency information for Java

In this paper, a method for extracting class dependency information from Java class files is described. Advantages and disadvantages of using this method are discussed The problems of virtual dependence and synthetic methods are explained, and solutions offered. A convenient user interface is presented for making use of the dependency information in the form of an interactive UML class diagram, which is automatically generated from Java class files. This interface is a component of the jGRASP integrated development environment.

Language independent generation of graphical representations of source code

There are many potential benefiti to be gained from the effective we of graphical representatiom of source code. To be of practical we, however, ruch graphical representations mwt be automatically generated and supported in aoftware. There are e&tiny tools that provide this functionality, but many are source language specific. That is, they can only be wed with source code written in, say, Ada. A source language independent tool that automatically generates control structure diagrams from source code is the authors’ first step towarda a suite of language independent code visualization and software engineering tools. The graphical representation generator worb in two phases: the markup phase and the rendering phase. During the markup phase, a parser for a given source language is used to embed generic markup tags in the source tezt. In the rendering phase, the embedded tags provide all the needed information for producing the control structure diagram.