Towards Enabling An Artificial Self-Construction Software Life-cycle via Autopoietic Architectures Daniel Rodriguez-Cardenas
David N. Palacio
Denys Poshyvanyk
[email protected] William & Mary Williamsburg, VA, USA
[email protected] Microsoft Redmont, WA, USA
[email protected] William & Mary Williamsburg, VA, USA
arXiv:2604.13934v1 [cs.SE] 15 Apr 2026
Abstract Software engineering research has focused on automating maintenance and evolution processes to reduce costs and improve reliability. The emergence of foundation models (FMs) with strong code understanding and reasoning abilities offers new opportunities for autonomous software behavior. Inspired by Artificial Life (ALife), we propose a fundamental shift in the Software Development Life-Cycle (SDLC) by introducing self-construction mechanisms that enable software to evolve and maintain autonomously. This position paper explores the potential of Autopoietic Architectures, specifically Ψ-Arch, as a foundational framework for selfconstructing software. We first analyze the limitations of traditional maintenance approaches and identify gaps in current SDLC automation. Subsequently, we outline the core challenges in achieving self-construction, including integrating foundation-model-based reasoning units and establishing novel architectural paradigms. Although this paper does not present a definitive solution, it seeks to catalyze discourse and inspire research toward a new paradigm in software engineering—one in which self-constructing software represents the next frontier in SDLC automation.
CCS Concepts • Software and its engineering → Software development techniques; Software development techniques; • Computing methodologies → Artificial intelligence.
deployed and maintained [19, 22]. Specifically, the software maintenance phase is the most critical and costly in the SDLC [14, 35]. Software maintenance entails any modifications made to a system after deployment. In fact, these modifications involve the knowledge of the practitioners [47] to design, construct, and improve the source code. Recent software maintenance (SM) research has focused on automating repetitive tasks using Machine Learning (ML) and, more recently, foundational models (FMs) - large-scale pre-trained models trained on vast datasets of code and natural language with broad capabilities across diverse tasks. Automating software maintenance ensures that software systems remain efficient, reliable, adaptable, and relevant over time [43, 46]. Several studies have investigated software maintenance automation on downstream tasks such as testing [16, 17], and program repair [10, 30, 60, 67]. Additionally, foundation model-based code generation has been extensively studied in the field of software maintenance [7, 11, 25, 52, 57, 61] to assist practitioners with large language models (LLMs) demonstrating remarkable abilities to understand code semantics [27], generate patches [21, 40], and think about software behavior [59]. However, as software products grow in size and complexity, canonical ML-assisted maintenance becomes increasingly challenging and error-prone [15], powered by the reasoning and generative capabilities of foundation models [62]. (a) Canonical Maintenance Paradigm
(b) Self-Construction Maintenance Paradigm
Keywords AI, LLMs for Code, Maintenance, Software Life-cycle ACM Reference Format: Daniel Rodriguez-Cardenas, David N. Palacio, and Denys Poshyvanyk. 2018. Towards Enabling An Artificial Self-Construction Software Life-cycle via Autopoietic Architectures . In Proceedings of Make sure to enter the correct conference title from your rights confirmation email (Conference acronym ’XX). ACM, New York, NY, USA, 6 pages. https://doi.org/XXXXXXX.XXXXXXX
Maintenance Software
Maintenance Software Prompt
Regulation and Control (Maintenance)
Main Software Artificial Software Engineer
Developer
Main Software Security
1
Introduction
Software Development Life-Cycle (SDLC) outlines five phases to produce a software artifact i.e., that is designed, developed, tested, Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than the author(s) must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected]. Conference acronym ’XX, Woodstock, NY © 2018 Copyright held by the owner/author(s). Publication rights licensed to ACM. ACM ISBN 978-1-4503-XXXX-X/2018/06 https://doi.org/XXXXXXX.XXXXXXX
Monitoring
Debug
self-construction life-cycle
Figure 1: Maintenance Paradigm Shift: a) Software Maintenance (SM) is independent from the main software, and b) SM is wrapping the main software. This canonical vision of software maintenance has permeated research methods in the software community, leaving no room for alternative approaches due to the remarkably successful use of statistical learning technologies such as transformers [55] or reinforcement learning [59]. Irrespective of the exponentially growing canonical research on maintenance, a significant gap remains as
Conference acronym ’XX, June 03–05, 2018, Woodstock, NY
this SM automation has not yet been addressed from the perspective of autonomous construction. This autonomous mechanism is achieved by incorporating artificial life (ALife) elements to enable autopoietic features (e.g., self-organization, self-assembly, or self-replication) for self-construction [12, 42, 63], powered by the reasoning and generative capabilities of fundation models. ALife is an interdisciplinary field that examines life-like properties—such as self-organization, adaptation, and evolution—in natural and artificial systems [12]. Integrating ALife principles with foundation model capabilities enables maintenance frameworks that not only perform predefined tasks, but also autonomously adapt and evolve under changing conditions. We propose selfconstruction maintenance as a replacement for the canonical maintenance paradigm within the SDLC. This paper challenges the traditional understanding of SM and introduces an autonomous mechanism that supports the software construction life-cycle. This paper introduces an autopoietic architecture called ΨArch for the artificial self-construction software life-cycle. Ψ-Arch is an extended and adapted version of von Neumann’s self-replicating model [33]. We present a first draft for the formal notation of Ψ-Arch and a complete description of an additional self-construction reasoning unit Γ. Ψ-Arch establishes the foundation for next-generation SDLC through artificial software engineering. In this paper, we explain our Ψ-Arch and how to integrate an autopoietic architecture in a software system using LLMs. We highlight the necessity of using causal reasoning to help the system make decisions on self-refactoring, where FMs provide the generative and reasoning capabilities required for autonomous decisionmaking.
2
What are the Autopietic Architectures for?
We assert that the software maintenance research conducted on automatic techniques to date will be easily integrated into the autopoietic architecture (Ψ-Arch). Consider the following scenario; a software engineer wants to eliminate a useless functionality in a software system 𝑆. The useless functionality can be mapped to sections of the source code that are executed, but its results are never required. This is a typical example of dead functionality elimination. This engineer wants the system 𝑆 to self-identify the impact of the elimination of functionality and remove additional dead code. At this point, we can notice that the system 𝑆 includes the FM-powered solution, in other words, 𝑆 is an FM by itself. Using an autopoietic architecture (Ψ-Arch), the system 𝑆 is controlled by a reasoning unit Γ that decides how to react in the presence of dead code and create a refactoring. The autopoietic architecture automatically generates a new, refactored replica of itself to replace the actual system, ensuring that the replica runs stably. We envision a formal and nature-inspired approach that artificially enables the self-construction of the Software Engineering LifeCycle using Ψ-Arch. Figure 1 illustrates the paradigm shift from a canonical ML-driven to a self-construction maintenance technique. This self-construction paradigm allows software systems to create better replicas of themselves at run-time, leaveraging the code understanding, generation, and reasoning capabilities.
Rodriguez-Cardenas et al.
3
Background & Context
Foundation models are large-scale pre-trained models trained on broad datasets that can be adapted to a wide range of tasks [2]. Unlike traditional Machine Learning models that require taskspecific training, FMs leverage transfer learning and self-supervised learning to develop general-purpose capabilities that can be finetuned for specific applications. In the context of software maintenance, FMs such as GPT-4, CodeLlama, and StarCoder have demonstrated remarkable capabilities in code generation [13], program repair [21, 67], vulnerability detection [38, 45], and code comprehension [56]. The term autopoiesis refers to a process by which systems continuously regenerate and sustain their components and connections autonomously [5, 26]. Under this autopoietic automation vision, software systems are perceived as dynamic entities with inherent self-regulation, adaptability, and, in particular, self-construction behaviors. The autopoiesis concept becomes feasible as the recent research on FMs, particularly LLMs for SE and agentAI4SE [3, 44, 64, 66] has demonstrated the potential to cover the required components for an autopoietic architecture. This perspective transcends conventional ML techniques by enabling a paradigm where software architectures incorporate self-maintenance, self-repair, and autonomous evolution. As a result, autopoietic principles provide a foundation for next-generation artificial software engineering, fostering resilient, adaptive, and self-sustaining computational ecosystems and redefining the SDLC. The Software Development Life-Cycle (SDLC) enables a software product by involving technological resources and stakeholders in a well-designed pipeline. This pipeline consists of several phases, including planning, analysis, design, development, testing, deployment, and maintenance. Each phase has its own set of activities and deliverables that feed into the next phase. Software Maintenance (SM), the last phase, is the longest and, therefore, the most costly because it stays active as long as the software remains in production[14, 35]. Considerable research attention has been devoted to SM on the automation of specific tasks. These tasks assist maintenance activities such as clone detection [61], bug-fixing [53, 54], impact analysis, traceability [29], refactoring[28, 31], bad smell detection [41, 51], and vulnerability detection[8, 9, 48]. It is generally accepted that SM automation operates using machine learning (ML) approaches or evolutionary computation (EC) solutions (i.e., Search-Based Software Engineering [18]). Consequently, several maintenance tasks, within the Software Development Life-Cycle SDLC, still require the active intervention of practitioners. For example, automating bug-fixing with a statistical learning approach depends upon collecting, filtering, deduplicating, and transforming code-based datasets, tasks generally performed by practitioners. Despite the breadth and depth of existing research for automating maintenance tasks, none of those ML and EC approaches have been addressed from the point of view of a self-adaptive technology. Self-adaptivity comprises the ability of a software system to assess and regulate its behavior[23]. Recent progress in self-adaptivity investigates and develops sophisticated systems such as multi-agent
Towards Enabling An Artificial Self-Construction Software Life-cycle via Autopoietic Architectures
software [2], component-based software engineering [24], configurable systems [65], and model-driven architectures [6]. These systems can adapt their behavior in response to environmental changes (e.g., new requirements, limited resources, or code changes). Remarkably, this adaptive capability has also been further studied in the context of Artificial Life (ALife) -particularly- with the introduction, definition, and formalization of autopoietic systems [12].
4
From Canonical to Self-Construction Life-Cycle
Following Asimov’s vision about a self-replicating machine [4], this paper examines the relationship between the premise software systems can self-replicate into a “better, decentralized, and intelligent” version of themselves and the Software Development Life-Cycle (SDLC). This self-replication process embodies the self-construction of adapted internal mechanisms, which compose the original software, to attend an environment of functional (i.e., what the system should do) and non-functional (i.e., how the system should perform) requirements. Assuming the autopoietic automation vision, we must recognize and acknowledge the feasibility of a new type of autonomous architecture that leverages an artificial self-construction life-cycle and the FM’s ability to understand code semantics and generate syntactically correct, functionally appropriate patches [59]. We refer to this autonomous mechanism as Autopoietic Architectures (Ψ-Arch). To attain an artificial self-construction life-cycle paradigm, beyond the canonical perspective (see Figure 1-a), we argue that Ψ-Arch can be used as a self-construction standard to implement systems whose self-replicating components are calibrated and well communicated. This self-construction paradigm draws inspiration from the Von Neumann kinetic beast [32, 33] 1 . The Ψ-Arch embodies six self-replicating components: the main (or original) software, an instruction tape, three machines (e.g., constructor, copy and control machines) and a reasoning unit. The self-replicating process starts when the control machine Λ causes the copy machine 𝐵 to replicate the instruction tape Φ. The first component encapsulates the original software to replicate 𝑃 (Figure 2- 1 ). 𝑃𝑡 𝑦𝑝𝑒 refers to Lehman’s categorization of software systems [22] that encompasses specified systems (𝑆-Systems), problem-solving systems (𝑃-Systems), and evolving systems (𝐸systems). The second component (Figure 2- 2 ) consists of an instruction tape, Φ, which stores the meta-data of Ψ-Arch. This meta-data contains detailed instructions on constructing the entire architecture from its source code. The instruction tape Φ could incorporate advanced, goal-oriented techniques for system maintenance (i.e., automated refactoring, patching, repairing, and re-engineering processes). The third component (Figure 2- 3 ) reflects a constructor machine, denoted as 𝐴, which is responsible for reading any instruction 𝜙 from the instruction tape Φ to construct components. The fourth component is a copy machine 𝐵 (Figure 2- 4 ). 𝐵 can replicate Φ instruction, i.e., 𝐵 can copy Φ meta-data -including Φ(𝐵). The fifth component is the control machine Λ (Figure 2- 5 ). Λ produces an
1 Langton later enhanced this foundational model by introducing a simpler self-
replicating automaton to address the problem of evolutionary capabilities [1]
Conference acronym ’XX, June 03–05, 2018, Woodstock, NY
isolated copy of Ψ and communicates with the reasoning unit Γ (Figure 2- 6 ). Γ is the sixth and last component oracle that formulates causal questions to make decisions [50]. Definition 4.1. The copy process generates a Φ final instruction tape 𝐵 + Φ(Ψ) → Φ(Ψ) (1) where the operand ‘+’ is the use of two components (𝐵 and Φ) and the operand ‘→’ is a realization or copy. In other words, 𝐵 takes the metadata instructions and generates a copy of Φ(Ψ). Define Δ = 𝐴 + 𝐵. Thus, Ψ would be the Δ + 𝑃 composition. Replacing in the previous formula: 𝐵 + Φ(Δ + 𝑃) → Φ(Δ + 𝑃)
(2)
Definition 4.2. Now, Λ causes A to construct the components described by the instruction in Φ(Ψ). The construction process generates a copy of Ψ 𝐴 + Φ(Ψ) → Ψ (3) Definition 4.3. The control machine Λ synchronizes the machines correctly to produce the tape Φ and the Ψ-Architecture by adding the copy of Φ(Ψ) to the new Ψ 𝐴 + 𝐵 + Γ + Φ(Ψ) → Ψ + Φ(Ψ)
(4)
Now, let’s include in the tape machine the information of the main software or 𝑃, the reasoning unit Γ, and rename the entire architecture as Ψ𝑃 , therefore Δ = 𝐴 + 𝐵 + Γ: Ψ𝑃 = Δ + Φ(Δ + 𝑃) = 𝐴 + 𝐵 + Γ + Φ(𝐴 + 𝐵 + Γ + 𝑃)
(5)
so we can observe that Ψ𝑃 → 𝐴 + 𝐵 + Γ + 𝑃 + Φ(𝐴 + 𝐵 + Γ + 𝑃) which means: Ψ𝑃 → Ψ𝑃 + 𝑃 (6) Finally, after following previous definitions, we obtain the original software 𝑃, with the respective optimizations 𝑃 ′ , and its instruction tape. 𝑃 is embedded in the autopoietic architecture Ψ-Arch. Note that 𝑃 ′ optimizations originate from the reasoning unit Γ. Γ introduces small instructions to the instruction tape so Φ(𝑃) evolves to 𝑃 ′ . Γ can include other complementary maintainability tasks e.g., performing control tasks, such as software traceability. This reasoning component Γ is the most challenging to design as it comprises unique and necessary knowledge to address selfconstruction tasks. However, recent research has demonstrated the reasoning capabilities of FMs via prompt engineering and agent orchestration [49]. To properly define this reasoning unit, we decompose it, as detailed in Table 1, into five key dimensions (e.g., component representation, purpose, source of information, algorithm employed, and agent question). In addition to those dimensions, we can classify reasoning tasks into three levels according to Pearl’s causality approach: observation, intervention, and retrospection [36]. Firstly, the goal of the observation level is to predict a maintenance task 𝑀 based on given evidence 𝜖. The prediction is a conditional distribution 𝑝 (𝑀 |𝜖) where 𝑀 can be corrective 𝑀𝑐 , adaptive 𝑀𝑎 , perfective 𝑀𝑝 , or preventive 𝑀𝑣 activity. Secondly, the intervention level aims to measure the causal effect when the reasoning unit Γ modifies a sub-component in 𝑃 to accomplish a maintenance task 𝑀. Finally,
Conference acronym ’XX, June 03–05, 2018, Woodstock, NY
Rodriguez-Cardenas et al.
Figure 2: Autopoietic Architecture Ψ-Arch to enable artificial self-construction software life-cycle -Arch components and software self-construction life-cycle Version t=1 2
Instruction Tape
Version t=2
3 6
Reasoning Unit
2
Constructor Machine
Instruction Tape
Refactoring 1
2
1
3
2
3
3
Reasoning Unit
6
Constructor Machine
Refactoring
4
Program Repair
Program Repair Evolution
System Type Main Software V1
1
4
5
System Type
Copy Machine
Main Software V2
Control Machine
1
4
5
Copy Machine
Control Machine
Table 1: The Reasoning Unit Γ Depends Upon The Maintenance Task Dimension Representation Purpose Source of Inf. Algorithm Agent Question
Observation Probability 𝑝 (𝑀 |𝜖) Take decisions about maintenance tasks based on observations Quality SE Metrics Π Variational Inference What if the unit sees a metric 𝑀 under desired thresholds?
Intervention Causal Effect 𝑑𝑜 {𝑝 (𝑀 |𝜖)} To intervene in the architecture to assess the causal effect of a new replica Traceability Links 𝐿, SE Metrics Π Front/Back door adjustment If the unit modifies a sub-component 𝑃 in the main system to fulfill a maintenance task 𝑀, will enhance a Π metric?
the retrospection level aims to estimate the expected value of hypothetical conditions. For example, consider the reasoning unit Γ performed an adaptive maintenance task 𝑀𝑎 with an observed result 𝑌 = 𝑦, but now the reasoning unit wants to assess what would have happened (𝑌 =?) if, instead of 𝑀𝑎 , the unit had performed 𝑀𝑣 . The previous situation formally defines a counterfactual prediction. The reasoning unit can measure this hypothetical condition using the expected value 𝐸 (𝑌𝑀=𝑀𝑣 |𝑀 = 𝑀𝑎 , 𝑌 = 𝑦).
5
Discussion & Implications
The emergence of self-evolving and autonomous FM agents represents a natural evolution beyond the autopoietic architecture (Ψ-Arch) framework presented in this work. Recent research demonstrates that FM-powered agents can transcend static, human-designed configurations to become adaptive systems capable of continuous self-improvement through interaction data and environmental feedback. These developments align closely with the self-construction paradigm proposed in Ψ-Arch and suggest promising directions for extending the autopoietic software life-cycle. Because the reasoning unit automates some maintenance tasks, a replica of the autopoietic architecture Ψ-Arch serves as an enhanced copy of the original (i.e., main) software. This enhancement formally represents what software researchers refer to as software evolution[39]. In light of our autopoietic architecture Ψ-Arch, the proposed work seeks to explore the following research questions (RQs): • 𝑅𝑄 1 How effective is using ALife elements combined with foundation models to create software systems that exhibit self-construction behavior? The effectiveness of ALife to create software systems that exhibit living features (i.e., self-replication) has been widely studied [5]. However, we require researching methodologies compatible with the software development life-cycle similar to the software transplantaton [34].
Retrospection Counterfactuals 𝐸 [𝑌𝑀 |𝑀, 𝑌 ] To imagine possible scenarios where a modification on the architecture takes place Depends upon the maintenance task 𝑀 Front/Back door adjustment What if the unit had assessed one possible maintenance solution 𝑀 that was not being considered before?
• 𝑅𝑄 2 To what extent is software maintenance automated under the autopoietic Ψ-Arch scheme powered by foundation models? We can measure maintenance levels in a software system by considering corrective, adaptive, perfective, and preventive tasks executed by FMs agents. • 𝑅𝑄 3 Should software designs have a dedicated component to selfconstruction? This question explores if and when incorporating ALife elements in software design. • 𝑅𝑄 4 How can we migrate from canonical maintenance to selfconstruction maintenance paradigm? We can leverage software engineering research to migrate any potential system to an autopoietic architecture Ψ-Arch. To address the RQs, developing and deploying Ψ-Arch will require extensive expertise in training and programming AI-agents. An increased interest in AI-agents has emerged in recent years; this technology has enhanced the performance of challenging tasks[20, 37, 58, 64]. We believe AI-agents theory and practice can contribute to the implementation of the proposed self-replicating components. For example, the control mechanism could be an AI agent trained on architectural patterns data. This control agent can also formulate questions to or communicate with the reasoning unit, another independent agent. While the exact nature of inputs and outputs within autopoietic architectures Ψ-Arch remains uncertain, the overarching goal is clear: to enable self-construction and maintenance through replication and adaptability processes inspired by ALife. It may be observed that the proposed architecture does not account for possible security issues or any other type of non-functional constraints.
6
Conclusion
Software maintenance and evolution are challenging activities in SDLC that require the application of Artificial Life (ALife) techniques combined with FM capabilities to advance next-generation artificial software engineering. This positional paper highlights
Towards Enabling An Artificial Self-Construction Software Life-cycle via Autopoietic Architectures
the benefits of closing the gap between ALife and Software Engineering research by formulating autopoietic architectures to enable an artificial self-construction software life-cycle. The autopoietic architecture, namely Ψ-Arch, aims to follow Lehman laws for software evolution on a SDLC (i.e., continuing change, self-regulation, stability). Ψ-Arch elicits the next generation of artificial software engineers for new SDLC activities (i.e., prompt-engineering, agentAI monitoring, and LLMs for SE debugging). Furthermore, Ψ-Arch requires architectural data and benchmarking to assess the extent of self-construction of the original software system.
References [1] 1989. Artificial Life: The Proceedings of an Interdisciplinary Workshop on the Synthesis and Simulation of Living Systems. In Artificial Life (SFI Studies in the Sciences of Complexity), Christopher G. Langton (Ed.), Vol. VI. Addison-Wesley, Redwood City, CA. [2] Stefano V. Albrecht, Filippos Christianos, and Lukas Schäfer. 2024. Multi-Agent Reinforcement Learning: Foundations and Modern Approaches. MIT Press. https: //www.marl-book.com [3] Daman Arora, Atharv Sonwane, Nalin Wadhwa, Abhav Mehrotra, Saiteja Utpala, et al. 2024. MASAI: Modular Architecture for Software-engineering AI Agents. arXiv:cs.AI/2406.11638 https://arxiv.org/abs/2406.11638 [4] Isaac Asimov. 1956. The Last Question. In Science Fiction Thinking Machines: Robots, Androids, and Computers, Groff Conklin (Ed.). Gnome Press, New York, NY, 3–17. [5] M A Bedau. 2007. Artificial Life. Philosophy of Biology (2007), 585–603. https: //doi.org/10.1016/B978-044451543-8/50027-7 [6] Mayuri Bhadra, Daniela Sanchez Lopera, Robert Kunzelmann, and Wolfgang Ecker. 2024. A Model-Driven Architecture Approach to Accelerate Software Code Generation. In 2024 7th International Conference on Software and System Engineering (ICoSSE). 23–30. https://doi.org/10.1109/ICoSSE62619.2024.00012 [7] David Bingham Brown, Michael Vaughn, Ben Liblit, and Thomas Reps. 2017. The Care and Feeding of Wild-Caught Mutants. (2017). https://doi.org/10.1145/ 3106237.3106280 [8] Sicong Cao, Xiaobing Sun, Xiaoxue Wu, David Lo, Lili Bo, et al. 2024. Snopy: Bridging Sample Denoising with Causal Graph Learning for Effective Vulnerability Detection. In 2024 39th IEEE/ACM International Conference on Automated Software Engineering (ASE). 606–618. [9] Yizhou Chen, Zeyu Sun, Zhihao Gong, and Dan Hao. 2024. Improving Smart Contract Security with Contrastive Learning-based Vulnerability Detection. In Proceedings of the IEEE/ACM 46th International Conference on Software Engineering (ICSE ’24). Association for Computing Machinery, New York, NY, USA, Article 156, 11 pages. https://doi.org/10.1145/3597503.3639173 [10] Zimin Chen, Steve Kommrusch, Michele Tufano, Louis-Noel Pouchet, Denys Poshyvanyk, et al. 2021. SequenceR: Sequence-to-Sequence Learning for Endto-End Program Repair . IEEE Transactions on Software Engineering 47, 09 (Sept. 2021), 1943–1959. https://doi.org/10.1109/TSE.2019.2940179 [11] Matteo Ciniselli, Nathan Cooper, Luca Pascarella, Denys Poshyvanyk, Massimiliano Di Penta, et al. 2021. An Empirical Study on the Usage of BERT Models for Code Completion. 2021 IEEE/ACM 18th International Conference on Mining Software Repositories (MSR) (2021), 108–119. https://api.semanticscholar.org/ CorpusID:232222637 [12] Alan Dorin and Susan Stepney. 2024. What Is Artificial Life Today, and Where Should It Go? Artificial Life 30, 1 (02 2024), 1– 15. https://doi.org/10.1162/artl_e_00435 arXiv:https://direct.mit.edu/artl/articlepdf/30/1/1/2354665/artl_e_00435.pdf [13] Shihan Dou, Yan Liu, Haoxiang Jia, Limao Xiong, Enyu Zhou, et al. 2024. StepCoder: Improve Code Generation with Reinforcement Learning from Compiler Feedback. https://doi.org/10.48550/arXiv.2402.01391 arXiv:2402.01391 [cs]. [14] S.G. Eick, T.L. Graves, A.F. Karr, J.S. Marron, and A. Mockus. 2001. Does code decay? Assessing the evidence from change management data. IEEE Transactions on Software Engineering 27, 1 (2001), 1–12. https://doi.org/10.1109/32.895984 [15] Hadeel Eladawy, Claire Le Goues, and Yuriy Brun. 2024. Automated Program Repair, What Is It Good For? Not Absolutely Nothing!. In Proceedings of the IEEE/ACM 46th International Conference on Software Engineering (ICSE ’24). Association for Computing Machinery, New York, NY, USA, Article 84, 13 pages. https://doi.org/10.1145/3597503.3639095 [16] Yujia Fan, Sinan Wang, Zebang Fei, Yao Qin, Huaxuan Li, et al. 2024. Can Cooperative Multi-Agent Reinforcement Learning Boost Automatic Web Testing? An Exploratory Study. In 2024 39th IEEE/ACM International Conference on Automated Software Engineering (ASE). 14–26. [17] Martin Gruber, Muhammad Firhard Roslan, Owain Parry, Fabian Scharnböck, Phil McMinn, et al. 2023. Do Automatic Test Generation Tools Generate Flaky
Conference acronym ’XX, June 03–05, 2018, Woodstock, NY
Tests? arXiv:cs.SE/2310.05223 https://arxiv.org/abs/2310.05223 [18] Mark Harman, S. Afshin Mansouri, and Yuanyuan Zhang. 2012. Search-based software engineering: Trends, techniques and applications. ACM Comput. Surv. 45, 1, Article 11 (Dec. 2012), 61 pages. https://doi.org/10.1145/2379776.2379787 [19] Israel Herraiz, Daniel Rodriguez, Gregorio Robles, and Jesus M. GonzalezBarahona. 2013. The evolution of the laws of software evolution: A discussion based on a systematic literature review. ACM Comput. Surv. 46, 2, Article 28 (Dec. 2013), 28 pages. https://doi.org/10.1145/2543581.2543595 [20] Carlos E. Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, et al. 2024. SWE-bench: Can Language Models Resolve Real-World GitHub Issues? arXiv:cs.CL/2310.06770 https://arxiv.org/abs/2310.06770 [21] Matthew Jin, Syed Shahriar, Michele Tufano, Xin Shi, Shuai Lu, et al. 2023. InferFix: End-to-End Program Repair with LLMs. http://arxiv.org/abs/2303.07263 arXiv:2303.07263 [cs]. [22] Meir Lehman. 1980. Programs, Life Cycles, and Laws of Software Evolution. Proc. IEEE (1980). https://doi.org/10.1109/PROC.1980.11805 [23] Frank D. Macías-Escrivá, Rodolfo Haber, Raul Del Toro, and Vicente Hernandez. 2013. Self-adaptive systems: A survey of current approaches, research challenges and applications. Expert Systems with Applications 40, 18 (2013), 7267–7279. https://doi.org/10.1016/j.eswa.2013.07.033 [24] Pradeep Kumar Mahapatro and Neelamadhab Padhy. 2024. Reviewing the Landscape: Component-Based Software Engineering Practices and Challenges. In 2024 International Conference on Emerging Systems and Intelligent Computing (ESIC). 360–365. https://doi.org/10.1109/ESIC60604.2024.10481576 [25] Antonio Mastropaolo, Simone Scalabrino, Nathan Cooper, David Nader Palacio, Denys Poshyvanyk, et al. 2021. Studying the Usage of Text-To-Text Transfer Transformer to Support Code-Related Tasks. In 2021 IEEE/ACM 43rd International Conference on Software Engineering (ICSE). 336–347. https://doi.org/10.1109/ ICSE43902.2021.00041 [26] Varela Francisco Maturana, Humberto. 1980. Autopoesis and Cognition. 86 pages. [27] William Merrill, Zhaofeng Wu, Norihito Naka, Yoon Kim, and Tal Linzen. 2024. Can You Learn Semantics Through Next-Word Prediction? The Case of Entailment. http://arxiv.org/abs/2402.13956 arXiv:2402.13956 [cs]. [28] Mohamed Wiem Mkaouer, Marouane Kessentini, Mel Cinnéide, Shinpei Hayashi, and Kalyanmoy Deb. 2016. A robust multi-objective approach to balance severity and importance of refactoring opportunities. , 34 pages. https://doi.org/10.1007/ s10664-016-9426-8 [29] Kevin Moran, David N. Palacio, Carlos Bernal-Cárdenas, Daniel McCrystal, Denys Poshyvanyk, et al. 2020. Improving the Effectiveness of Traceability Link Recovery using Hierarchical Bayesian Networks. In 2020 IEEE/ACM 42nd International Conference on Software Engineering (ICSE). 873–885. [30] Manish Motwani and Yuriy Brun. 2023. Better Automatic Program Repair by Using Bug Reports and Tests Together. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE). 1225–1237. https://doi.org/10.1109/ ICSE48619.2023.00109 [31] David Nader-palacio, Daniel Rodríguez-cárdenas, and Jonatan Gomez. 2018. Assessing Single-Objective Performance Convergence and Time Complexity for Refactoring Detection. In Proceedings of the Genetic and Evolutionary Computation Conference Companion on - GECCO ’18. 1606–1613. https://doi.org/10.1145/ 3205651.3208294 [32] John Von Neumann. 1951. The General and Logical Theory of Automata. In Cerebral Mechanisms in Behaviour—The Hixon Symposium, L.A. Jeffress (Ed.). Wiley, New York, NY, USA, 1–41. [33] John Von Neumann. 1966. Theory of Self-Reproducing Automata. University of Illinois Press, Champaign, IL, USA. [34] Leandro Oliveria de Souza, Eduardo Santana de Almeida, Paulo Anselmo da Mota Silveira Neto, Earl T. Barr, and Justyna Petke. 2025. Software Product Line Engineering via Software Transplantation. ACM Trans. Softw. Eng. Methodol. 34, 2, Article 31 (Jan. 2025), 27 pages. https://doi.org/10.1145/3695987 [35] Oluwaseyi Ezekiel Olorunshola and Francisca Nonyelum Ogwueleka. 2022. Review of System Development Life Cycle (SDLC) Models for Effective Application Delivery. In Information and Communication Technology for Competitive Strategies (ICTCS 2020), Amit Joshi, Mufti Mahmud, Roshan G. Ragel, and Nileshsingh V. Thakur (Eds.). Springer Singapore, Singapore, 281–289. [36] Judea Pearl. 2009. Causal inference in statistics: An overview. Statistics Surveys (2009). https://doi.org/10.1214/09-SS057 [37] Jiahao Qiu, Xuan Qi, Hongru Wang, Xinzhe Juan, Yimin Wang, et al. 2025. AlitaG: Self-Evolving Generative Agent for Agent Generation. arXiv:cs.AI/2510.23601 https://arxiv.org/abs/2510.23601 [38] Md Mahbubur Rahman, Ira Ceka, Chengzhi Mao, Saikat Chakraborty, Baishakhi Ray, et al. 2024. Towards Causal Deep Learning for Vulnerability Detection. In Proceedings of the IEEE/ACM 46th International Conference on Software Engineering. 1–11. https://doi.org/10.1145/3597503.3639170 arXiv:2310.07958 [cs, stat]. [39] Václav Rajlich. 2014. Software evolution and maintenance. In Future of Software Engineering Proceedings (FOSE 2014). Association for Computing Machinery, New York, NY, USA, 133–144. https://doi.org/10.1145/2593882.2593893 [40] Buvaneswari A. Ramanan, Manzoor A. Khan, and Abhinav Rao. 2024. ASPIRE: A Multi-Agent Framework for Execution-Free Code Analysis and Repair. In 2024
Conference acronym ’XX, June 03–05, 2018, Woodstock, NY
IEEE International Conference on Big Data (BigData). IEEE, Washington, DC, USA, 8811–8813. https://doi.org/10.1109/BigData62323.2024.10825553 [41] Simone Romano, Christopher Vendome, Giuseppe Scanniello, and Denys Poshyvanyk. 2018. A Multi-study Investigation Into Dead Code. IEEE Transactions on Software Engineering (2018). https://doi.org/10.1109/TSE.2018.2842781 [42] Hiroki Sayama and Chrystopher L. Nehaniv. 2024. Self-Reproduction and Evolution in Cellular Automata: 25 Years After Evoloops. Artificial Life 31, 1 (Feb. 2024), 81–95. https://doi.org/10.1162/artl_a_00451 [43] Saad Shafiq, Atif Mashkoor, Christoph Mayr-Dorn, and Alexander Egyed. 2021. A Literature Review of Using Machine Learning in Software Development Life Cycle Stages. IEEE Access 9 (2021), 140896–140920. https://doi.org/10.1109/ ACCESS.2021.3119746 [44] Haiyang Shen, Yue Li, Desong Meng, Dongqi Cai, Sheng Qi, et al. 2025. ShortcutsBench: A Large-Scale Real-world Benchmark for API-based Agents. https: //doi.org/10.48550/arXiv.2407.00132 arXiv:2407.00132 [cs]. [45] Samiha Shimmi, Hamed Okhravi, and Mona Rahimi. 2025. AI-Based Software Vulnerability Detection: A Systematic Literature Review. https://doi.org/10. 48550/arXiv.2506.10280 arXiv:2506.10280 [cs]. [46] Adriana Meza Soria, Taylor Lopez, Negin Mashhadi, André Van der Hoek, Elizabeth Seero, et al. 2024. Characterizing Software Maintenance Meetings: Information Shared, Discussion Outcomes, and Information Captured. In 2024 IEEE/ACM 46th International Conference on Software Engineering (ICSE). 665–677. https://doi.org/10.1145/3597503.3623330 [47] Adriana Meza Soria, Taylor Lopez, Elizabeth Seero, Negin Mashhadi, Emily Evans, et al. 2024. Characterizing Software Maintenance Meetings: Information Shared, Discussion Outcomes, and Information Captured. In Proceedings of the IEEE/ACM 46th International Conference on Software Engineering (ICSE ’24). Association for Computing Machinery, New York, NY, USA, Article 56, 13 pages. https: //doi.org/10.1145/3597503.3623330 [48] Benjamin Steenhoek, Hongyang Gao, and Wei Le. 2024. Dataflow AnalysisInspired Deep Learning for Efficient Vulnerability Detection. In Proceedings of the IEEE/ACM 46th International Conference on Software Engineering (ICSE ’24). Association for Computing Machinery, New York, NY, USA, Article 16, 13 pages. https://doi.org/10.1145/3597503.3623345 [49] Bruce Toran. 2023. AutoGPT. https://github.com/Significant-Gravitas/AutoGPT [50] Robert R. Tucci. 2013. Introduction to Judea Pearl’s Do-Calculus. (2013). http: //arxiv.org/abs/1305.5506 [51] Michele Tufano, Fabio Palomba, Gabriele Bavota, Rocco Oliveto, Massimiliano Di Penta, et al. 2017. When and Why Your Code Starts to Smell Bad (and Whether the Smells Go Away). IEEE Transactions on Software Engineering 43, 11 (2017), 1063–1088. https://doi.org/10.1109/TSE.2017.2653105 [52] Michele Tufano, Cody Watson, Gabriele Bavota, Massimiliano Di Penta, Martin White, et al. 2018. An Empirical Investigation into Learning Bug-Fixing Patches in the Wild via Neural Machine Translation. In ASE 2018. 831–836. https://doi. org/10.1145/3238147.3240732 [53] Watson C Bavota G Di Penta M White M Tufano M. and D Poshyvanyk. 2018. An Empirical Investigation into Learning Bug-Fixing Patches in the Wild via Neural Machine Translation. In Proceedings of 33rd IEEE/ACM International Conference on Automated Software Engineering (ASE’18) (ASE ’18). Montpellier, France. [54] Watson C Bavota G Di Penta M White M Tufano M. and D Poshyvanyk. 2018. Deep Learning Similarities from Different Representations of Source Code. In Proceedings of the 15th IEEE/ACM Conference on Mining Software Repositories (MSR’18) (MSR ’18). Gothenburg, Sweden. [55] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, et al. 2023. Attention Is All You Need. arXiv:cs.CL/1706.03762 https://arxiv.org/abs/ 1706.03762 [56] Alejandro Velasco, Aya Garryyeva, David N. Palacio, Antonio Mastropaolo, and Denys Poshyvanyk. 2025. Toward Neurosymbolic Program Comprehension. https://doi.org/10.48550/arXiv.2502.01806 arXiv:2502.01806 [cs]. [57] Shuai Wang, Pei Wang, and Dinghao Wu. 2017. Semantics-aware machine learning for function recognition in binary code. In Proceedings - 2017 IEEE International Conference on Software Maintenance and Evolution, ICSME 2017. https://doi.org/10.1109/ICSME.2017.59 [58] Xingyao Wang, Yangyi Chen, Lifan Yuan, Yizhe Zhang, Yunzhu Li, et al. 2024. Executable Code Actions Elicit Better LLM Agents. arXiv:cs.CL/2402.01030 https://arxiv.org/abs/2402.01030 [59] Yuxiang Wei, Olivier Duchenne, Jade Copet, Quentin Carbonneaux, Lingming Zhang, et al. 2025. SWE-RL: Advancing LLM Reasoning via Reinforcement Learning on Open Software Evolution. arXiv:cs.SE/2502.18449 https://arxiv.org/ abs/2502.18449 [60] Martin White, Michele Tufano, Matías Martínez, Martin Monperrus, and Denys Poshyvanyk. 2019. Sorting and Transforming Program Repair Ingredients via Deep Learning Code Similarities. In 2019 IEEE 26th International Conference on Software Analysis, Evolution and Reengineering (SANER). 479–490. https: //doi.org/10.1109/SANER.2019.8668043 [61] Martin White, Michele Tufano, Christopher Vendome, and Denys Poshyvanyk. 2016. Deep learning code fragments for code clone detection. In Proceedings of the 31st IEEE/ACM International Conference on Automated Software Engineering -
Rodriguez-Cardenas et al.
ASE 2016. https://doi.org/10.1145/2970276.2970326 [62] Zhaofeng Wu, Linlu Qiu, Alexis Ross, Ekin Akyürek, Boyuan Chen, et al. 2024. Reasoning or Reciting? Exploring the Capabilities and Limitations of Language Models Through Counterfactual Tasks. https://doi.org/10.48550/arXiv.2307.02477 arXiv:2307.02477 [cs]. [63] Blaise Agüera y Arcas, Jyrki Alakuijala, James Evans, Ben Laurie, Alexander Mordvintsev, et al. 2024. Computational Life: How Well-formed, Self-replicating Programs Emerge from Simple Interaction. arXiv:cs.NE/2406.19108 https: //arxiv.org/abs/2406.19108 [64] John Yang, Carlos E. Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, et al. 2024. SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering. arXiv:cs.SE/2405.15793 https://arxiv.org/abs/2405.15793 [65] Yulong Ye, Tao Chen, and Miqing Li. 2025. Distilled Lifelong Self-Adaptation for Configurable Systems. arXiv:cs.SE/2501.00840 https://arxiv.org/abs/2501.00840 [66] Quanjun Zhang, Chunrong Fang, Yang Xie, Yaxin Zhang, Yun Yang, et al. 2024. A Survey on Large Language Models for Software Engineering. arXiv:cs.SE/2312.15223 https://arxiv.org/abs/2312.15223 [67] Wenkang Zhong, Chuanyi Li, Kui Liu, Tongtong Xu, Jidong Ge, et al. 2024. Practical Program Repair via Preference-based Ensemble Strategy. In Proceedings of the IEEE/ACM 46th International Conference on Software Engineering (ICSE ’24). Association for Computing Machinery, New York, NY, USA, Article 5, 13 pages. https://doi.org/10.1145/3597503.3623310