Abstract
Modular software design is characterized by partitioning the system into discrete scalable, reusable modules consisting of isolated, self-contained functional elements. Software architects use modularity to allow independent offerings and reuse. Moreover, modularity allows dealing with changing customer demands, as it offers software architectures that are stable and more adaptive to changes. There have been some attempts at automatic partitioning of object-oriented classes into modules (i.e., packages). However, all these attempts are based on source code, i.e., they occur late in the development process at the implementation stage. In this paper, we present a metric and a search-based mechanism to allow automatic functionality-based system partitioning during the architecture design phase using requirements conceptual sequence diagrams. The metric is validated against applicable theoretical properties and also experimentally against hypothetical and real-case studies using different search techniques. Results suggest that the metric together with the partitioning mechanism is promising and can be used in effectively partitioning system conceptual classes into packages.
This is a preview of subscription content, log in via an institution to check access.
Similar content being viewed by others
Notes
The nth Bell number is the number of partitions of a set with n members. Starting with B 0 = B 1 = 1, the first seven Bell numbers are: 1, 1, 2, 5, 15, 52, and 203. Bell numbers satisfy the recursive formula: \( B_{n + 1} = \mathop \sum \limits_{k = 0}^{n} \left( {\begin{array}{*{20}c} n \\ k \\ \end{array} } \right)B_{k} \).
References
Abdeen, H., Ducasse, S., Sahraouiy, H., & Alloui, I. (2009). Automatic package coupling and cycle minimization. Working Conference on Reverse Engineering (WCRE), pp. 103–122. USA.
Abdeen, H., Ducasse, S., Sahraouiy, H., & Alloui, I. (2011). Modularization metrics: Assessing package organization in legacy large object-oriented software. In Proceedings of the 18th working conference on reverse engineering (WCRE), pp.394–398. USA.
Ahmed, M. (2011). Towards the development of integrated reuse environments for UML artifacts. In The 6th international conference on software engineering advances (ICSEA). Spain.
Alkhalid, A., Alshayeb, M., & Mahmoud, S. (2011). Software refactoring at the package level using clustering techniques. IET Software, 5(3), 274–286.
Bauer, M., & Trifu, M. (2004). Architecture-aware adaptive clustering of OO systems. In European conference on maintenance and reengineering (CSMR 04), pp. 3–14. Karlsruhe, Germany.
Bell, D. (2004). UML basics: The sequence diagram. http://www.ibm.com/developerworks/rational/library/3101.html. Accessed 6 Jan 2012.
Bonja, C., & Kidanmariam, E. (2006). Metrics for class cohesion and similarity between methods. In Proceedings of the 44th annual ACM southeast regional conference, pp. 91–95. USA.
Briand, L., Daly, J., & Wuest, J. (1998). A unified framework for cohesion measurement in object-oriented systems. Empirical Software Engineering- An International Journal, 3(1), 65–117.
Chiricota, Y., Jourdan, F., & Melancon, G. (2003). Software components capture using graph clustering. In The 11th IEEE international workshop on program comprehension (IWPC). USA.
Clarke, J., Dolado, J., Harman, M., Jones, B., Lumkin, M., Mitchell, B., et al. (2003). Reformulating software engineering as a search problem. IEEE Proceedings-Software, 150(3), 161–175.
Doval, D., Mancoridis, S., & Mitchell, B. (1999). Automatic clustering of software systems using a genetic algorithm. In Software technology and engineering practice (STEP’99). USA.
Ebad, S. (2012). Functionality-based software packaging approach for higher architecture stability. Ph.D. Dissertation. Department of Computer Science and Engineering, King Fahd University of Petroleum and Minerals (KFUPM), Saudi Arabia.
Ebad, S., & Ahmed, M. (2011a). Software packaging approaches—A comparison framework. In The 5th European conference on software architecture (ECSA 2011). LNCS 6903, pp. 438–446. Essen, Germany.
Ebad, S., & Ahmed, M. (2011b). An evaluation framework for package-level cohesion metrics. In Proceedings of the 2nd international conference on Future Information Technology (ICFIT). Singapore.
Ebad, S., & Ahmed, M. (2012). XMI2UC: an automatic tool to extract use cases from object-oriented source code. In Proceedings of the international conference on advancements in information Technology (ICAIT 2012), Hong Kong.
Falkenauer, E. (1998). Genetic algorithms and grouping problems. New York: Wiley.
Fowler M. (2001). Reducing coupling. IEEE Software, 18(4), 102–104.
Garud, R., Kumaraswamy A., & Langlois R. (2002). Managing in the modular age: Architectures, networks, and organizations. John Wiley & Sons.
Harman, M., & Clarke, J. (2004). Metrics are fitness functions too. In Proceedings of the 10th international symposium on software metrics. USA.
Jacobson I. (1992). Object-oriented software engineering: A use case driven approach. Redwood City, CA: Addison Wesley Longman Publishing Co., Inc.
Liu, X., Swift, S., & Tucker, A. (2001). Using evolutionary algorithms to tackle large scale grouping problems. In Proceedings of the genetic and evolutionary computation conference (GECCO’01).
Lung, C.-H., Xu, X., Zaman, M., & Srinivasan, A. (2006). Program restructuring using clustering techniques. The Journal of Systems and Software, 79(9), 1261–1279.
Mancoridis, S., Mitchell, B., Chen, Y., & Gansner, R. (1999). Bunch: A clustering tool for the recovery and maintenance of software system structures. In Proceedings of the IEEE international conference on software maintenance, pp 50–59. USA.
Mancoridis, S., Mitchell, B., Rorres, C., Chen, Y., & Gansner, R. (1998). Using automatic clustering to produce high-level system organizations of source code. In Proceedings of the international workshop on program comprehension (IWPC), pp. 45–53. USA.
Mitchell, B., & Mancoridis, S. (2002). Using heuristic search techniques to extract design abstractions from source code. In Proceedings of the genetic and evolutionary computation conference (GECCO’02).
Net-centric enterprise solutions for interoperability (US Government). (2007). Glossary: modular design. http://nesipublic.spawar.navy.mil/part5/releases/1.3.0/WebHelp/glossary/m.htm. Accessed 1 Sept 2011.
Nijenhuis, A., & Wilf, H. S. (1978). Combinatorial algorithms. New York: Academic Press.
Object Management Group. (2010). OMG unified modeling language (OMG UML). Superstructure.
Raiha, O. (2010). A survey on search-based software design. Computer Science Review, 4(4), 203–249.
Russell, S., & Norvig, P. (2010). Artificial intelligence: a modern approach (3rd ed.). Upper Saddle River: Prentice Hall.
Sait, S., & Youssef, H. (1999). Iterative computer algorithms with applications in engineering: Solving combinatorial optimization problems. Los Alamitos, CA: IEEE Computer Society Press.
Seng, O. Bauer, M., Biehl, M., & Pache, G. (2005). Search-based improvement of subsystem decompositions. In Proceedings of the genetic and evolutionary computation conference (GECCO).
Walpole, R., Myers, R., Myer, S., Ye, K. (2010). Probability and statistics for engineers and scientists. Pearson Prentice Hall.
Acknowledgments
The authors wish to acknowledge King Fahd University of Petroleum and Minerals (KFUPM) for providing the facilities to carry out this research. We also wish to thank the anonymous reviewers for their comments and suggestions, which have resulted in a significantly improved manuscript
Author information
Authors and Affiliations
Corresponding author
Rights and permissions
About this article
Cite this article
Ebad, S.A., Ahmed, M.A. Functionality-based software packaging using sequence diagrams. Software Qual J 23, 453–481 (2015). https://doi.org/10.1007/s11219-014-9245-3
Published:
Issue Date:
DOI: https://doi.org/10.1007/s11219-014-9245-3