An Empirical Study of a Repeatable Method for Reengineering Procedural Software Systems to Object- Oriented Systems

This paper describes a repeatable method for reengineering a procedural system to an object-oriented system. The method uses coupling metrics to assist a domain expert in identifying candidate objects. An application of the method to a simple program is given, and the effectiveness of the various coupling metrics are discussed. We perform a detailed comparison of our repeatable method with an ad hoc, manual reengineering effort based on the same procedural program. The repeatable method was found to be effective for identifying objects. It produced code that was much smaller, more efficient, and passed more regression tests than the ad hoc method. Analysis of object-oriented metrics indicated both simpler code and less variability among classes for the repeatable method

A comparative evaluation of dynamic visualisation tools

Despite their potential applications in software comprehension, it appears that dynamic visualisation tools are seldom used outside the research laboratory. This paper presents an empirical evaluation of five dynamic visualisation tools - AVID, Jinsight, jRMTool, Together ControlCenter diagrams and Together ControlCenter debugger. The tools were evaluated on a number of general software comprehension and specific reverse engineering tasks using the HotDraw objectoriented framework. The tasks considered typical comprehension issues, including identification of software structure and behaviour, design pattern extraction, extensibility potential, maintenance issues, functionality location, and runtime load. The results revealed that the level of abstraction employed by a tool affects its success in different tasks, and that tools were more successful in addressing specific reverse engineering tasks than general software comprehension activities. It was found that no one tool performs well in all tasks, and some tasks were beyond the capabilities of all five tools. This paper concludes with suggestions for improving the efficacy of such tools

Identifying reusable functions in code using specification driven techniques

The work described in this thesis addresses the field of software reuse. Software reuse is widely considered as a way to increase the productivity and improve the quality and reliability of new software systems. Identifying, extracting and reengineering software. components which implement abstractions within existing systems is a promising cost-effective way to create reusable assets. Such a process is referred to as reuse reengineering. A reference paradigm has been defined within the RE(^2) project which decomposes a reuse reengineering process in five sequential phases. In particular, the first phase of the reference paradigm, called Candidature phase, is concerned with the analysis of source code for the identification of software components implementing abstractions and which are therefore candidate to be reused. Different candidature criteria exist for the identification of reuse-candidate software components. They can be classified in structural methods (based on structural properties of the software) and specification driven methods (that search for software components implementing a given specification).In this thesis a new specification driven candidature criterion for the identification and the extraction of code fragments implementing functional abstractions is presented. The method is driven by a formal specification of the function to be isolated (given in terms of a precondition and a post condition) and is based on the theoretical frameworks of program slicing and symbolic execution. Symbolic execution and theorem proving techniques are used to map the specification of the functional abstractions onto a slicing criterion. Once the slicing criterion has been identified the slice is isolated using algorithms based on dependence graphs. The method has been specialised for programs written in the C language. Both symbolic execution and program slicing are performed by exploiting the Combined C Graph (CCG), a fine-grained dependence based program representation that can be used for several software maintenance tasks

A distributed solution to software reuse

Reuse can be applied to all stages of the software lifecycle to enhance quality and to shorten time of completion for a project. During the phases of design and implementation are some examples of where reuse can be applied, but one frequent obstruction to development is the building of and the identifying of desirable components. This can be costly in the short term but an organisation can gain the profits of applying this scheme if they are seeking long-term goals. Web services are a recent development in distributed computing. This thesis combines the two research areas to produce a distributed solution to software reuse that displays the advantages of distributed computing within a reuse system. This resulted in a web application with access to web services that allowed two different formats of component to be inserted into a reuse repository. These components were searchable by keywords and the results are adjustable by the popularity of a component’s extraction from the system and by user ratings of it; this improved the accuracy of the search. This work displays the accuracy, usability, and speed of this system when tested with five undergraduate and five postgraduate students

Identifying reusable abstract data types in code

The basic aim of this thesis is to analyse the state of the art in the field of the software reuse Software reuse is widely regarded as offering the opportunity for improving the software production process. It is expected that a massive increase in software reuse is the most promising way of overcoming the software crisis. It can lead to substantial increases in productivity and also to software systems which are more robust and more reliable. A Reuse Re-engineering process together with techniques from reverse engineering represent a method to achieve software reuse. A reference paradigm is established to implement the Reuse Re-engineering process. The reference paradigm is composed of five sequential phases, each characterised by the object it produces. This thesis deals mainly with the first phase of the reference paradigm. This phase is called Candidature and it is concerned with the analysis of the source code for the identification of sets of software components that can be candidate to make up a reusable component. Various methods involved in this phase exist in the literature. Each of them has different characteristic and different qualities. One of these approaches is analysed and it is extended in the new method to give a more precise set of reusable abstract data types. In this thesis the new method is presented. A formalisation followed by implementation of it and an evaluation of its quality through quality attributes is given