Skip to main content
SpringerLink
Log in

Extending the reflexion method for consolidating software variants into product lines

  • Published:
Software Quality Journal Aims and scope Submit manuscript

Abstract

Software variants emerge from ad-hoc copying in-the-large with adaptations to a specific context. As the number of variants increases, maintaining such software variants becomes more and more difficult and expensive. In contrast to such ad-hoc reuse, software product lines offer organized ways of reuse, taking advantage of similarities of different products. To re-gain control, software variants may be consolidated as organized software product lines. In this paper, we describe a method and supporting tools to compare software variants at the architectural level extending the reflexion method to software variants. Murphy’s reflexion method allows one to reconstruct the module view, a static architectural view describing the static components, their interfaces and dependencies and their grouping as layers and subsystems. The method consists of the specification of the module view and the mapping of implementation components onto the module view. An automatic analysis determines differences between the module view and its implementation. We extend the reflexion method from single systems to software variants. Because software variants share a very large amount of code, we can expect components of one variant to re-occur in the other variant either identically or at least similarly. We use similarity metrics to determine this type of correspondence among implementation components between two variants. Because the similarity metrics are expensive to compute, we use clone detection techniques to reduce the number of candidate pairs of implementation components for which the similarity is computed. The correspondence is then used to transfer as much as possible of the mapping for the analyzed variants to the next variant to be analyzed. Furthermore, we describe how to unify the individual product architectures into a software product line architecture.

This is a preview of subscription content, log in via an institution to check access.

Access this article

Log in via an institution

Price excludes VAT (USA)
Tax calculation will be finalised during checkout.

Instant access to the full article PDF.

Institutional subscriptions

Fig. 1
Fig. 2
Fig. 3
Fig. 4
Fig. 5
Fig. 6
Fig. 7

Similar content being viewed by others

Notes

  1. http://www.rigi.csc.uvic.ca/.

  2. http://www.axivion.com.

  3. http://www.uni-koblenz.de/FB4/Contrib/GUPRO/Site/Home.

  4. Our formalization here differs from the original one by Murphy et al. (2001b) in that we consider subtyping.

  5. We note that the numbers reported in this paper are slightly different from the conference paper; our clone detection has improved; also, we compute the Levenshtein distance on the basis of token type for keywords and token value for identifiers and literals. In the conference paper, we measured at the level of characters for all types of tokens.

  6. http://www.axivion.com.

References

  • Abreu, F., Pereira, G., & Sousa, P. (2000). A coupling-guided cluster analysis approach to reengineer the modularity of object-oriented systems. In European conference on software maintenance and reengineering. IEEE Computer Society Press.

  • Anquetil, N., & Lethbridge, T. (1998). Extracting concepts from file names: a new file clustering criterion. In International conference on software engineering (pp. 84–93). ACM Press.

  • Baker, B. S. (1995). On finding duplication and near-duplication in large software systems. In L. Wills, P. Newcomb, & E. Chikofsky (Eds.), Second working conference on reverse engineering (pp. 86–95). Los Alamitos, CA: IEEE Computer Society Press.

  • Balazinska, E., Merlo, M., Dagenais, B., Lague, M., & Kontogiannis, K. (2000). Advanced clone-analysis to support object-oriented system refactoring. In Working conference on reverse engineering (pp. 98–107). IEEE Computer Society Press.

  • Bayer, J., Flege, O., Knauber, P., Laqua, R., Muthig, D., Schmid, K., Widen, T., & DeBaud, J. M. (1999a). Pulse: Amethodology to develop software product lines. In Proceedings of the 1999 symposium on software reusability (pp 122–131). ACM Press. http://doi.acm.org/10.1145/303008.303063.

  • Bayer, J., Girard, J. F., Würthner, M., DeBaud, J. M., & Apel, M. (1999b). Transitioning legacy assets to a product line architecture. In Proceedings of the 7th European software engineering conference held jointly with the 7th ACM SIGSOFT international symposium on foundations of software engineering (pp. 446–463). Springer. http://doi.acm.org/10.1145/318773.319262.

  • Belady, L. A., & Evangelisti, C. J. (1982). System partitioning and its measure. Journal of Systems and Software, 2(1), 23–29.

    Article  Google Scholar 

  • Bergey, J., O’Brien, L., & Smith, D. (2002). Using options analysis for reengineering (OAR) for mining components for a product line. In Proceedings of second software product line conference. Lecture Notes in Computer Science (Vol. 2379, pp. 316–327). Springer.

  • Bojic, D., & Velasevic, D. (2000). A use-case driven method of architecture recovery for program understanding and reuse reengineering. In European conference on software maintenance and reengineering. IEEE Computer Society Press.

  • Canfora, G., Cimitile, A., Lucia, A. D., & Lucca, G. A. D. (1999). A case study of applying an eclectic approach to identify objects in code. In International workshop on program comprehension (pp. 136–143). IEEE Computer Society Press.

  • Canfora, G., Cimitile, A., & Munro, M. (1996). An improved algorithm for identifying objects in code. Journal of Software Practice and Experience, 26(1), 25–48.

    Article  Google Scholar 

  • Canfora, G., Cimitile, A., Munro, M., & Taylor, C. J. (1993). Extracting abstract data types from C programs: A case study. In International conference on software maintenance (pp. 200–209). IEEE Computer Society Press.

  • Choi, S., & Scacchi, W. (1990). Extracting and restructuring the design of large systems. IEEE Software, 7(1), 66–71.

    Article  Google Scholar 

  • Christl, A., Koschke, R., & Storey, M. A. (2005). Equipping the reflexion method with automated clustering. In Working conference on reverse engineering (pp. 89–98). IEEE Computer Society Press.

  • Christl, A., Koschke, R., & Storey, M. A. (2007). Automated clustering to support the reflexion method. Journal Information and Software Technology, 49, 255–274.

    Article  Google Scholar 

  • Cimitile, A., & Visaggio, G. (1995). Software salvaging and the call dominance tree. Journal of Systems and Software, 28, 117–127.

    Article  Google Scholar 

  • Clements, P., Bachmann, F., Bass, L., Garlan, D., Ivers, J., Little, R., Nord, R., & Stafford, J. (2002). Documenting software architecture. Boston: Addison-Wesley.

    Google Scholar 

  • Clements, P., Kazman, R., & Klein, M. (2001). Evaluating software architectures: Methods and case studies. SEI series in software engineering series, Addison-Wesley, Professional.

  • Clements, P., & Northrop, L. M. (2001). Software product lines: Practices and patterns. Addison-Wesley, Professional.

  • de Oca, C. M., & Carver, D. L. (1998). A visual representation model for software subsystem decomposition. In Working conference on reverse engineering. IEEE Computer Society Press.

  • Eisenbarth, T., Koschke, R., & Simon, D. (2003). Locating features in source code. IEEE Computer Society Transactions on Software Engineering, 29(3).

  • Faust. D., & Verhoef, C. (2003). Software product line migration and deployment. Journal of Software Practice and Experiences, 33(10), 933–955. doi:10.1002/spe.530.

    Google Scholar 

  • Feijs, L., Krikhaar, R., & van Ommering, R. (1998). A relational approach to support software architecture analysis. Journal of Software Practice and Experiences, 28(4), 371–400.

    Article  Google Scholar 

  • Frenzel, P., Koschke, R., Breu, A. P. J., & Angstmann, K. (2007). Extending the reflection method for consolidating software variants into product lines. In Working conference on reverse engineering (pp. 160–169). IEEE Computer Society Press.

  • Gall, H., & Klösch, R. (1995). Finding objects in procedural programs: An alternative approach. In Working conference on reverse engineering (pp. 208–217). IEEE Computer Society Press.

  • Garey, M. R., Johnson, D. S., & Stockmeyer, L. (1974). Some simplified np-complete problems. In Proceedings of the sixth annual ACM symposium on theory of computing (pp. 47–63).

  • Girard, J. F., & Koschke, R. (1997). Finding components in a hierarchy of modules: A step towards architectural understanding. In International conference on software maintenance. IEEE Computer Society Press.

  • Girard, J. F., Koschke, R., & Schied, G. (1997). A metric-based approach to detect abstract data types and state encapsulations. In International conference on automated software engineering. IEEE Computer Society Press.

  • Girard, J. F., Koschke, R., & Schied, G. (1999). A metric-based approach to detect abstract data types and state encapsulations. Journal of Automated Software Engineering, 6(4).

  • Gomaa, H. (2005). Designing software product lines with UML—from use cases to pattern-based software architectures. Addison-Wesley.

  • Graudejus, H. (1998). Implementing a concept analysis tool for identifying abstract data types in C code. Diplomarbeit, University of Kaiserslautern: Germany.

    Google Scholar 

  • Guo, G. Y., Atlee, J. M., & Kazman, R. (1999). A software architecture reconstruction method. In WICSA1: Proceedings of the TC2 first working IFIP conference on software architecture (WICSA1) (pp. 15–34). Deventer: Kluwer, B.V.

  • Hofmeister, C., Nord, R., & Soni, D. (2000). Applied software architecture. Object Technology Series. Addison Wesley.

  • Holt, R. C. (1998). Structural manipulation of software architecture using tarski relational algebra. In M. Blaha & C. Verhoef (Eds.). Working conference on reverse engineering (pp. 210–219). IEEE Computer Society Press.

  • Hutchens, D. H., Basili, V. R. (1985). System structure analysis: Clustering with data bindings. IEEE Computer Society Transactions on Software Engineering, 11(8), 749–757.

    Article  Google Scholar 

  • Kazman, R., Abowd, G., Bass, L., Clements, P. (1996). Scenario-based analysis of software architecture (pp. 47–55). IEEE Software.

  • Kolb, R., Muthig, D., Patzke, T., & Yamauchi, K. (2005). A case study in refactoring a legacy component for reuse in a product line. In International conference on software maintenance (pp. 369–378). IEEE Computer Society Press. doi:10.1002/smr.329.

  • Kolb, R., Muthig, D., Patzke, T., & Yamauchi, K. (2006). Refactoring a legacy component for reuse in a software product line: A case study. Journal of Software Maintenance and Evolution: Research and Practice, 18(2), 109–132, doi:10.1002/smr.329.

    Article  Google Scholar 

  • Koschke, R. (1999). Atomic architectural component recovery for program understanding and evolution. Ph.D. thesis, University of Stuttgart, http://www.iste.uni-stuttgart.de/ps/rainer/thesis.

  • Koschke, R. (2005). Rekonstruktion von Software-Architekturen: Blickwinkel, Sichten, Ansichten und Aussichten. Informatik—Forschung und Entwicklung. Springer 19(3).

  • Koschke, R. (2007). Survey of research on software clones. In R. Koschke, E. Merlo, & A. Walenstein (Eds.), Duplication, redundancy, and similarity in software, Internationales Begegnungsund Forschungszentrum fuer Informatik (IBFI), Schloss Dagstuhl, Germany, no. 06301 in Dagstuhl Seminar Proceedings, http://drops.dagstuhl.de/opus/volltexte/2007/962 [date of citation: 2008-06-02].

  • Koschke, R. (2008a). Frontiers in software clone management. In Frontiers in software maintenance, proceedings of the international conference on software maintenance. IEEE Computer Society Press.

  • Koschke, R. (2008b). Identifying and removing software clones. In S. Demeyer & T. Mens (Eds.), Sofware evolution (pp. 15–39). Springer.

  • Koschke, R. (2008c). Architecture reconstruction. In International summer school on software engineering. Springer.

  • Koschke, R., & Simon, D. (2003). Hierarchical reflexion models. In Working conference on reverse engineering (pp. 36–45). IEEE Computer Society Press.

  • Kruchten, P. (1995). The 4 + 1 view model of architecture. IEEE Software, 12(6), 42–50.

    Article  Google Scholar 

  • Lindig, C., & Snelting, G. (1997). Assessing modular structure of legacy code based on mathematical concept analysis. In International conference on software engineering (pp. 349–359). IEEE Computer Society Press.

  • Liu, S. S., & Wilde, N. (1990). Identifying objects in a conventional procedural language: An example of data design recovery. In International conference on software maintenance (pp. 266–271). IEEE Computer Society Press.

  • Livadas, P., & Johnson, T. (1994). A new approach to finding objects in programs. Journal of Software Maintenance and Evolution: Research and Practice, 6, 249–260.

    Article  Google Scholar 

  • Maccari, A., & Riva, C. (2001). Architectural evolution of legacy product families. In Proceedings of the fourth international workshop on product family engineering (PFE-4) (pp. 63–68).

  • Mahdavi, K., Harman, M., & Hierons, R. M. (2003). A multiple hill climbing approach to software module clustering. In International conference on software maintenance (pp. 315–324). IEEE Computer Society Press.

  • Mancoridis, S., Mitchell, B. S., Chen, Y. F., & Gansner, E. R. (1999). Bunch: A clustering tool for the recovery and maintenance of software system structures. In International conference on software maintenance (pp. 50–59).

  • Mancoridis, S., Mitchell, B., Rorres, C., Chen, Y., & Gansner, E. (1998). Using automatic clustering to produce high-level system organizations of source code. In International workshop on program comprehension. IEEE Computer Society Press.

  • Maqbool, O., & Babri, H. A. (2004). The weighted combined algorithm: A linkage algorithm for software clustering. In European conference on software maintenance and reengineering (pp. 15–24). IEEE Computer Society Press.

  • Mende, T., Beckwermert, F., Koschke, R., & Meier, G. (2008). Supporting the grow-and-prune model in software product lines evolution using clone detection. In European conference on software maintenance and eeengineering. IEEE Computer Society Press.

  • Mende, T., Koschke, R., & Beckwermert, F. (2009). An evaluation of code similarity identification for the grow-and-prune model. Journal of Software Maintenance and Evolution: Research and Practice. doi:10.1002/smr.402.

  • Mens, K. (2000). Automating architectural conformance checking by means of logic meta programming. Ph.D. thesis, Departement Informatica, Vrije Universiteit Brussel.

  • Müller, H. A., & Klashinsky, K. (1985). Rigi—a system for programming-in-the-large. In International conference on software engineering (pp. 80–86). ACM Press.

  • Müller, H. A., Tilley, S. R., Orgun, M. A., Corrie, B. D., & Madhavji, N. H. (1992). A reverse engineering environment based on spatial and visual software interconnection models. In Proceedings of the fifth ACM SIGSOFT symposium on software development environments (pp. 88–98). ACM Press.

  • Murphy, G. C., & Notkin, D. (1997). Reengineering with reflexion models: A case study. IEEE Computer, 30(8), 29–36. (Reprinted in Nikkei Computer, January 19, 1998, pp. 161–169).

    Google Scholar 

  • Murphy, G. C., Notkin, D., & Sullivan, K. J. (2001a). Software reflexion models: Bridging the gap between design and implementation. IEEE Computer Society Transactions on Software Engineering, 27(4), 364–380.

    Article  Google Scholar 

  • Murphy, G. C., Notkin, D., & Sullivan, K. J. (2001b). Software reflexion models: Bridging the gap between design and implementation. IEEE Computer Society Transactions on Software Engineering, 27(4).

  • Ogando, R. M., Yau, S. S., & Wilde, N. (1994). An object finder for program structure understanding in software maintenance. Journal of Software Maintenance and Evolution: Research and Practice, 6(5), 261–283.

    Article  Google Scholar 

  • Patel, S., Chu, W., & Baxter, R. (1992). A measure for composite module cohesion. In International conference on software engineering (pp. 38–48). ACM Press.

  • Pollet, D., Ducasse, S., Poyet, L., Alloui, I., Cîmpan, S., & Verjus, H. (2007). Towards a process-oriented software architecture reconstruction taxonomy. In European conference on software maintenance and reengineering (pp. 137–148). IEEE Computer Society Press.

  • Postma, A. (2003). A method for module architecture verification and its application on a large component based system. Information and Software Technology, 45 171–194.

    Article  Google Scholar 

  • Riva, C. (2002). Architecture reconstruction in practice. In IEEE/IFIP working conference on software architecture. IEEE Computer Society Press.

  • Riva, C. (2004). View-based software architecture reconstruction. Ph.D. dissertation, Vienna University of Technology, Vienna, Austria.

  • Roy, C., & Cordy, J. (2007). A survey on software clone detection research. Technical Report 541, Queen’s University.

  • Saeed, M., Maqbool, O., Babri, H., Hassan, S., & Sarwar, S. (2003). Software clustering techniques and the use of combined algorithm. In European conference on software maintenance and reengineering (pp. 301–310). IEEE Computer Society Press.

  • Sahraoui, H., Melo, W., Lounis, H., & Dumont, F. (1997). Applying concept formation methods to object identfication in procedural code. In International conference on automated software engineering (pp. 210–218). IEEE Computer Society Press.

  • Sartipi, K. (2001). Alborz: A query-based tool for software architecture recovery. In International workshop on program comprehension (pp. 115–117). IEEE Computer Society Press.

  • Sartipi, K., & Kontogiannis, K. (2001). A graph pattern matching approach to software architecture recovery. In International conference on software maintenance (pp. 408–417). IEEE Computer Society Press.

  • Sartipi, K., & Kontogiannis, K. (2003). On modeling software architecture recovery as graph matching. In International conference on software maintenance (pp. 224–234). IEEE Computer Society Press.

  • Sartipi, K., Kontogiannis, K., & Mavaddat, F. (2000a). Architectural design recovery using data mining techniques. In European conference on software maintenance and reengineering. IEEE Computer Society Press.

  • Sartipi, K., Kontogiannis, K., & Mavaddat, F. (2000b). A pattern matching framework for software architecture recovery and restructuring. In International workshop on program comprehension. IEEE Computer Society Press.

  • Schwanke, R. W. (1992). An intelligent tool for re-engineering software modularity. In International conference on software engineering. ACM Press.

  • Schwanke, R. W., & Hanson, S. J. (1994). Using neural networks to modularize software. Machine Learning, 15, 136–168.

    Google Scholar 

  • Shokoufandeh, A., Mancoridis, S., & Maycock, M. (2002). Applying spectral methods to software clustering. In Working conference on reverse engineering (pp. 3–12). IEEE Computer Society Press.

  • Siff, M., & Reps, T. (1997). Identifying modules via concept analysis. In International conference on software maintenance (pp. 170–179). IEEE Computer Society Press.

  • Siff, M., & Reps, T. (1999). Identifying modules via concept analysis. IEEE Computer Society Transactions on Software Engineering, 25(6), 749–768.

    Article  Google Scholar 

  • Stoermer, C., & O’Brien, L. (2001). MAP—mining architectures for product line evaluations. In IEEE/IFIP working conference on software architecture (pp. 35–44). IEEE Computer Society Press.

  • Tonella, P. (2001). Concept analysis for module restructuring. IEEE Computer Society Transactions on Software Engineering, 27(4), 351–363.

    Article  Google Scholar 

  • Tzerpos, V. (1997). The orphan adoption problem in architecture maintenance. In Working conference on reverse engineering. IEEE Computer Society Press.

  • Valasareddi, R. R., & Carver, D. L. (1998). A graph-based object identification process for procedural programs. In Working conference on reverse engineering (pp. 50–58). IEEE Computer Society Press.

  • van der Linden, F. (2002). Software product families in Europe. the Esaps and Cafe project. IEEE Software, 19(4), 41–49.

    Article  MathSciNet  Google Scholar 

  • van Deursen, A., & Kuipers, T. (1999). Identifying objects using cluster and concept analysis. In International conference on software engineering (pp. 246–255). IEEE Computer Society Press.

  • Weidl, J., & Gall, H. (1998). Binding object models to source code: An approach to object-oriented re-architecturing. In Proceedings of the of the 22nd computer software and applications conference. IEEE Computer Society Press.

  • Wiggert, T. A. (1998). Using clustering algorithms in legacy systems remodularization. In Working conference on reverse engineering (pp. 33–43). IEEE Computer Society Press.

  • Xing, Z., & Stroulia, E. (2004). Understanding phases and styles of object-oriented systems’ evolution. In International conference on software maintenance(pp. 242–251). IEEE Computer Society Press.

  • Yeh, A. S., Harris, D. R., & Reubenstein, H. B. (1995). Recovering abstract data types and object instances from a conventional procedural language. In Working conference on reverse engineering (pp. 227–236). IEEE Computer Society Press.

  • Zou, L., & Godfrey, M. (2003). Detecting merging and splitting using origin analysis. In Working conference on reverse engineering (pp 146–154). IEEE Computer Society Press.

Download references

Author information

Authors and Affiliations

  1. University of Bremen, Bremen, Germany

    Rainer Koschke & Pierre Frenzel

  2. Robert Bosch GmbH, Stuttgart, Germany

    Andreas P. J. Breu & Karsten Angstmann

Authors
  1. Rainer Koschke
    View author publications

    You can also search for this author in PubMed Google Scholar

  2. Pierre Frenzel
    View author publications

    You can also search for this author in PubMed Google Scholar

  3. Andreas P. J. Breu
    View author publications

    You can also search for this author in PubMed Google Scholar

  4. Karsten Angstmann
    View author publications

    You can also search for this author in PubMed Google Scholar

Corresponding author

Correspondence to Rainer Koschke.

Appendix

Appendix

See Figs. 8, 9 and 10.

Fig. 8
figure 8

Whole system comparison

Full size image
Fig. 9
figure 9

Kernel-functions only comparison

Full size image
Fig. 10
figure 10

Feature-functions only comparison

Full size image

Rights and permissions

Reprints and permissions

About this article

Cite this article

Koschke, R., Frenzel, P., Breu, A.P.J. et al. Extending the reflexion method for consolidating software variants into product lines. Software Qual J 17, 331–366 (2009). https://doi.org/10.1007/s11219-009-9077-8

Download citation

  • Published:

  • Issue Date:

  • DOI: https://doi.org/10.1007/s11219-009-9077-8

Keywords

Search

Navigation