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

still a working view ended · each leads to its entry below

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

  1. Software evolution (introduction, General introduction, Lehman's Laws of Software Evolution), Wikipedia
  2. Waterfall model (introduction, History), Wikipedia
  3. Software configuration management, Wikipedia
  4. Technical debt (Origin, introduction), Wikipedia
  5. 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.

  1. 1970-1995
  2. 1972-Present
  3. 1974-2000

    Lehman's Laws of Software Evolution

    What regularities govern how software changes over time?

    Fly to its tower in Nousfarer

  4. 1976-Present

    Software metric

    How can we measure the quality of code?

    Fly to its tower in Nousfarer

  5. 1992-Present

    Technical Debt

    What is the cost of taking shortcuts now?

    Fly to its tower in Nousfarer

  6. 1993-Present

    Software Architecture Evolution

    What large-scale structure lets a system keep changing?

    Fly to its tower in Nousfarer

  7. 1999-Present

    Code refactoring

    How can we improve code without changing behavior?

    Fly to its tower in Nousfarer

  8. 2001-Present

    Agile and Continuous Delivery

    How can teams deliver change quickly and reliably?

    Fly to its tower in Nousfarer

  9. 2004-Present

    Mining Software Repositories

    What can past change histories tell us about software?

    Fly to its tower in Nousfarer

  10. 2009-Present

    Automatic bug fixing

    Can machines fix defects without people?

    Fly to its tower in Nousfarer

  11. 2009-Present

    DevOps

    How can building and running software work as one?

    Fly to its tower in Nousfarer

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.

Software Maintenance and Life-Cycle C…Software Configuration ManagementLehman's Laws of Software EvolutionSoftware metricTechnical DebtSoftware Architecture EvolutionCode refactoringAgile and Continuous DeliveryMining Software RepositoriesAutomatic bug fixingDevOps

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.

A city in Nousfarer: a red-carpeted stair climbing terraces to a crowned tower on an acropolis, more towers round it, forest and snowy mountains beyond.
A city in Nousfarer, the game played in the browser.

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 Evolution

Related fields

Fields its ideas are linked to

More in Software Engineering

See where Software Evolution sits on the Map of Human Knowledge