Myth: The loss of core developers is a critical issue for OSS communities

TL;DR

The paper investigates how open-source projects lose or replace core developers by computing the truck factor and detecting TFDD events across 36,464 GitHub projects. Using an established TF algorithm on yearly snapshots, it finds that 89.65% of projects experience at least one TFDD, with 70% of these events occurring within the first three years and many projects relying on a single core developer. Survival after a TFDD is relatively uncommon, with only 27.07% of affected projects attracting new core developers, though some endure multiple TFDD events. Surviving projects tend to be more active and older at the time of TFDD, suggesting greater maturity aids recovery. The findings highlight significant vulnerability in OSS ecosystems and underscore the need for strategies to diversify core maintainership to improve longevity and resilience.

Abstract

Throughout their lifetime, open-source software systems will naturally attract new contributors and lose existing contributors. Not all OSS contributors are equal, however, as some contributors within a project possess significant knowledge and expertise of the codebase (i.e., core developers). When investigating the ability of projects to attract new contributors and how often a project loses contributors, it is therefore important to take into account the expertise of the contributors. Since core developers are vital to the longevity of projects, we therefore aim to find out: can OSS projects attract new core developers and how often do OSS projects lose core developers? To investigate core developer contribution patterns, we calculate the truck factor (or bus factor) of over 36,000 OSS projects to investigate how often TF developers join or abandon OSS projects. We find that 89% of our studied projects have experienced losing their core development team at least once. Our results also show that in 70% of cases, this project abandonment happens within the first three years of the project life. We also find that most OSS projects rely on a single core developer to maintain development activities. Finally, we find that only 27% of projects that were abandoned were able to attract at least one new TF developer. Our analysis shows that it is not uncommon for OSS projects to lose their initial core development team. This is likely due to most OSS project relying on a single core developer to maintain development activities. The first year of development is critical for OSS projects since this is where they are most at risk of losing their core developer(s). Additionally, projects that lose their core developer(s) early seem less likely to survive this event than projects that lost their core developers later on during their life.

Figures (4)

• Figure 1: Year during which projects faced TFDDs (from the initial creation of the project).
• Figure 2: Cumulative percentage of TFDDs that happen within N years.
• Figure 3: Number of TF developers at the time of TFDD.
• Figure 4: Number of commits, files, contributors, and project age (in days) at the time of TFDD between surviving and non-surviving projects.