This Article 
 Bibliographic References 
 Add to: 
Concept Analysis for Module Restructuring
April 2001 (vol. 27 no. 4)
pp. 351-363

Abstract—Low coupling between modules and high cohesion inside each module are the key features of good software design. This is obtained by encapsulating the details about the internal structure of data and exporting only public functions with a clean interface. The only native support to encapsulation offered by procedural programming languages, such as C, is the possibility to limit the visibility of entities at the file level. Thus, modular decomposition is achieved by assigning functions and data structures to different files. This paper proposes a new approach to using concept analysis for module restructuring, based on the computation of extended concept subpartitions. Alternative modularizations, characterized by high cohesion around the internal structures that are being manipulated, can be determined by such a method. To assess the quality of the restructured modules, the trade-off between encapsulation violations and decomposition is considered and proper measures for both factors are defined. Furthermore, the cost of restructuring is evaluated through a measure of distance between original and new modularizations. Concept subpartitions were determined for a test suite of 20 programs of variable size, 10 public domain and 10 industrial applications. On the resulting module candidates, the trade-off between encapsulation and decomposition was measured, together with an estimate of the cost of restructuring. Moreover, the ability of concept analysis to determine meaningful modularizations was assessed in two ways. First, programs without encapsulation violations were used as oracles, assuming the absence of violations as an indicator of careful decomposition. Second, the suggested restructuring interventions were actually implemented in some case studies to evaluate the feasibility of restructuring and to deeply investigate the code organization before and after the intervention. Concept analysis was experienced to be a powerful tool supporting module restructuring.

[1] G. Antoniol, R. Fiutem, G. Lutteri, P. Tonella, and S. Zanfei, “Program Understanding and Maintenance with the CANTO Environment,” Proc. Int'l Conf. Software Maintenance, pp. 72–81, Oct. 1997.
[2] G. Caldiera and V.R. Basili, "Identifying and Qualifying Reusable Software Components," Computer, pp .61-70, Feb. 1991.
[3] G. Canfora, A. Cimitile, M. Munro, and C. Taylor, “Extracting Abstract Data Type from C Programs: A Case Study,” Proc. Int'l Conf. Software Maintenance, pp. 200–209, Sept. 1993.
[4] G. Canfora, A. Cimitile, M. Tortorella, and M. Munro, "A Precise Method for Identifying Reusable Abstract Data Type in Code," Proc. Int'l Conf. Software Maintenance,Victoria, Canada, pp. 404-413, 1994.
[5] J. Esteva, “Automatic Identification of Reusable Components,” Proc. Seventh Int'l Workshop Computer-Aided Software Eng., pp. 80–87, July 1995.
[6] R. Fiutem, P. Tonella, G. Antoniol, and E. Merlo, “Points-to Analysis for Program Understanding,” J. Systems and Software, vol. 44, no. 3, pp. 213–227, Jan. 1999.
[7] P. Funk, A. Lewien, and G. Snelting, “Algorithms for Concept Lattice Decomposition and Their Application,” technical report, Computer Science Dept., Technische Univ. Braunschweig, 1995.
[8] J.-F. Girard and R. Koschke, “Finding Components in a Hierarchy of Modules: A Step Towards Architectural Understanding,” Proc. Int'l Conf. Software Maintenance, pp. 58-65, Bari, Italy, Oct. 1997.
[9] W. Griswold, M. Chen, R. Bowdidge, and J. Morgenthaler, “Tool Support for Planning the Restructuring of Data Abstractions in Large Systems,” Proc. Int'l Conf. Foundations of Software Eng., pp. 33–45, 1996.
[10] M. Krone and G. Snelting, “On The Inference of Configuration Structures from Source Code,” Proc. 16th Int'l Conf. Software Eng., pp. 49-58, May 1994.
[11] T. Kunz, “Evaluating Process Clusters to Support Automatic Program Understanding,” Proc. Fourth Workshop Program Comprehension, pp. 198-207, 1996.
[12] C. Lindig and G. Snelting, "Assessing Modular Structure of Legacy Code Based on Mathematical Concept Analysis," Proc. the 19th Int'l Conf. Software Eng., pp. 349-359,Boston, Mass.: ACM Press, 1997.
[13] P.E. Livadas and T. Johnson, “A New Approach to Finding Objects in Programs,” Software Maintenance: Research and Practice, vol. 6, pp. 249–260, 1994.
[14] S. Mancoridis and R.C. Holt, “Recovering the Structure of Software Systems Using Tube Graph Interconnection Clustering,” Proc. Int'l Conf. Software Maintenance, pp. 23–32, 1996.
[15] S. Mancoridis, B.S. Mitchell, Y. Chen, E.R. Gansner, “Using Automatic Clustering to Produce High-Level System Organizations of Source Code,” Proc. Int'l Workshop Program Comprehension, pp. 45–52, 1998.
[16] S. Mancoridis et al., "Bunch: A Clustering Tool for the Recovery and Maintenance of Software System Structures," IEEE Proc. Int'l Conf. Software Maintenance(ICSM '99), IEEE CS Press, Los Alamitos, Calif., 1999.
[17] H.A. Muller, M.A. Orgun, S.R. Tilley, and J.S. Uhl, “A Reverse Engineering Approach to Subsystem Structure Identification,” Software Maintenance: Research and Practice, vol. 5, no. 4, pp. 181–204, 1993.
[18] D. Paulson and Y. Wand, “An Automated Approach to Information Systems Decomposition,” IEEE Trans. Software Eng., vol. 18, no. 3, pp. 174–189, Mar. 1992
[19] R. Schwanke, "An Intelligent Tool for Re-Engineering Software Modularity," Proc. 13th Int'l Conf. Software Eng., 1991.
[20] M. Siff and T. Reps, “Identifying Modules via Concept Analysis,” Proc. Int'l Conf. Software Maintenance, pp. 170-179, Oct. 1997.
[21] G. Snelting, “Reengineering of Configurations Based on Mathematical Concept Analysis,” ACM Trans. Software Eng. and Methodology, vol. 5, no. 2, pp. 146-189, Apr. 1996.
[22] G. Snelting and F. Tip, “Reengineering Class Hierarchies using Concept Analysis,” Proc. Sixth SIGSOFT Symp. Foundations of Software Eng., pp. 99-110, Nov. 1998.
[23] P. Tonella, Using the O-A Diagram to Encapsulate Dynamic Memory Access Proc. Int'l Conf. Software Maintenance, pp. 326-335, Nov. 1998.
[24] A. Yeh, D.R. Harris, and H.B. Reubenstein, “Recovering Abstract Data Types and Object Instances from a Conventional Procedural Language,” Proc. Second Working Conf. Reverse Eng., pp. 227-236, 1995.

Index Terms:
Concept analysis, modularization, encapsulation, abstract data type, legacy systems, reengineering, restructuring.
Paolo Tonella, "Concept Analysis for Module Restructuring," IEEE Transactions on Software Engineering, vol. 27, no. 4, pp. 351-363, April 2001, doi:10.1109/32.917524
Usage of this product signifies your acceptance of the Terms of Use.