It has been observed by many practitioners that software applications frequently contain redundant code fragments. This redundancy is often caused by the common programming practice of replicating (or cloning) existing code and then customizing code fragments to handle new demands within an application. An IT organization consequently spends significant amounts of its budget maintaining such code (e.g., a bug in one code fragment is also a bug in all of its replicated clones). To address the challenges of clone detection and maintenance, this demo will introduce a new open source tool that can be used to visualize the results of CloneDR™, which is a commercial clone detection tool (a free version of the tool is available for Java). Several open source projects will be used as case studies to demonstrate the usage of the visualization tool

While a number of research systems have demonstrated the potential value of program transformations, very few of these systems have made it into practice. The core technology for such systems is well understood; what remains is integration and more importantly, the problem of handling the scale of the applications to be processed. This paper describes DMS, a practical, commercial program analysis and transformation system, and sketches a variety of tasks to which it has been applied, from redocumenting to large-scale system migration. Its success derives partly from a vision of design maintenance and the construction of infrastructure that appears necessary to support that vision. DMS handles program scale by careful space management, computational scale via parallelism and knowledge acquisition scale via domains.

This paper shows a commercial program transformation system, DMS , applied to reengineer code in components of a distributed system implemented in C++. To be practical, such a tool has to not only reliably parse and regenerate C++ code, but it must be able to move program fragments from one place to another, accurately adjusting access paths to data. The demo shows the problem, sketches the solution, shows some of the source-to-source program transformation rules involved, and runs the tool against an illustrative example and real component code.

Automated program transformation holds promise for a variety of software life cycle endeavors, particularly where the size of legacy systems makes code analysis, re-engineering, and evolution very difficult and expensive. But constructing transformation tools that handle the full generality of modern languages and that scale to very large applications is itself a painstaking and expensive process. This cost can be managed by developing a common transformation system infrastructure that is re-used by an array of derived tools that each address specific tasks, thus leveraging the infrastructure cost over the various tools.This talk describes DMS, a practical, commercial program analysis and transformation system, and discusses how its infrastructure was employed to construct the Boeing Migration Tool (BMT), a custom component modernization application being applied to a large C++ industrial avionics system. The BMT automatically transforms components developed under a 1990's era component style to a more modern CORBA-like component framework, preserving functionality. We describe the DMS infrastructure and the BMT application itself, illustrating some of the kinds of syntheses and transformations required and some of the issues involved with transforming industrial C++ code. We also discuss the development experience, including the strategies for approaching the scale of the migration, the style of interaction that evolved between the tool-building company and its industrial customer, and how the project adapted to changing requirements.

Architectures are intended to be structuring principles for applications. However, with legacy systems they are often based on assumptions which have long since changed, and are now an obstacle. We believe that the fluidity of architecture is a function of the tools available for massively modifying systems. In this paper, we briefly sketch a tool, DMS, for making massive changes, and focus on how its fundamental mechanism, program transformation, is being applied to reengineer the architecture of a very large-scale, distributed avionics software system coded in C++.

No abstract available.

Existing research suggests that a considerable fraction (5-10%) of the source code of large scale computer programs is duplicate code ("clones"). Detection and removal of such clones promises decreased software maintenance costs of possibly the same magnitude. Previous work was limited to detection of either near misses differing only in single lexems, or near misses only between complete functions. The paper presents simple and practical methods for detecting exact and near miss clones over arbitrary program fragments in program source code by using abstract syntax trees. Previous work also did not suggest practical means for removing detected clones. Since our methods operate in terms of the program structure, clones could be removed by mechanical methods producing in-lined procedures or standard preprocessor macros. A tool using these techniques is applied to a C production software system of some 400 K source lines, and the results confirm detected levels of duplication found by previous work. The tool produces macro bodies needed for clone removal, and macro invocations to replace the clones. The tool uses a variation of the well known compiler method for detecting common sub expressions. This method determines exact tree matches; a number of adjustments are needed to detect equivalent statement sequences, commutative operands, and nearly exact matches. We additionally suggest that clone detection could also be useful in producing more structured code, and in reverse engineering to discover domain concepts and their implementations.

Conventional software engineering tends to focus on a small part of the software life cycle: the design and implementation of a product. The bulk of the lifetime cost is in the maintenance phase, where one must live with the product previously developed. Presently, we have little theory and fewer tools to help us manage the maintenance activity. We contend that a fundamental cause of the difficulty is the failure to preserve design information. This results from an over preoccupation with the synthesis and maintenance of code. We offer an alternative paradigm: make the design the central focus of the construction process-get code as a byproduct; make the design the central focus of the maintenance process-preserve revised designs and get code as a byproduct. A transformational scheme for accomplishing this is presented. We call it the Design Maintenance System. The programming roles change radically from coding instances for ill defined specifications to specifiers of functionality and (compiler like) implementation methods. Specification and implementation method debugging would then become prominent activities. The design scheme and change management procedures are illustrated with a simple data processing application. We sketch an ongoing implementation