- Atlas
- Computer Science
- Software Evolution
Software Evolution
Software is one of the few things people build that is expected to keep changing after it is "finished." A bridge, once opened, is maintained but not redesigned; a program, once shipped, is routinely altered for years or decades—to fix defects, add features, move to new hardware, or satisfy new users.
11 frameworks, from 1970 to today · Software Engineering · Computer Science
- Software Maintenance and Life-Cycle Cost Model 1970-1995
- Software Configuration Management 1972-Present
- Lehman's Laws of Software Evolution 1974-2000
- Software metric 1976-Present
- Technical Debt 1992-Present
- Software Architecture Evolution 1993-Present
- Code refactoring 1999-Present
- Agile and Continuous Delivery 2001-Present
- Mining Software Repositories 2004-Present
- Automatic bug fixing 2009-Present
- DevOps 2009-Present
Overview
Software is one of the few things people build that is expected to keep changing after it is "finished." A bridge, once opened, is maintained but not redesigned; a program, once shipped, is routinely altered for years or decades—to fix defects, add features, move to new hardware, or satisfy new users. Software evolution is the subfield of software engineering that studies this long, ongoing life of software: how systems change over time, why change is so expensive, and what techniques let teams make changes safely and sustainably1. Its central insight is that most of the cost and risk of a large system lies not in building it the first time but in everything that happens afterward1. The history of the field is a sequence of attempts to understand, measure, and tame that change.
Maintenance as the Dominant Cost
The field's founding observation was economic. In the 1960s and 1970s, as large systems such as operating systems and business applications accumulated, practitioners noticed that the bulk of effort went into modifying existing code rather than writing new code. A widely cited 1970s study by Barry Boehm and others put maintenance at roughly half or more of total life-cycle cost, and later surveys often pushed the figure higher. "Maintenance" here did not mean only repair: it covered correcting faults, adapting software to new environments, and—most of all—perfecting it with new features.
This reframing mattered because it changed what "maintenance" meant. The older hardware analogy suggested a passive, degrading activity. Software maintenance was recognized instead as continued development. In 1980 the IEEE published a standard (later revised) that sorted maintenance into categories still taught today: corrective (fixing bugs), adaptive (responding to changed environments), perfective (improving performance or adding features), and preventive (making future changes easier). The perfective category alone typically accounted for the largest share, which is why some writers argued the word "maintenance" was misleading and "evolution" better captured what actually happened.
Life-Cycle Models and the Problem of the "Finished" System
Classical process models—the waterfall model, formalized in the 1970s—assumed a project with a beginning and an end: requirements, design, implementation, testing, delivery2. That shape fit one-off construction but not software that lived on. The spiral model, described by Boehm in 1988, was an early response: it organized development as repeated cycles of risk analysis and prototyping, implicitly acknowledging that systems are built in increments and revisited.
The deeper challenge was that a system's structure tends to degrade as it is changed. Each modification made without regard to the overall design leaves the code further from the clean architecture it started with. This is the phenomenon later called software aging or design decay: the system still works, but every further change costs more. Life-cycle thinking therefore shifted from "how do we finish this project?" to "how do we keep this system healthy across many releases?" That question connects directly to the field's later ideas about architecture and technical debt.
Lehman's Laws: Change as a Lawful Process
The most influential attempt to make evolution a science came from Meir Lehman, who studied the successive releases of IBM's OS/360 and later large systems. Beginning with a 1974 paper and refined through the 1970s and 1980s (often with Laszlo Belady and later W. M. Turski), Lehman proposed that evolving software obeys regularities—"laws" in the sense of empirically observed tendencies, not physical necessity.
The best known are: that a system used in a real environment must be continually adapted or it becomes progressively less satisfactory; that as it evolves its complexity increases unless work is done to maintain or reduce it; that its evolution tends to follow a self-regulating pattern with recognizable trends in attributes such as size and release interval; and that the rate of progress of a system's evolution is roughly constant, so the amount of change per release is limited. A further law holds that the quality of a system declines unless it is rigorously maintained and adapted to its environment1.
The practical force of these ideas is the "complexity" law. A concrete illustration: a system whose modules were once cleanly separated gradually accumulates cross-dependencies as features are added, until a change in one place breaks something elsewhere. Lehman's work gave the field a vocabulary for treating evolution as a process to be managed rather than a series of accidents, and it motivated later empirical work measuring growth, change rates, and decay.
Configuration Management: Keeping Track of What Changed
None of this is possible without knowing what the system is at any moment. Software configuration management (SCM) is the discipline of identifying the components of a system, controlling changes to them, and recording their states over time3. Its roots are in the 1970s, when tools such as SCCS (Source Code Control System, developed at Bell Labs in the early 1970s) introduced versioned source files. RCS followed in the early 1980s, and CVS in the late 1980s extended version control to whole projects with branching and merging.
SCM grew into more than version control: it covers build management, release management, and the tracking of which versions of which components make up a delivered product (the "configuration"). The reason it belongs to the history of evolution is that evolution is change over time, and SCM is the machinery that makes change traceable and reversible. Without it, a team cannot answer "what did this look like before the last change?"—the basic question of any evolutionary practice.
Measuring Code: Metrics, Smells, and Refactoring
If complexity grows, it should be measurable. The 1970s and 1980s produced a family of software metrics—quantitative measures of code and design. Maurice Halstead's "software science" (1970s) counted operators and operands to estimate volume and effort. Thomas McCabe's cyclomatic complexity (1976) measured the number of independent paths through a program, giving a simple proxy for how hard code is to test and understand. Object-oriented metrics followed in the 1990s, notably the Chidamber–Kemerer suite, which measured coupling, cohesion, and inheritance depth.
Metrics alone did not tell developers what to fix. The idea of code smells—surface patterns in code that suggest deeper design problems, such as duplicated code, long methods, or classes that know too much about each other—was popularized by Kent Beck and Martin Fowler in the late 1990s. The remedy was refactoring: restructuring code without changing its external behavior, in small, safe steps. Fowler's 1999 book Refactoring catalogued specific transformations (extract method, move field, replace conditional with polymorphism) and tied them to the smells they cured. Refactoring gave evolution a discipline: instead of letting decay accumulate, a team could continuously improve structure while preserving behavior, backed by tests that catch accidental changes. It became a cornerstone of the agile movement that followed.
Architecture and the Long View
Some changes are too large for local refactoring. Software architecture—the large-scale structure of a system: its components, their responsibilities, and how they connect—turned out to be the main determinant of what a system can and cannot evolve into. A design decision made early, such as a monolithic database shared by every module, can make later changes cheap or nearly impossible.
The field's attention to architecture grew through the 1990s, with architectural styles and patterns, and with the recognition that architecture itself evolves. Researchers studied how architectures drift from their intended design and how to detect and repair that drift. The practical lesson, echoed in later work on architecture tradeoffs, is that evolvability is an architectural quality: it must be designed in, and it constrains which future changes are affordable.
Technical Debt: A Metaphor That Stuck
In 1992 Ward Cunningham coined a metaphor that reshaped how practitioners talk about evolution4. Shipping code with known shortcuts is like taking on technical debt: you get the feature sooner, but you pay interest later in the form of extra effort for every subsequent change, and eventually you must repay the principal by cleaning up4. The metaphor's power is that it makes the tradeoff explicit and negotiable—some debt is a sensible investment, some is reckless.
The idea spread widely in the 2000s and 2010s, and researchers worked to make it measurable, linking debt to code smells, to architectural shortcuts, and to the cost of change. It gave managers a language for a problem engineers had long felt: that the fastest way to ship today is often the slowest way to ship next year.
Mining the Repository: Evolution Becomes Empirical
A decisive shift came when researchers realized that version-control histories are a vast record of evolution itself. Mining software repositories (MSR) is the practice of extracting and analyzing data from source-control systems, bug trackers, and build logs to study how software actually changes. The field crystallized in the early 2000s; the first International Workshop on Mining Software Repositories was held in 2004, and it became an annual conference.
MSR made questions empirical. Which files change most often? Do files that change together also tend to contain bugs together? A well-known line of work found that code churn and change frequency predict defects better than sheer size. Another found that "copy-paste" duplication and certain change patterns correlate with faults. The approach also enabled the study of code clones and their evolution, and gave the field large-scale evidence for or against earlier theories—including tests of Lehman's laws on many systems. MSR is the empirical backbone of modern software evolution research: it turned anecdotes about decay into measurable regularities.
Agile, Continuous Delivery, and DevOps: Evolution as the Normal State
The process side of the field changed just as dramatically. The agile movement, crystallized in the 2001 Agile Manifesto, rejected the assumption that a system is specified once and built once. Agile methods—Scrum, Extreme Programming—organized work into short iterations with working software at each step, making change the expected input rather than a disruption. Extreme Programming in particular paired refactoring with automated testing and continuous integration, so that the code could be reshaped continuously without breaking.
Continuous delivery, articulated by Jez Humble and David Farley in their 2010 book, extended this to the release process: keep software in a state where it can be deployed at any time, through automated build, test, and deployment pipelines. DevOps, emerging around 2009, merged development and operations so that the people who change software also run it, shortening the feedback loop between a change and its consequences in production5. These practices made evolution continuous rather than episodic: instead of large, risky releases, systems change in many small, verified steps. They descend directly from the field's oldest insight—that change is the dominant activity—and turn it into an operating principle.
Automated Change and the Present
The newest turn is automation of change itself. Automated program repair uses search or constraint-solving to generate candidate patches for defects, then tests them against a suite; the field took off in the late 2000s and 2010s, with techniques that mutate existing code or synthesize fixes from templates. More recently, machine-learning models trained on large code corpora—so-called AI-assisted programming tools—can suggest edits, completions, and refactorings. These are early and imperfect, but they point toward a future in which some evolutionary changes are proposed by tools rather than written by hand.
Today the field's main strands coexist: empirical study through repository mining; measurement through metrics and debt tracking; structural discipline through refactoring and architecture; process discipline through agile, continuous delivery, and DevOps; and increasing automation of change. The open questions are the old ones in new form—how to measure and predict the cost of change, how to keep architecture from drifting, how much debt is acceptable, and how far automated tools can be trusted with the changes that keep long-lived systems alive.
References
- Software evolution (introduction, General introduction, Lehman's Laws of Software Evolution), Wikipedia
- Waterfall model (introduction, History), Wikipedia
- Software configuration management, Wikipedia
- Technical debt (Origin, introduction), Wikipedia
- DevOps (introduction, History), Wikipedia
The frameworks of Software Evolution
Each framework is a way of working the field has used: when it held, and the question it answers.
- 1970-1995
Software Maintenance and Life-Cycle Cost Model
Where does most software cost go over its life?
- 1972-Present
Software Configuration Management
How do we track and control what changed?
- 1974-2000
Lehman's Laws of Software Evolution
What regularities govern how software changes over time?
- 1976-Present
- 1992-Present
- 1993-Present
Software Architecture Evolution
What large-scale structure lets a system keep changing?
- 1999-Present
- 2001-Present
Agile and Continuous Delivery
How can teams deliver change quickly and reliably?
- 2004-Present
Mining Software Repositories
What can past change histories tell us about software?
- 2009-Present
- 2009-Present
How the ideas connect
Each arrow runs from an earlier idea to the later one it shaped. The list below says what passed between them.
Agile and Continuous Delivery influenced by Code refactoring
Refactoring, backed by tests, became a cornerstone practice of agile development and later continuous delivery. The agile movement adopted continuous structural improvement as part of its working rhythm.
Carried by Kent Beck; Martin Fowler; Refactoring (1999).
DevOps grew out of Agile and Continuous Delivery
DevOps grew directly out of agile and continuous delivery, extending their automation and fast feedback from development into operations. Continuous delivery pipelines are the direct ancestor of DevOps practice.
Carried by Jez Humble; Continuous Delivery (2010).
Agile and Continuous Delivery influenced by Software Configuration Management
Continuous delivery depends on version control, branching, build and release management that SCM developed from SCCS and CVS onward. Automated pipelines are SCM's release machinery made routine and fast.
Carried by CVS; Jez Humble; Continuous Delivery (2010).
Mining Software Repositories influenced by Software Configuration Management
Mining software repositories works on the change histories that configuration management systems record. Version-control logs and bug-tracker records are the raw data the field analyzes.
DevOps influenced by Software Configuration Management
DevOps joined SCM's build and release management to operations, treating configuration and deployment as versioned, automated artifacts. The practice grew out of configuration-management tooling extended across the dev/ops boundary.
Mining Software Repositories influenced by Lehman's Laws of Software Evolution
Lehman's laws posed empirical questions about growth, change rates and release intervals that repository mining could test at scale. Mining studies explicitly revisited and revised the laws using version-control data.
Technical Debt influenced by Software metric
Efforts to make technical debt measurable linked it to code smells and to metrics of complexity and coupling. Metrics supplied the quantitative handle the debt metaphor needed to be managed.
Code refactoring influenced by Software metric
Refactoring's code smells are diagnosed with structural measures such as method length, coupling and complexity. Fowler's catalogue tied specific transformations to the metric-visible problems they cure.
Carried by Martin Fowler; Refactoring (1999).
Mining Software Repositories influenced by Software metric
Repository mining correlates code metrics with change and defect data to find which structures predict costly evolution. The metrics developed earlier became the dependent variables of mining studies.
Automatic bug fixing influenced by Mining Software Repositories
Automatic bug fixing learns from the large corpora of past fixes that repository mining assembled. Mined fix patterns and change histories supply the templates repair tools apply to new defects.
Automatic bug fixing influenced by Code refactoring
Automated program repair borrows the idea of behavior-preserving transformation applied under test oracles. Repair tools search over refactoring-like edits, validated by tests, to fix defects automatically.
Beyond the field
Where Software Evolution's ideas came from in other fields, and what they led to there: the strongest 12 of 36 links.
Agile and Continuous Delivery led to Continuous design in Software Architecture
Continuous design extends agile and continuous delivery thinking from code and deployment to architectural decisions, arguing that design too should proceed in small, reversible increments. It grew directly out of the continuous delivery movement's practices of frequent, automated release.
Carried by Jez Humble; David Farley; Continuous Delivery (2010).
Agile and Continuous Delivery influenced DevOps in Devops And Sre
Agile and continuous delivery supplied DevOps with its core practices: cross-functional teams, automated build-test-deploy pipelines and short release cycles. The DevOps movement of 2009 grew directly out of the agile and continuous-delivery community's push to extend those practices into operations.
Carried by Jez Humble; Continuous Delivery (2010); Patrick Debois.
Software Maintenance and Life-Cycle Cost Model influenced by Systems development life cycle in Software Process Models
The systems development life cycle, codified in the late 1960s and 1970s, supplied software engineering with its phase structure of requirements, design, implementation, and maintenance. Maintenance and life-cycle cost models placed maintenance as the final phase of that cycle and costed it accordingly.
Carried by Winston W. Royce; Barry Boehm.
Software Maintenance and Life-Cycle Cost Model influenced by Waterfall model in Systems Engineering
The waterfall model's separation of development into sequential phases, with maintenance as the terminal phase, framed how software maintenance was defined and budgeted. Life-cycle cost models inherited this phase decomposition and attached cost estimates to each stage.
Carried by Winston W. Royce; Barry Boehm.
Software Configuration Management influenced Continuous Integration in Systems Integration
Software configuration management provided version control, change tracking and reproducible builds. Continuous integration built its automated integration on these configuration management practices.
Software metric influenced Capability Maturity Model in Software Engineering
The CMM's assessment and maturity-level scheme rests on measuring process capability, drawing on the software metrics tradition of quantifying process and product attributes. Measurement of process performance became a key process area in the model.
Carried by Watts Humphrey.
Software Architecture Evolution influenced by Architectural Styles in Software Architecture
The architectural-styles work of Garlan and Shaw, cataloguing pipe-and-filter, layered, and blackboard organisations, gave software architecture evolution its units of analysis: styles as recurring structures whose changes can be tracked and compared. Evolution research built directly on that style taxonomy.
Carried by David Garlan; Mary Shaw.
Software Architecture Evolution influenced Continuous design in Software Architecture
Continuous design treats architecture as something that evolves incrementally rather than being fixed up front, taking up the software architecture evolution research tradition on managing and documenting architectural change over time. That body of work supplied the concepts of architectural drift and incremental restructuring that continuous design applies continuously.
Code refactoring influenced by Software Testing in Software Engineering
Refactoring relies on the software testing tradition for its safety argument: the test suite is the oracle that detects behaviour change during restructuring. The refactoring literature took up unit testing frameworks and test-first practice from testing research and practice.
Carried by Kent Beck.
Code refactoring influenced by Regression testing in Software Testing
Refactoring is defined as behaviour-preserving change, and the standard way to establish preservation is to run the existing regression test suite before and after each transformation. The refactoring literature makes regression testing the enabling condition for safe refactoring.
Carried by Martin Fowler; Refactoring (1999).
Code refactoring influenced by Structured Design in Software Engineering
Refactoring's makers drew on structured design's criteria for good modular structure, such as coupling and cohesion, when defining when a restructuring improves design. Opdyke's and later Fowler's work on refactoring explicitly framed behaviour-preserving transformations in terms of these design-quality measures.
Carried by William Opdyke; Martin Fowler; Refactoring (1999).
Agile and Continuous Delivery influenced Continuous Delivery in Software Process Models
Agile and continuous delivery contributed the iterative, automated-release practices that continuous delivery codified into a deployment pipeline. The agile emphasis on short cycles carried into continuous delivery.

Software Evolution is a planet in Nousfarer
Its city has a tower for each of these 11 frameworks. Land, walk in, and climb one concept at a time.
Land on Software EvolutionRelated fields
Fields its ideas are linked to
- Software Engineering 7 links
- Devops And Sre 5 links
- Software Architecture 4 links
- Software Process Models 4 links
- Software Testing 4 links
- Systems Lifecycle 3 links
- Program Analysis 2 links
- Data Science 1 link
- ML Systems 1 link
- Reliability Engineering 1 link
- Organizational Change 1 link
- Project Management 1 link
More in Software Engineering
- Computing Education
- Design Patterns
- Devops And Sre
- Formal Methods
- Open Source Software
- Requirements Engineering
- Software Architecture
- Software Engineering
- Software Process Models
- Software Testing
See where Software Evolution sits on the Map of Human Knowledge