1. the complete title of one (or more) paper(s) published in the open literature describing the work that the author claims describes a human-competitive result; Software Product Line Engineering via Software Transplantation 2. the name, complete physical mailing address, e-mail address, and phone number of EACH author of EACH paper(s); Leandro Oliveria de Souza Federal Institute of Bahia Avenida Professor Jorge Rodrigues. Bairro Liberdade. nº 1800. Irecê - Bahia Brazil e-mail: leandro.souza@ifba.edu.br tel:+55 (74) 99997 3165 Eduardo Santana de Almeida Federal University of Bahia, Institute of Computing Avenida Milton Santos, Ondina Salvador - Bahia Brazil e-mail: eduardo.almeida@ufba.br tel:+55 (71) 9607-0309 Paulo Anselmo da Mota Silveira Neto Federal Rural University of Pernambuco, Department of Computing Rua Dom Manoel de Medeiros, s/n. Campus Dois Irmãos Recife - Pernambuco Brazil e-mail: paulo.motant@ufrpe.br tel:+55 (81) 8288-0808 Earl T. Barr University College London, Department of Computer Science Gower Street, London, WC1E 6BT, United Kingdom e-mail: e.barr@ucl.ac.uk tel: +44 (0)20 7679 3570 Justyna Petke University College London, Department of Computer Science Gower Street, London, WC1E 6BT, United Kingdom e-mail: j.petke@ucl.ac.uk tel: +44 (0)20 3549 5760 3. the name of the corresponding author (i.e., the author to whom notices will be sent concerning the competition); Justyna Petke 4. the abstract of the paper(s); Software Product Lines (SPLs) improve time-to-market, enhance software quality, and reduce maintenance costs. Current SPL reengineering practices are largely manual and require domain knowledge. Thus, adopting and, to a lesser extent, maintaining SPLs are expensive tasks, preventing many companies from enjoying their benefits. To address these challenges, we introduce Foundry, an approach utilising software transplantation to reduce the manual effort of SPL adoption and maintenance. Foundry enables integrating features across different codebases, even codebases that are unaware that they are contributing features to a software product line. Each product produced by Foundry is pure code, without variability annotation, unlike feature flags, which eases variability management and reduces code bloat. We realise Foundry in prodScalpel, a tool that transplants multiple organs (i.e., a set of interesting features) from donor systems into an emergent product line for codebases written in C. Given tests and lightweight annotations identifying features and implantation points, prodScalpel automates feature extraction and integration. To evaluate its effectiveness, our evaluation compares feature transplantation using prodScalpel to the current state of practice: on our dataset, prodScalpel’s use speeds up feature migration by an average of 4.8 times when compared to current practice. 5. a list containing one or more of the eight letters (A, B, C, D, E, F, G, or H) that correspond to the criteria (see above) that the author claims that the work satisfies; (E) The result is equal to or better than the most recent human-created solution to a long-standing problem for which there has been a succession of increasingly better human-created solutions. (F) The result is equal to or better than a result that was considered an achievement in its field at the time it was first discovered. (G) The result solves a problem of indisputable difficulty in its field. (H) The result holds its own or wins a regulated competition involving human contestants (in the form of either live human players or human-written computer programs). 6. a statement stating why the result satisfies the criteria that the contestant claims (see examples of statements of human-competitiveness as a guide to aid in constructing this part of the submission); (E) Feature reuse and software reengineering for Software Product Lines (SPLs) is a long-standing and labor-intensive challenge in computer science. Traditional SPL reengineering requires manual identification, adaptation, and integration of features across diverse codebases. Our work is the first to automate this process using software transplantation guided by genetic and evolutionary computation (GEC). We introduce Foundry, a transplantation-based framework, and prodScalpel, a tool that automates the extraction, adaptation, and integration of features (termed "organs") from existing systems into new SPLs. Unlike manual approaches, Foundry requires only a single annotation per feature, significantly reducing the human effort and expertise required. (F) Our tool outperforms humans in SPL engineering tasks. In a controlled experiment with 20 SPL experts, prodScalpel completed feature transplantation 4.8 times faster than the average time taken by experts. Moreover, in real-world codebases such as VI, VIM, and CFLOW, prodScalpel successfully transplanted multiple features from disparate domains. In contrast, human experts often failed to complete these tasks within the allotted time or produced defective results. (G) Code reuse is a daily challenge for software developers. Manually transplanting code involves locating functionality, understanding dependencies, adapting the feature, and validating integration — typically requiring days or weeks. Our automated solution transforms this into a fully autonomous process. For example, we show that transplanting a complex feature such as write_archive from an archive manager (MYTAR) into a text editor (NEATVI) is completed by prodScalpel in under 30 minutes, whereas most human experts failed within a 4-hour window. This automation makes SPL reengineering accessible to organizations without SPL expertise. (H) We evaluated our results with SPL experts and industrial-quality benchmarks. prodScalpel was tested in two experimental scenarios and two case studies, involving 20 participants and five real-world systems. Our transplanted features passed extensive test suites — including regression and acceptance tests — with higher reliability than the manual baseline. In both controlled and case study settings, prodScalpel consistently produced functional, modular, and correctly integrated features. In the controlled experiment with 20 SPL experts, prodScalpel completed feature transplantation 4.8 times faster than the average time taken by experts. These improvements stem directly from our use of Genetic Improvement techniques, which guide the evolution and adaptation of transplanted code to fit new host environments via test-driven genetic programming. 7. a full citation of the paper (that is, author names; publication date; name of journal, conference, technical report, thesis, book, or book chapter; name of editors, if applicable, of the journal or edited book; publisher name; publisher city; page numbers, if applicable); Leandro Oliveria de Souza, Eduardo Santana de Almeida, Paulo Anselmo da Mota Silveira Neto, Earl T. Barr, and Justyna Petke. Software Product Line Engineering via Software Transplantation. Publication Date: 20 January 2025. ACM Transacations on Software Engineering and Methodology, Volume 34, Issue 2, Article No. 31, Pages 1 - 27. Publisher Name: Association for Computing Machinery. Publisher City: New York, NY, USA. https://doi.org/10.1145/3695987 8. a statement either that "any prize money, if any, is to be divided equally among the co-authors" OR a specific percentage breakdown as to how the prize money, if any, is to be divided among the co-authors; any prize money, if any, is to be divided equally among the co-authors 9. a statement stating why the authors expect that their entry would be the "best” Genetic programming and genetic improvement (GI) have proven effective in solving various software engineering problems — from performance tuning to automated repair. Our work pushes the frontier of GI further by tackling automated software reuse at the feature level, a fundamental challenge in Software Product Line (SPL) engineering. We are the first to use GI-based software transplantation to automate the reengineering of legacy systems into SPLs, enabling code reuse across unrelated systems. We implemented our approach in a practical tool, prodScalpel, and used it to extract and transplant multiple features (organs) from real-world donor program — including NEATVI, VIM, CFLOW, and MYTAR — into newly assembled SPLs. These donor systems come from diverse domains, and the resulting product lines are fully functional, modular, and reproducible. Unlike traditional reuse, which is brittle and manually intensive, our tool automates the entire pipeline: extraction, adaptation, and integration. We validated our results in a rigorous experiment with 20 SPL experts, showing that prodScalpel performs feature migration 4.8x faster than human experts on average — without sacrificing correctness or breaking test suites. In addition, we presented two multi-feature case studies, demonstrating the tool’s ability to transplant code from systems not engineered for SPLs — a key step toward the vision of Symbiotic SPLs. Our research has already been recognized by the ACM Transactions on Software Engineering and Methodology (TOSEM), where it was published as a full article. TOSEM is one of the most prestigious journals in the software engineering field, further underscoring the originality and significance of our work. We expect our entry to be the best because: • It automates a non-trivial software engineering task traditionally requiring weeks of expert effort. • It demonstrates generalizability across domains and systems (text editors, archive managers, code analyzers). • It introduces a novel software reuse paradigm — Symbiotic SPL — where the features could be periodically refreshed by re-transplanting them form an SPL-oblivious donor into its product base. • It brings practical impact by lowering the barrier to SPL adoption in real-world codebases. • It is backed by rigorous empirical evidence: the statistical analysis of controlled, reproducible, experiments. We believe that prodScalpel has potential to redefine how software reuse is performed — by removing the manual bottlenecks of SPL engineering — which is not only innovative but also truly human-competitive. 10. an indication of the general type of genetic or evolutionary computation used, such as GA (genetic algorithms), GP (genetic programming), ES (evolution strategies), EP (evolutionary programming), LCS (learning classifier systems), GE (grammatical evolution), GEP (gene expression programming), DE (differential evolution), etc. Genetic Improvement (GI), Genetic Programming (GP) 11. The date of publication of each paper. If the date of publication is not on or before the deadline for submission, but instead, the paper has been unconditionally accepted for publication and is “in press” by the deadline for this competition, the entry must include a copy of the documentation establishing that the paper meets the "in press" requirement. Published: 20 January 2025 Publisher's link: https://doi.org/10.1145/3695987 Please post the publisher's link on the Humie pages as attribution is required by the publisher.