research-article

Feature trace recording

Authors:

Paul Maximilian Bittner,

Alexander Schultheiß,

Jeffrey M. Young,

Lukas LinsbauerAuthors Info & Claims

ESEC/FSE 2021: Proceedings of the 29th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering

Pages 1007 - 1020

https://doi.org/10.1145/3468264.3468531

Published: 18 August 2021 Publication History

Abstract

Tracing requirements to their implementation is crucial to all stakeholders of a software development process. When managing software variability, requirements are typically expressed in terms of features, a feature being a user-visible characteristic of the software. While feature traces are fully documented in software product lines, ad-hoc branching and forking, known as clone-and-own, is still the dominant way for developing multi-variant software systems in practice. Retroactive migration to product lines suffers from uncertainties and high effort because knowledge of feature traces must be recovered but is scattered across teams or even lost. We propose a semi-automated methodology for recording feature traces proactively, during software development when the necessary knowledge is present. To support the ongoing development of previously unmanaged clone-and-own projects, we explicitly deal with the absence of domain knowledge for both existing and new source code. We evaluate feature trace recording by replaying code edit patterns from the history of two real-world product lines. Our results show that feature trace recording reduces the manual effort to specify traces. Recorded feature traces could improve automation in change-propagation among cloned system variants and could reduce effort if developers decide to migrate to a product line.

References

[1]

Hadil Abukwaik, Andreas Burger, Berima Kweku Andam, and Thorsten Berger. 2018. Semi-Automated Feature Traceability with Embedded Annotations. In Proc. Int’l Conf. on Software Maintenance and Evolution (ICSME). IEEE, 529–533. https://doi.org/10.1109/ICSME.2018.00049

[2]

Alfred V. Aho, Monica S. Lam, Ravi Sethi, and Jeffrey D. Ullman. 2006. Compilers: Principles, Techniques, and Tools (2nd Edition). Addison-Wesley.

Digital Library

[3]

Ra’Fat Al-Msie’deen, Abdelhak Seriai, Marianne Huchard, Christelle Urtado, Sylvain Vauttier, and Hamzeh Eyal Salman. 2013. Feature Location in a Collection of Software Product Variants Using Formal Concept Analysis. In Proc. Int’l Conf. on Software Reuse (ICSR), John M. Favaro and Maurizio Morisio (Eds.). 7925, Springer, 302–307. https://doi.org/10.1007/978-3-642-38977-1_22

[4]

Nasir Ali, Yann-Gael Gueheneuc, and Giuliano Antoniol. 2013. Trustrace: Mining Software Repositories to Improve the Accuracy of Requirement Traceability Links. IEEE Trans. on Software Engineering (TSE), 39, 5 (2013), 725–741. https://doi.org/10.1109/TSE.2012.71

Digital Library

[5]

Sofia Ananieva, Sandra Greiner, Thomas Kühn, Jacob Krüger, Lukas Linsbauer, Sten Grüner, Timo Kehrer, Heiko Klare, Anne Koziolek, Henrik Lönn, Sebastian Krieter, Christoph Seidl, S. Ramesh, Ralf Reussner, and Bernhard Westfechtel. 2020. A Conceptual Model for Unifying Variability in Space and Time. In Proc. Int’l Systems and Software Product Line Conf. (SPLC). ACM, Article 15, 12 pages. https://doi.org/10.1145/3382025.3414955

Digital Library

[6]

Berima Andam, Andreas Burger, Thorsten Berger, and Michel R. V. Chaudron. 2017. FLOrIDA: Feature LOcatIon DAshboard for Extracting and Visualizing Feature Traces. In Proc. Int’l Workshop on Variability Modelling of Software-Intensive Systems (VaMoS). ACM, 100–107. https://doi.org/10.1145/3023956.3023967

Digital Library

[7]

Michał Antkiewicz, Wenbin Ji, Thorsten Berger, Krzysztof Czarnecki, Thomas Schmorleiz, Ralf Lämmel, Stefan Stănciulescu, Andrzej Wąsowski, and Ina Schaefer. 2014. Flexible Product Line Engineering with a Virtual Platform. In Proc. Int’l Conf. on Software Engineering (ICSE). ACM, 532–535. https://doi.org/10.1145/2591062.2591126

Digital Library

[8]

Sven Apel, Don Batory, Christian Kästner, and Gunter Saake. 2013. Feature-Oriented Software Product Lines. Springer. https://doi.org/10.1007/978-3-642-37521-7

[9]

Muhammad Asaduzzaman, Chanchal K. Roy, Kevin A. Schneider, and Massimiliano Di Penta. 2013. LHDiff: A Language-Independent Hybrid Approach for Tracking Source Code Lines. In Proc. Int’l Conf. on Software Maintenance (ICSM). IEEE, 230–239. https://doi.org/10.1109/ICSM.2013.34

Digital Library

[10]

Don Batory. 2005. Feature Models, Grammars, and Propositional Formulas. In Proc. Int’l Systems and Software Product Line Conf. (SPLC). Springer, 7–20. https://doi.org/10.1007/11554844_3

Digital Library

[11]

Thorsten Berger, Marsha Chechik, Timo Kehrer, and Manuel Wimmer. 2019. Software Evolution in Time and Space: Unifying Version and Variability Management (Dagstuhl Seminar 19191). Dagstuhl Reports, 9, 5 (2019), 1–30. https://doi.org/10.4230/DagRep.9.5.1

[12]

Thorsten Berger, Daniela Lettner, Julia Rubin, Paul Grünbacher, Adeline Silva, Martin Becker, Marsha Chechik, and Krzysztof Czarnecki. 2015. What is a Feature? A Qualitative Study of Features in Industrial Software Product Lines. In Proc. Int’l Systems and Software Product Line Conf. (SPLC). ACM, 16–25. https://doi.org/10.1145/2791060.2791108

Digital Library

[13]

Ted J. Biggerstaff, Bharat G. Mitbander, and Dallas Webster. 1993. The Concept Assignment Problem in Program Understanding. In Proc. Int’l Conf. on Software Engineering (ICSE). IEEE, 482–498. https://doi.org/10.1109/ICSE.1993.346017

[14]

Philip Bille. 2005. A Survey on Tree Edit Distance and Related Problems. Theoretical Computer Science, 337, 1–3 (2005), 217–239. https://doi.org/10.1016/j.tcs.2004.12.030

Digital Library

[15]

Paul Maximilian Bittner. 2020. Semi-Automated Inference of Feature Traceability During Software Development. Master’s thesis. TU Braunschweig. https://doi.org/10.24355/dbbs.084-202002271120-0

[16]

Goetz Botterweck and Andreas Pleuss. 2014. Evolution of Software Product Lines. In Evolving Software Systems. Springer, 265–295. https://doi.org/10.1007/978-3-642-45398-4_9

[17]

Sudarshan S. Chawathe, Anand Rajaraman, Hector Garcia-Molina, and Jennifer Widom. 1996. Change Detection in Hierarchically Structured Information. In Proc. Int’l Conf. on Management of Data (SIGMOD). ACM, 493–504. https://doi.org/10.1145/233269.233366

Digital Library

[18]

Reidar Conradi and Bernhard Westfechtel. 1998. Version Models for Software Configuration Management. ACM Computing Surveys (CSUR), 30, 2 (1998), 232–282. https://doi.org/10.1145/280277.280280

Digital Library

[19]

Krzysztof Czarnecki and Ulrich Eisenecker. 2000. Generative Programming: Methods, Tools, and Applications. ACM/Addison-Wesley.

Digital Library

[20]

Michiel de Wit, Andy Zaidman, and Arie van Deursen. 2009. Managing Code Clones Using Dynamic Change Tracking and Resolution. In Proc. Int’l Conf. on Software Maintenance (ICSM). 169–178. issn:1063-6773 https://doi.org/10.1109/ICSM.2009.5306336

[21]

Nicolas Dintzner, Arie van Deursen, and Martin Pinzger. 2018. FEVER: An Approach to Analyze Feature-Oriented Changes and Artefact Co-Evolution in Highly Configurable Systems. Empirical Software Engineering (EMSE), 23, 2 (2018), 905–952. https://doi.org/10.1007/s10664-017-9557-6

Digital Library

[22]

Bogdan Dit, Meghan Revelle, Malcom Gethers, and Denys Poshyvanyk. 2013. Feature Location in Source Code: A Taxonomy and Survey. J. Software: Evolution and Process, 25, 1 (2013), 53–95. https://doi.org/10.1002/smr.567

[23]

Ekwa Duala-Ekoko and Martin P. Robillard. 2010. Clone Region Descriptors: Representing and Tracking Duplication in Source Code. Trans. on Software Engineering and Methodology (TOSEM), 20, 1 (2010), 31 pages. https://doi.org/10.1145/1767751.1767754

Digital Library

[24]

Yael Dubinsky, Julia Rubin, Thorsten Berger, Slawomir Duszynski, Martin Becker, and Krzysztof Czarnecki. 2013. An Exploratory Study of Cloning in Industrial Software Product Lines. In Proc. Europ. Conf. on Software Maintenance and Reengineering (CSMR). IEEE, 25–34. https://doi.org/10.1109/CSMR.2013.13

Digital Library

[25]

Andrew David Eisenberg and Kris De Volder. 2005. Dynamic Feature Traces: Finding Features in Unfamiliar Code. In Proc. Int’l Conf. on Software Maintenance (ICSM). IEEE, 337–346. https://doi.org/10.1109/ICSM.2005.42

Digital Library

[26]

Sina Entekhabi, Anton Solback, Jan-Philipp Steghöfer, and Thorsten Berger. 2019. Visualization of Feature Locations with the Tool FeatureDashboard. In Proc. Int’l Systems and Software Product Line Conf. (SPLC). ACM, 1–4. https://doi.org/10.1145/3307630.3342392

Digital Library

[27]

Jean-Rémy Falleri, Floréal Morandat, Xavier Blanc, Matias Martinez, and Martin Monperrus. 2014. Fine-Grained and Accurate Source Code Differencing. In Proc. Int’l Conf. on Automated Software Engineering (ASE). 313–324. https://doi.org/10.1145/2642937.2642982

Digital Library

[28]

Wolfram Fenske, Jens Meinicke, Sandro Schulze, Steffen Schulze, and Gunter Saake. 2017. Variant-Preserving Refactorings for Migrating Cloned Products to a Product Line. In Proc. Int’l Conf. on Software Analysis, Evolution and Reengineering (SANER). IEEE, 316–326. https://doi.org/10.1109/SANER.2017.7884632

[29]

Stefan Fischer, Lukas Linsbauer, Roberto E. Lopez-Herrejon, and Alexander Egyed. 2015. The ECCO Tool: Extraction and Composition for Clone-and-Own. In Proc. Int’l Conf. on Software Engineering (ICSE). IEEE, 665–668. https://doi.org/10.1109/ICSE.2015.218

[30]

Beat Fluri, Michael Wuersch, Martin Pinzger, and Harald Gall. 2007. Change Distilling: Tree Differencing for Fine-Grained Source Code Change Extraction. IEEE Trans. on Software Engineering (TSE), 33, 11 (2007), 725–743. issn:2326-3881 https://doi.org/10.1109/TSE.2007.70731

Digital Library

[31]

Masatomo Hashimoto and Akira Mori. 2008. Diff/TS: A Tool for Fine-Grained Structural Change Analysis. In Proc. Working Conf. on Reverse Engineering (WCRE). 279–288. https://doi.org/10.1109/WCRE.2008.44

Digital Library

[32]

Florian Heidenreich, Jan Kopcsek, and Christian Wende. 2008. FeatureMapper: Mapping Features to Models. In Companion Int’l Conf. on Software Engineering (ICSEC). ACM, 943–944. https://doi.org/10.1145/1370175.1370199 Informal demonstration paper.

Digital Library

[33]

Patrick Heymans, Quentin Boucher, Andreas Classen, Arnaud Bourdoux, and Laurent Demonceau. 2012. A Code Tagging Approach to Software Product Line Development. Int’l J. Software Tools for Technology Transfer (STTT), 14 (2012), 553–566. https://doi.org/10.1007/s10009-012-0242-1

Digital Library

[34]

James W. Hunt and Thomas Gregory Szymanski. 1977. A Fast Algorithm for Computing Longest Common Subsequences. Comm. ACM, 20, 5 (1977), 350–353. https://doi.org/10.1145/359581.359603

Digital Library

[35]

Wenbin Ji, Thorsten Berger, Michal Antkiewicz, and Krzysztof Czarnecki. 2015. Maintaining Feature Traceability with Embedded Annotations. In Proc. Int’l Systems and Software Product Line Conf. (SPLC). ACM, 61–70. https://doi.org/10.1145/2791060.2791107

Digital Library

[36]

Huzefa Kagdi, Malcom Gethers, and Denys Poshyvanyk. 2013. Integrating Conceptual and Logical Couplings for Change Impact Analysis in Software. Empirical Software Engineering (EMSE), 18, 5 (2013), 933–969. https://doi.org/10.1007/s10664-012-9233-9

[37]

Christian Kästner. 2010. Virtual Separation of Concerns: Toward Preprocessors 2.0. Ph.D. Dissertation. University of Magdeburg.

[38]

Christian Kästner, Sven Apel, and Martin Kuhlemann. 2008. Granularity in Software Product Lines. In Proc. Int’l Conf. on Software Engineering (ICSE). ACM, 311–320. https://doi.org/10.1145/1368088.1368131

Digital Library

[39]

Christian Kästner, Sven Apel, Salvador Trujillo, Martin Kuhlemann, and Don Batory. 2009. Guaranteeing Syntactic Correctness for All Product Line Variants: A Language-Independent Approach. In Proc. Int’l Conf. Objects, Models, Components, Patterns (TOOLS EUROPE), Manuel Oriol and Bertrand Meyer (Eds.). Springer, 175–194. https://doi.org/10.1007/978-3-642-02571-6_11

[40]

Christian Kästner, Alexander Dreiling, and Klaus Ostermann. 2014. Variability Mining: Consistent Semiautomatic Detection of Product-Line Features. IEEE Trans. on Software Engineering (TSE), 40, 1 (2014), 67–82. https://doi.org/10.1109/TSE.2013.45

Digital Library

[41]

Timo Kehrer. 2015. Calculation and Propagation of Model Changes Based on User-Level Edit Operations: A Foundation for Version and Variant Management in Model-Driven Engineering. Ph.D. Dissertation. University of Siegen.

[42]

Timo Kehrer, Udo Kelter, and Gabriele Taentzer. 2011. A Rule-Based Approach to the Semantic Lifting of Model Differences in the Context of Model Versioning. In Proc. Int’l Conf. on Automated Software Engineering (ASE). ACM, 163.–172. https://doi.org/10.1109/ASE.2011.6100050

Digital Library

[43]

Timo Kehrer, Udo Kelter, and Gabriele Taentzer. 2013. Consistency-Preserving Edit Scripts in Model Versioning. In Proc. Int’l Conf. on Automated Software Engineering (ASE). ACM, 191–201. https://doi.org/10.1109/ASE.2013.6693079

Digital Library

[44]

Timo Kehrer, Thomas Thüm, Alexander Schultheiß, and Paul Maximilian Bittner. 2021. Bridging the Gap Between Clone-and-Own and Software Product Lines. In Proc. Int’l Conf. on Software Engineering (ICSE). IEEE, 21–25. https://doi.org/10.1109/ICSE-NIER52604.2021.00013

Digital Library

[45]

Benjamin Klatt, Martin Küster, and Klaus Krogmann. 2013. A Graph-Based Analysis Concept to Derive a Variation Point Design from Product Copies. In Proc. Int’l Workshop on Reverse Variability Engineering (REVE). 1–8.

[46]

Rainer Koschke. 2007. Survey of Research on Software Clones. In Duplication, Redundancy, and Similarity in Software, Rainer Koschke, Ettore Merlo, and Andrew Walenstein (Eds.) (Dagstuhl Seminar Proceedings, 06301). IBFI. issn:1862–4405 http://drops.dagstuhl.de/opus/volltexte/2007/962

[47]

Rainer Koschke, Pierre Frenzel, Andreas P. Breu, and Karsten Angstmann. 2009. Extending the Reflexion Method for Consolidating Software Variants into Product Lines. Software Quality Journal (SQJ), 17, 4 (2009), 331–366. https://doi.org/10.1007/s11219-009-9077-8

Digital Library

[48]

Jacob Krüger, Thorsten Berger, and Thomas Leich. 2019. Features and How to Find Them: A Survey of Manual Feature Location. In Software Engineering for Variability Intensive Systems - Foundations and Applications. Auerbach Publications / Taylor & Francis, 153–172. https://doi.org/10.1201/9780429022067-7

[49]

Bruno Lague, Daniel Proulx, Jean Mayrand, Ettore M. Merlo, and John Hudepohl. 1997. Assessing the Benefits of Incorporating Function Clone Detection in a Development Process. In Proc. Int’l Conf. on Software Maintenance (ICSM). IEEE, 314–321. issn:1063-6773 https://doi.org/10.1109/ICSM.1997.624264

[50]

Miguel A. Laguna and Yania Crespo. 2013. A Systematic Mapping Study on Software Product Line Evolution: From Legacy System Reengineering to Product Line Refactoring. Science of Computer Programming (SCP), 78, 8 (2013), 1010–1034. https://doi.org/10.1016/j.scico.2012.05.003

Digital Library

[51]

Raúl Lapeña, Manuel Ballarin, and Carlos Cetina. 2016. Towards Clone-and-Own Support: Locating Relevant Methods in Legacy Products. In Proc. Int’l Systems and Software Product Line Conf. (SPLC). ACM, 194–203. https://doi.org/10.1145/2934466.2934485

Digital Library

[52]

Duc Le, Eric Walkingshaw, and Martin Erwig. 2011. #ifdef Confirmed Harmful: Promoting Understandable Software Variation. In Proc. Int’l Symposium on Visual Languages and Human-Centric Computing (VL/HCC). IEEE, 143–150. https://doi.org/10.1109/VLHCC.2011.6070391

[53]

Jörg Liebig, Sven Apel, Christian Lengauer, Christian Kästner, and Michael Schulze. 2010. An Analysis of the Variability in Forty Preprocessor-Based Software Product Lines. In Proc. Int’l Conf. on Software Engineering (ICSE). IEEE, 105–114. https://doi.org/10.1145/1806799.1806819

Digital Library

[54]

Jörg Liebig, Christian Kästner, and Sven Apel. 2011. Analyzing the Discipline of Preprocessor Annotations in 30 Million Lines of C Code. In Proc. Int’l Conf. on Aspect-Oriented Software Development (AOSD). ACM, 191–202. https://doi.org/10.1145/1960275.1960299

Digital Library

[55]

Lukas Linsbauer, Thorsten Berger, and Paul Grünbacher. 2017. A Classification of Variation Control Systems. In Proc. Int’l Conf. on Generative Programming: Concepts & Experiences (GPCE). ACM, 49–62. https://doi.org/10.1145/3136040.3136054

Digital Library

[56]

Lukas Linsbauer, Alexander Egyed, and Roberto Erick Lopez-Herrejon. 2016. A Variability Aware Configuration Management and Revision Control Platform. In Proc. Int’l Conf. on Software Engineering (ICSE). ACM, 803–806. https://doi.org/10.1145/2889160.2889262

Digital Library

[57]

Lukas Linsbauer, Stefan Fischer, Roberto E. Lopez-Herrejon, and Alexander Egyed. 2015. Using Traceability for Incremental Construction and Evolution of Software Product Portfolios. In Proc. Int’l Symposium on Software and Systems Traceability (SST). IEEE, 57–60. https://doi.org/10.1109/SST.2015.16

Digital Library

[58]

Lukas Linsbauer, Roberto Erick Lopez-Herrejon, and Alexander Egyed. 2017. Variability Extraction and Modeling for Product Variants. Software and System Modeling (SoSyM), 16, 4 (2017), 1179–1199. https://doi.org/10.1007/s10270-015-0512-y

Digital Library

[59]

Jia Liu, Don Batory, and Christian Lengauer. 2006. Feature Oriented Refactoring of Legacy Applications. In Proc. Int’l Conf. on Software Engineering (ICSE). ACM, 112–121. https://doi.org/10.1145/1134285.1134303

Digital Library

[60]

Wardah Mahmood, Daniel Strueber, Thorsten Berger, Ralf Laemmel, and Mukelabai Mukelabai. 2021. Seamless Variability Management With the Virtual Platform. In Proc. Int’l Conf. on Software Engineering (ICSE). IEEE, 1658–1670. https://doi.org/10.1109/ICSE43902.2021.00147

Digital Library

[61]

R. Malaquias, M. Ribeiro, R. Bonifácio, E. Monteiro, F. Medeiros, A. Garcia, and R. Gheyi. 2017. The Discipline of Preprocessor-Based Annotations - Does #ifdef TAG n’t #endif Matter. In Proc. Int’l Conf. on Program Comprehension (ICPC). 297–307. https://doi.org/10.1109/ICPC.2017.41

Digital Library

[62]

Jabier Martinez, Tewfik Ziadi, Tegawendé F. Bissyandé, Jacques Klein, and Yves Le Traon. 2015. Bottom-Up Adoption of Software Product Lines: A Generic and Extensible Approach. In Proc. Int’l Systems and Software Product Line Conf. (SPLC). ACM, 101–110. https://doi.org/10.1145/2791060.2791086

Digital Library

[63]

Flávio Medeiros, Márcio Ribeiro, and Rohit Gheyi. 2013. Investigating Preprocessor-Based Syntax Errors. In Proc. Int’l Conf. on Generative Programming: Concepts & Experiences (GPCE). ACM, 75–84. https://doi.org/10.1145/2517208.2517221

Digital Library

[64]

Flávio Medeiros, Márcio Ribeiro, Rohit Gheyi, Sven Apel, Christian Kästner, Bruno Ferreira, Luiz Carvalho, and Baldoino Fonseca. 2018. Discipline Matters: Refactoring of Preprocessor Directives in the #ifdef Hell. IEEE Trans. on Software Engineering (TSE), 44, 5 (2018), 453–469. https://doi.org/10.1109/TSE.2017.2688333

[65]

Raul Medina-Mora and Peter H. Feiler. 1981. An Incremental Programming Environment. IEEE Trans. on Software Engineering (TSE), 472–482.

Digital Library

[66]

Thilo Mende, Rainer Koschke, and Felix Beckwermert. 2009. An Evaluation of Code Similarity Identification for the Grow-and-Prune Model. J. Software Maintenance and Evolution (JSME), 21, 2 (2009), 143–169. https://doi.org/10.1002/smr.v21:2

[67]

Gabriela Karoline Michelon, Lukas Linsbauer, Wesley K.G. Assunção, Stefan Fischer, and Alexander Egyed. 2021. A Hybrid Feature Location Technique for Re-Engineering Single Systems into Software Product Lines. In Proc. Int’l Working Conf. on Variability Modelling of Software-Intensive Systems (VaMoS). ACM, Article 11, 9 pages. https://doi.org/10.1145/3442391.3442403

Digital Library

[68]

Gabriela Karoline Michelon, David Obermann, Wesley Klewerton Guez Assunção, Lukas Linsbauer, Paul Grünbacher, and Alexander Egyed. 2020. Mining Feature Revisions in Highly-Configurable Software Systems. In Proc. Int’l Systems and Software Product Line Conf. (SPLC). ACM, 74–78. https://doi.org/10.1145/3382026.3425776

Digital Library

[69]

Gabriela Karoline Michelon, David Obermann, Lukas Linsbauer, Wesley Klewerton Guez Assunção, Paul Grünbacher, and Alexander Egyed. 2020. Locating Feature Revisions in Software Systems Evolving in Space and Time. In Proc. Int’l Systems and Software Product Line Conf. (SPLC). ACM, Article 14, 11 pages. https://doi.org/10.1145/3382025.3414954

Digital Library

[70]

Webb Miller and Eugene W. Myers. 1985. A File Comparison Program. Software: Practice and Experience, 15, 11 (1985), 1025–1040. https://doi.org/10.1002/spe.4380151102

[71]

Eugene W. Myers. 1986. An O(ND) Difference Algorithm and Its Variations. Algorithmica, 1, 1-4 (1986), 251–266. https://doi.org/10.1007/BF01840446

Digital Library

[72]

Hoan Anh Nguyen, Tung Thanh Nguyen, Nam H. Pham, Jafar Al-Kofahi, and Tien N. Nguyen. 2012. Clone Management for Evolving Software. IEEE Trans. on Software Engineering (TSE), 38, 5 (2012), 1008–1026. https://doi.org/10.1109/TSE.2011.90

Digital Library

[73]

David Notkin. 1985. The GANDALF Project. J. Systems and Software (JSS), 5, 2 (1985), 91–105. https://doi.org/10.1016/0164-1212(85)90011-1

Digital Library

[74]

Leonardo Passos, Jianmei Guo, Leopoldo Teixeira, Krzysztof Czarnecki, Andrzej Wąsowski, and Paulo Borba. 2013. Coevolution of Variability Models and Related Artifacts: A Case Study from the Linux Kernel. In Proc. Int’l Systems and Software Product Line Conf. (SPLC). ACM, 91–100. https://doi.org/10.1145/2491627.2491628

Digital Library

[75]

Mateusz Pawlik and Nikolaus Augsten. 2011. RTED: A Robust Algorithm for the Tree Edit Distance. Computing Research Repository (CoRR), 5, 4 (2011), 334–345.

[76]

Tristan Pfofe, Thomas Thüm, Sandro Schulze, Wolfram Fenske, and Ina Schaefer. 2016. Synchronizing Software Variants with VariantSync. In Proc. Int’l Systems and Software Product Line Conf. (SPLC). ACM, 329–332. https://doi.org/10.1145/2934466.2962726

Digital Library

[77]

Klaus Pohl, Günter Böckle, and Frank J. van der Linden. 2005. Software Product Line Engineering: Foundations, Principles and Techniques. Springer. https://doi.org/10.1007/3-540-28901-1

[78]

Denys Poshyvanyk, Yann-Gael Gueheneuc, Andrian Marcus, Giuliano Antoniol, and Vaclav Rajlich. 2007. Feature Location Using Probabilistic Ranking of Methods Based on Execution Scenarios and Information Retrieval. IEEE Trans. on Software Engineering (TSE), 33, 6 (2007), 420–432. https://doi.org/10.1109/TSE.2007.1016

Digital Library

[79]

Dhavleesh Rattan, Rajesh Bhatia, and Maninder Singh. 2013. Software Clone Detection: A Systematic Review. J. Information and Software Technology (IST), 55, 7 (2013), 1165–1199. https://doi.org/10.1016/j.infsof.2013.01.008

[80]

Thomas Reps and Tim Teitelbaum. 1984. The Synthesizer Generator. SIGPLAN Not., 19, 5 (1984), 42–48. https://doi.org/10.1145/800020.808247

Digital Library

[81]

Nicholas Rescher. 1968. Many-Valued Logic. Springer, 54–125. https://doi.org/10.1007/978-94-017-3546-9_6

[82]

Matthias Rieger, Stéphane Ducasse, and Georges Golomingi. 1999. Tool Support for Refactoring Duplicated OO Code. In Proc. Europ. Conf. on Object-Oriented Programming (ECOOP). 1743, Springer, 177–178.

[83]

Julia Rubin and Marsha Chechik. 2013. A Survey of Feature Location Techniques. In Domain Engineering: Product Lines, Languages, and Conceptual Models, Iris Reinhartz-Berger, Arnon Sturm, Tony Clark, Sholom Cohen, and Jorn Bettin (Eds.). Springer, 29–58. https://doi.org/10.1007/978-3-642-36654-3_2

[84]

Julia Rubin, Krzysztof Czarnecki, and Marsha Chechik. 2013. Managing Cloned Variants: A Framework and Experience. In Proc. Int’l Systems and Software Product Line Conf. (SPLC). ACM, 101–110. https://doi.org/10.1145/2491627.2491644

Digital Library

[85]

Thomas Schmorleiz and Ralf Lämmel. 2014. Similarity Management via History Annotation. In Proc. Seminar on Advanced Techniques and Tools for Software Evolution (SATToSE). Dipartimento di Informatica Università degli Studi dell’Aquila, L’Aquila, Italy, 45–48.

[86]

Thomas Schmorleiz and Ralf Lämmel. 2016. Similarity Management of ’Cloned and Owned’ Variants. In Proc. ACM Symposium on Applied Computing (SAC). ACM, 1466–1471. https://doi.org/10.1145/2851613.2851785

Digital Library

[87]

Sandro Schulze, Jörg Liebig, Janet Siegmund, and Sven Apel. 2013. Does the Discipline of Preprocessor Annotations Matter?: A Controlled Experiment. SIGPLAN Not., 49, 3 (2013), 65–74. https://doi.org/10.1145/2637365.2517215

Digital Library

[88]

Felix Schwägerl and Bernhard Westfechtel. 2016. SuperMod: Tool Support for Collaborative Filtered Model-Driven Software Product Line Engineering. In Proc. Int’l Conf. on Automated Software Engineering (ASE). ACM, 822–827. https://doi.org/10.1145/2970276.2970288

Digital Library

[89]

Janet Siegmund. 2016. Program Comprehension: Past, Present, and Future. In Proc. Int’l Conf. on Software Analysis, Evolution and Reengineering (SANER). IEEE, 13–20. https://doi.org/10.1109/SANER.2016.35

[90]

Bolesł aw Sobociński. 1952. Axiomatization of a Partial System of Three-Value Calculus of Propositions. Journal of Computing Systems, 1, 1 (1952), 23–55. https://doi.org/10.2307/2267445

[91]

Henry Spencer and Geoff Collyer. 1992. #ifdef Considered Harmful, or Portability Experience With C News. In USENIX. USENIX Association, 185–197.

[92]

Stefan Stănciulescu, Thorsten Berger, Eric Walkingshaw, and Andrzej Wąsowski. 2016. Concepts, Operations, and Feasibility of a Projection-Based Variation Control System. In Proc. Int’l Conf. on Software Maintenance and Evolution (ICSME). IEEE, 323–333. https://doi.org/10.1109/ICSME.2016.88

[93]

Stefan Stănciulescu, Sandro Schulze, and Andrzej Wąsowski. 2015. Forked and Integrated Variants in an Open-Source Firmware Project. In Proc. Int’l Conf. on Software Maintenance and Evolution (ICSME). IEEE, 151–160. https://doi.org/10.1109/ICSM.2015.7332461

Digital Library

[94]

Matús Sulír, Milan Nosál, and Jaroslav Porubän. 2018. Recording Concerns in Source Code Using Annotations. Computing Research Repository (CoRR), abs/1808.03576 (2018).

[95]

Thomas Thüm, Leopoldo Teixeira, Klaus Schmid, Eric Walkingshaw, Mukelabai Mukelabai, Mahsa Varshosaz, Goetz Botterweck, Ina Schaefer, and Timo Kehrer. 2019. Towards Efficient Analysis of Variation in Time and Space. In Proc. Int’l Workshop on Variability and Evolution of Software-Intensive Systems (VariVolution). ACM, 57–64. https://doi.org/10.1145/3307630.3342414

Digital Library

[96]

Michael Toomim, Andrew Begel, and Susan L. Graham. 2004. Managing Duplicated Code with Linked Editing. In Proc. Int’l Symposium on Visual Languages and Human-Centric Computing (VL/HCC). IEEE, 173–180. https://doi.org/10.1109/VLHCC.2004.35

Digital Library

[97]

Markus Voelter, Janet Siegmund, Thorsten Berger, and Bernd Kolb. 2014. Towards User-Friendly Projectional Editors. In Proc. Int’l Conf. on Software Language Engineering (SLE). Springer, 41–61. https://doi.org/10.1007/978-3-319-11245-9_3

[98]

Anneliese von Mayrhauser, A. Marie Vans, and Adele E. Howe. 1997. Program Understanding Behaviour During Enhancement of Large-Scale Software. J. Software: Evolution and Process, 9, 5 (1997), 299–327. https://doi.org/10.1002/(SICI)1096-908X(199709/10)9:5<299::AID-SMR157>3.0.CO;2-S

Digital Library

[99]

Neil Walkinshaw, Marc Roper, and Murray Wood. 2007. Feature Location and Extraction using Landmarks and Barriers. In Proc. Int’l Conf. on Software Maintenance (ICSM). IEEE, 54–63. https://doi.org/10.1109/ICSM.2007.4362618

[100]

Jinshui Wang, Xin Peng, Zhenchang Xing, and Wenyun Zhao. 2013. How Developers Perform Feature Location Tasks: A Human-Centric and Process-Oriented Exploratory Study. J. Software: Evolution and Process, 25, 11 (2013), 1193–1224. https://doi.org/10.1002/smr.1593 arxiv:https://onlinelibrary.wiley.com/doi/pdf/10.1002/smr.1593.

[101]

Norman Wilde and Michael C. Scully. 1995. Software Reconnaissance: Mapping Program Features to Code. J. Software Maintenance: Research and Practice, 7, 1 (1995), 49–62. https://doi.org/10.1002/smr.4360070105

Digital Library

[102]

David Wille, Sandro Schulze, Christoph Seidl, and Ina Schaefer. 2016. Custom-Tailored Variability Mining for Block-Based Languages. In Proc. Int’l Conf. on Software Analysis, Evolution and Reengineering (SANER). IEEE, 271–282. https://doi.org/10.1109/SANER.2016.13

[103]

Yinxing Xue, Zhenchang Xing, and Stan Jarzabek. 2012. Feature Location in a Collection of Product Variants. In Proc. Working Conf. on Reverse Engineering (WCRE). IEEE, 145–154. https://doi.org/10.1109/WCRE.2012.24

Digital Library

[104]

Tewfik Ziadi, Christopher Henard, Mike Papadakis, Mikal Ziane, and Yves Le Traon. 2014. Towards a Language-Independent Approach for Reverse-Engineering of Software Product Lines. In Proc. ACM Symposium on Applied Computing (SAC). ACM, 1064–1071. https://doi.org/10.1145/2554850.2554874

Digital Library

Cited By

Bittner PSchultheiß AMoosherr BYoung JTeixeira LWalkingshaw EAtaei PThüm T(2024)On the Expressive Power of Languages for Static VariabilityProceedings of the ACM on Programming Languages10.1145/36897478:OOPSLA2(1018-1050)Online publication date: 8-Oct-2024
https://dl.acm.org/doi/10.1145/3689747
Greiner SSchultheiß ABittner PThüm TKehrer T(2024)Give an Inch and Take a Mile? Effects of Adding Reliable Knowledge to Heuristic Feature TracingProceedings of the 28th ACM International Systems and Software Product Line Conference10.1145/3646548.3672593(84-95)Online publication date: 2-Sep-2024
https://dl.acm.org/doi/10.1145/3646548.3672593
Mahmood WÇalıklı GStrüber DLämmel RMukelabai MBerger T(2024)Virtual Platform: Effective and Seamless Variability Management for Software SystemsIEEE Transactions on Software Engineering10.1109/TSE.2024.340622450:11(2753-2785)Online publication date: 1-Nov-2024
https://dl.acm.org/doi/10.1109/TSE.2024.3406224
Show More Cited By

Index Terms

Feature trace recording
1. Software and its engineering
  1. Software creation and management
    1. Software post-development issues
      1. Software evolution
  2. Software notations and tools
    1. Software configuration management and version control systems

Recommendations

Bridging the gap between clone-and-own and software product lines
ICSE-NIER '21: Proceedings of the 43rd International Conference on Software Engineering: New Ideas and Emerging Results

Software is often released in multiple variants to meet all customer requirements. While software product lines address this need by advocating the development of an integrated software platform, practitioners frequently rely on ad-hoc reuse based on a ...
Feature location benchmark with argoUML SPL
SPLC '18: Proceedings of the 22nd International Systems and Software Product Line Conference - Volume 1

Feature location is a traceability recovery activity to identify the implementation elements associated to a characteristic of a system. Besides its relevance for software maintenance of a single system, feature location in a collection of systems ...
Synchronizing software variants with variantsync
SPLC '16: Proceedings of the 20th International Systems and Software Product Line Conference

Developing and managing software variants is a key challenge in today's software development. Due to conflicting requirements, software is developed in multiple variants to satisfy the needs of individual customers. While software product lines allow ...

Comments

Information & Contributors

Information

Published In

cover image ACM Conferences

ESEC/FSE 2021: Proceedings of the 29th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering

August 2021

1690 pages

ISBN:9781450385626

DOI:10.1145/3468264

General Chairs:
Diomidis Spinellis
Athens University of Economics and Business, Greece
,
Georgios Gousios
Facebook, Netherlands / Delft University of Technology, Netherlands
,
Program Chairs:
Marsha Chechik
University of Toronto, Canada
,
Massimiliano Di Penta
University of Sannio, Italy

Copyright © 2021 ACM.

Publication rights licensed to ACM. ACM acknowledges that this contribution was authored or co-authored by an employee, contractor or affiliate of a national government. As such, the Government retains a nonexclusive, royalty-free right to publish or reproduce this article, or to allow others to do so, for Government purposes only.

Sponsors

SIGSOFT: ACM Special Interest Group on Software Engineering

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 18 August 2021

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Badges

Author Tags

Qualifiers

Research-article

Funding Sources

German Research Foundation (DFG)

Conference

ESEC/FSE '21

Sponsor:

SIGSOFT

ESEC/FSE '21: 29th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering

August 23 - 28, 2021

Athens, Greece

Acceptance Rates

Overall Acceptance Rate 112 of 543 submissions, 21%

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

5
Total Citations
View Citations
317
Total Downloads

Downloads (Last 12 months)34
Downloads (Last 6 weeks)3

Reflects downloads up to 03 Mar 2025

Other Metrics

View Author Metrics

Citations

Cited By

Bittner PSchultheiß AMoosherr BYoung JTeixeira LWalkingshaw EAtaei PThüm T(2024)On the Expressive Power of Languages for Static VariabilityProceedings of the ACM on Programming Languages10.1145/36897478:OOPSLA2(1018-1050)Online publication date: 8-Oct-2024
https://dl.acm.org/doi/10.1145/3689747
Greiner SSchultheiß ABittner PThüm TKehrer T(2024)Give an Inch and Take a Mile? Effects of Adding Reliable Knowledge to Heuristic Feature TracingProceedings of the 28th ACM International Systems and Software Product Line Conference10.1145/3646548.3672593(84-95)Online publication date: 2-Sep-2024
https://dl.acm.org/doi/10.1145/3646548.3672593
Mahmood WÇalıklı GStrüber DLämmel RMukelabai MBerger T(2024)Virtual Platform: Effective and Seamless Variability Management for Software SystemsIEEE Transactions on Software Engineering10.1109/TSE.2024.340622450:11(2753-2785)Online publication date: 1-Nov-2024
https://dl.acm.org/doi/10.1109/TSE.2024.3406224
Schultheiß ABittner PGreiner SKehrer T(2023)Benchmark Generation with VEVOS: A Coverage Analysis of Evolution Scenarios in Variant-Rich SystemsProceedings of the 17th International Working Conference on Variability Modelling of Software-Intensive Systems10.1145/3571788.3571793(13-22)Online publication date: 25-Jan-2023
https://dl.acm.org/doi/10.1145/3571788.3571793
Schultheis ABittner PThum TKehrer T(2022)Quantifying the Potential to Automate the Synchronization of Variants in Clone-and-Own2022 IEEE International Conference on Software Maintenance and Evolution (ICSME)10.1109/ICSME55016.2022.00032(269-280)Online publication date: Oct-2022
https://doi.org/10.1109/ICSME55016.2022.00032

View Options

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Publication

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

Figures

Tables

Media

View Table of Conten