Traditional software is "static and bullheaded." As Barak A. Pearlmutter argues in Automatic Differentiation and Ubiquitous Adaptive Computing, most systems are built to perform a fixed set of functions in a predictable environment. When the world changes—whether through shifting user goals, new organizational requirements, or "unknown unknowns"—these systems typically require manual reconfiguration or complete redesign.
A growing body of research proposes a shift from software as a rigid tool to software as a living organism. This direction, often termed Lifelong Computing or Continuous Evolution, focuses on systems that autonomously reorganize their own internal logic and architecture to survive in chaotic, interconnected environments.
From Parameter Tuning to Structural Evolution
Most "adaptive" systems today rely on parameter tuning—adjusting a few pre-defined knobs to optimize performance. However, Danny Weyns and colleagues argue in Lifelong Computing that true autonomy requires structural evolution.
Instead of just changing a numerical value, a lifelong computing system might:
- Discover new modules from a "computing warehouse."
- Replace its own core components when they no longer align with environmental demands.
- Reconfigure its architectural topology to handle unanticipated changes that the original designers never envisioned.
This moves the system beyond simple self-optimization into the realm of self-composition, where the software's "DNA" is not a fixed script but a dynamic blueprint.
Architecture as a Continuous Process
In the traditional software lifecycle, "architecture" is a phase that happens at the beginning. Once the system is built, the architecture is effectively frozen. Alessio Bucaioni, David Lo, and their co-authors suggest in Artificial Intelligence for Software Architecture that this approach is obsolete. They advocate for continuous architectural evolution, where AI-driven collaborators monitor system performance in real-time to provide dynamic design refinements.
This perspective is echoed by Evgeny Knutov and Paul De Bra in their work on the Generic Adaptation Process (GAP). They argue that we should design systems based on the sequence of operational steps (the process) rather than static data structures. By prioritizing the functional flow of adaptation, the system's layers can couple and decouple according to real-time interaction needs.
Differentiable Programming and Internal Optimization
How does a system "know" how to evolve? One promising mechanism is pushing optimization loops directly into the programming language itself. Barak A. Pearlmutter suggests that differentiable programming—using automatic differentiation to calculate gradients through complex code structures like loops and recursion—allows software to minimize its own "error" or "cost" relative to its environment.
When software can differentiate through its own execution, it becomes an adaptive agent. It doesn't just follow instructions; it seeks the most efficient path to a goal, evolving its behavior as the "landscape" of that goal shifts.
The Bio-Inspired Shift: Software as Internetware
This movement toward autonomous evolution draws heavy inspiration from biological and social systems. Tao Xie, Gang Huang, and others describe this as the era of Internetware—software that is situated, autonomous, and evolvable. As noted in their Preface to the Journal of Computer Science and Technology, these systems must coordinate third-party services and navigate environmental uncertainty without human intervention.
The intuition here is similar to Architectural Typology in vernacular buildings. As Wenbin Liu explains in Discussion on the Vernacular Architecture Construction, traditional buildings survive not by being static monuments, but by maintaining a core "DNA" or logic while their physical forms are continuously transformed to meet new needs.
Similarly, researchers like Eugenio Maria Battaglia and Guillaume Dumas propose coadaptive metadesign in Systems of Global Governance. They argue that for systems to handle high complexity, they must be open-ended frameworks where the system and its users evolve together through continuous feedback loops, reorganizing internal logic rather than adhering to top-down, static rules.
Summary of the Intuition
The shift toward continuous structural evolution can be summarized as follows:
- From Static to Situated: Software is no longer a standalone tool but an entity "situated" in a changing environment.
- From Design-Time to Run-Time: Architectural decisions are moved from the initial development phase to the execution phase.
- From Tuning to Transformation: Adaptation is not just about changing variables; it is about changing the system's fundamental structure and logic to meet "unknown unknowns."