RE2: Reverse-engineering and reuse re-engineering

Initial research in reuse was in the designing and implementation of reusable software. This research, although fruitful, did not address the area of extracting reusable components from existing software. In this paper the term reuse is used to mean the ‘reuse of existing source code’. A process called ‘reuse re-engineering’ is defined and this, together with techniques from reverse-engineering, form a new method for achieving reuse. A reference paradigm is established to implement the reuse re-engineering process. This process is divided into five sequential phases, each characterized by the objects it produces. These phases are: candidature, election, qualification, classification and storage, and search and display. This paper concentrates on the first three phases because they produce reusable modules from existing systems. In selecting candidates for reuse, different abstractions have to be applied, namely functional abstraction (algorithms) and data abstractions (data structures and data types). This paper presents a formalized approach to each of these abstractions. The approach proposed in this paper aims to promote reuse in industrial software production environments.

[1]  Corrado Böhm,et al.  Flow diagrams, turing machines and languages with only two formation rules , 1966, CACM.

[2]  Edsger W. Dijkstra,et al.  Letters to the editor: go to statement considered harmful , 1968, CACM.

[3]  D. L. Parnas,et al.  On the criteria to be used in decomposing systems into modules , 1972, Software Pioneers.

[4]  Edsger W. Dijkstra,et al.  Structured programming , 1972, A.P.I.C. Studies in data processing.

[5]  J. Hopcroft,et al.  Algorithm 447: efficient algorithms for graph manipulation , 1973, CACM.

[6]  Brenda S. Baker,et al.  An Algorithm for Structuring Flowgraphs , 1977, J. ACM.

[7]  Matthew S. Hecht,et al.  Flow Analysis of Computer Programs , 1977 .

[8]  Edward Yourdon,et al.  Structured design : fundamentals of a discip!ine of computer proqram and system desiqn , 1979 .

[9]  Duncan Fyfe Gillies,et al.  Synthesis and Structural Analysis of Abstract Programs , 1980, Comput. J..

[10]  Ronald E. Prather,et al.  Decomposition of Flowchart Schemata , 1981, Computer/law journal.

[11]  G. Oulsnam,et al.  Unravelling Unstructured Programs , 1982, Comput. J..

[12]  Mark Weiser,et al.  Programmers use slices when debugging , 1982, CACM.

[13]  Edsger W. Dijkstra Finding the Maximum Strong Components in a Directed Graph , 1982 .

[14]  Henry Ledgard,et al.  Reference Manual for the ADA® Programming Language , 1983, Springer New York.

[15]  James M. Neighbors,et al.  The Draco Approach to Constructing Software from Reusable Components , 1984, IEEE Transactions on Software Engineering.

[16]  Kate Ehrlich,et al.  Empirical Studies of Programming Knowledge , 1984, IEEE Transactions on Software Engineering.

[17]  Victor R. Basili,et al.  A Methodology for Collecting Valid Software Engineering Data , 1984, IEEE Transactions on Software Engineering.

[18]  Mark Weiser,et al.  Program Slicing , 1981, IEEE Transactions on Software Engineering.

[19]  Aniello Cimitile,et al.  Well-Formed Conversion of Unstructured One-in/one-out Schemes for Complexity Measurement and Program Maintenance , 1986, Comput. J..

[20]  Harlan D. Mills,et al.  Data structured programming: Program design without arrays and pointers , 1986, IEEE Transactions on Software Engineering.

[21]  Elliot Soloway,et al.  Delocalized Plans and Program Comprehension , 1986, IEEE Software.

[22]  Robin W. Whitty,et al.  Axiomatic Approach to Software Metrication Through Program Decomposition , 1986, Comput. J..

[23]  Norman Fenton,et al.  Metrics and software structure , 1987 .

[24]  T. Biggerstaff,et al.  Reusability Framework, Assessment, and Directions , 1987, IEEE Software.

[25]  Will Tracz,et al.  Software reuse myths , 1988, SOEN.

[26]  Frank W. Calliss Inter-module code analysis techniques for software maintenance , 1989 .

[27]  C. Smythe,et al.  The retrospective introduction of abstraction into software , 1989, Proceedings. Conference on Software Maintenance - 1989.

[28]  Ted J. Biggerstaff,et al.  Design recovery for maintenance and reuse , 1989, Computer.

[29]  Victor R. Basili,et al.  Viewing maintenance as reuse-oriented software development , 1990, IEEE Software.

[30]  James H. Cross,et al.  Reverse engineering and design recovery: a taxonomy , 1990, IEEE Software.

[31]  J. A. Zimmer Restructuring for style , 1990, Softw. Pract. Exp..

[32]  Frank W. Calliss,et al.  Potpourri module detection , 1990, Proceedings. Conference on Software Maintenance 1990.

[33]  Alan R. Hevner,et al.  Using function abstraction to understand program behavior , 1990, IEEE Software.

[34]  Rubén Prieto-Díaz Implementing faceted classification for software reuse , 1991, CACM.

[35]  Aniello Cimitile,et al.  Reverse engineering: Algorithms for program graph production , 1991, Softw. Pract. Exp..

[36]  Victor R. Basili,et al.  Identifying and qualifying reusable software components , 1991, Computer.

[37]  Aniello Cimitile,et al.  A Logic-Based Approach to Reverse Engineering Tools Production , 1992, IEEE Trans. Software Eng..

[38]  Aniello Cimitile,et al.  Reverse-engineering and intermodular data flow: A theoretical approach , 1992, J. Softw. Maintenance Res. Pract..

[39]  Mats Brorsson,et al.  Human Aspects and Organizational Issues of Software Reuse , 1992 .

[40]  Ted J. Biggerstaff,et al.  An Assessment and Analysis of Software Reuse , 1992, Adv. Comput..