Modern scientific discovery is fundamentally digital. Across fields as diverse as genomics, neuroimaging, and high-energy physics, progress relies on complex computational pipelines, visualization toolkits, and data manipulation libraries. Yet, while the scientific community depends heavily on this digital infrastructure, the mechanisms used to build and maintain it are profoundly fragile.
This tension creates the research software sustainability gap: a systemic vulnerability where critical scientific tools degrade, become obsolete, or disappear entirely. To understand why this gap exists—and how the community is working to close it—we must look at the misalignment between the lifecycle of software and the incentives of traditional academia.
The Lifecycle Paradox of Scientific Software
In commercial software engineering, the launch of a product is merely the beginning of its lifecycle. Software requires continuous energy input to combat "bit rot"—the gradual loss of functionality that occurs as underlying operating systems, dependencies, and hardware environments evolve.
In academia, however, software development is governed by a different set of physics. Academic structures are optimized for discrete bursts of novelty rather than continuous maintenance. As Way et al. observe, scientific software is frequently treated as a temporary byproduct of a specific publication rather than a durable research output. Once the primary paper is published, the institutional energy shifts elsewhere.
This structural friction manifests as two primary failure modes:
- The Funding Mismatch: Traditional research grants are designed to fund novel, short-term projects. As Salmon points out, initial grants routinely cover the development of a new tool but fail to provide for its long-term maintenance. This leaves essential community tools stranded without financial support once their initial funding cycle concludes (Poldrack et al.; Ye et al.).
- The Personnel Turnover Trap: Academic research groups operate on high rates of student and postdoc turnover. Yee et al. and Sonnenburg et al. note that when the primary student or developer leaves a research group, the technical expertise required to maintain the software leaves with them.
The result is a proliferation of "abandonware"—prototypes and specialized web servers that become non-functional or inaccessible shortly after publication, hindering reproducibility and stalling downstream research (Bruneliere et al.; Stoltzfus et al.; Liu). This pattern is visible even during global crises; an empirical study by Wang found that open-source software projects initiated during emergencies often exhibit an intense burst of initial development followed by immediate stagnation, leaving critical digital infrastructure unmaintained.
[Grant Awarded] ──> [Prototype Built] ──> [Paper Published] ──> [Student Graduates]
│
▼
[Software Rot]
From Single-Lab Artifacts to Shared Ecosystems
Why do some tools survive while others decay? The distinction lies in the transition from an isolated, single-laboratory tool to a community-driven ecosystem.
When software remains confined to the laboratory that created it, its survival is tied entirely to that lab's immediate funding and focus (Stajich et al.). To achieve long-term viability, software must cultivate a distributed contributor base. Royer et al. demonstrate that entire scientific subfields can accelerate rapidly when propelled by open-source software frameworks that lower the barrier to entry for new users and contributors.
However, building a collaborative ecosystem requires deliberate design. It demands moving away from "one-off" scripts toward standardized data structures, comprehensive documentation, and containerization (Poldrack et al.; Fu et al.). Without community-contributed examples, diagnostic tools, and clear integration pathways, specialized software cannot successfully transition to a broader user base (Duck et al.; D’Aquino et al.).
Realigning Incentives and Roles
Resolving the sustainability gap requires changing the underlying economics and incentives of academic software production. Several structural interventions have emerged to address this:
Formal Academic Credit for Software
If researchers are evaluated solely on journal citations, they cannot afford to spend time refactoring code or fixing bugs. To fix this, Sonnenburg et al. successfully proposed the Journal of Machine Learning Research Machine Learning Open Source Software (MLOSS) track. By creating a formal venue where software contributions receive peer-reviewed academic credit, developers can justify the time spent on engineering quality and maintenance.
Institutionalizing the Research Software Engineer (RSE)
Relying on transient graduate students to build production-grade scientific software is a structural mismatch. Deschamps et al. argue for embedding professional Research Software Engineers (RSEs) directly into institutional core facilities. Furthermore, Agapopoulou et al. and Ye et al. emphasize that universities must establish formal, stable career paths and tenure-track opportunities for software specialists. Without these roles, academia will continue to lose the technical expertise required to manage increasingly complex data pipelines.
Software Engineering as a Service (SEAS)
Interdisciplinary research teams often lack dedicated DevOps support, making it difficult to monitor software health over time. To lower this operational burden, Thiruvathukal et al. propose a "Software Engineering as a Service" (SEAS) model. By leveraging automated metrics—such as defect density and issue tracking—teams can systematically monitor the health and maintainability of their software without requiring deep software engineering expertise.
Ultimately, closing the research software sustainability gap requires recognizing that software is not a static product of research, but the dynamic infrastructure upon which modern research is built.
Key Foundational Work
SIGIR06 workshop report: Open Source Information Retrieval systems (OSIR06) (2006) — contributed 2 concept elements to this direction.
The Bioperl Toolkit: Perl Modules for the Life Sciences (2002) — contributed 1 concept elements to this direction.