Open Source is one person

Has anyone seen any stats on what happens to a single maintainer project when said person is hit by a bus (or meets some other demise)? With that many data points, there should be enough of them by now to study it.

Is the project taken over by another, single developer? Is it replaced by a similar project? Does it just go away?

I would love to see a diligently researched episodic series, every episode covering the transition of a popular open-source library/tool/app/site from one maintainer to the next.

And that's why I don't run Netflix.

No, but I would happily pirate that.

Closest example I could think of would be Hans Reiser/Reiserfs. It's a more sordid story than just getting hit by a bus, though. Ultimately the project just died.

I think this is in the realm of a YouTube series. I mean, what's stopping you from doing it?

I don't think this is a good example though as the "sordid" part also made the project toxic for anything that might have otherwise chosen to take it on.

I think this is one thing that people fail to consider: if the code is open source, though it may take time to understand, worst case scenario you can just fork it.

Here is one data point.

I bought ASIO Link Pro (software) something like 10 years ago to help route virtual audio devices on my system. The author sadly died and eventually the license key server went offline rendering it unable to start. His nephew looked into it and eventually made the tool free after a year or 2.

I stopped using it after the license server went offline because I still had to record videos. I ended up solving my problem with hardware, but that tool was extremely helpful when I used it for years. It was around $40 at the time. It's one of the few pieces of software I've purchased and felt really happy about it.

Unless something changes in the underlying infrastructure, most packages don't need active maintenance after achieving their objective.

If there is a major change (e.g., Python 3, React Native new arch), they are replaced/forked.

Not sure if you know or not, or if it matters anymore, but someone eventually made a fix for this.

https://github.com/DirkoAudio/ASIOLinkProFIX

I've been using it for over a year on Windows 10 and it works great.

I suspect this is the case for the majority of open source software. I have a handful of tiny projects. I don't think anyone will keep them alive after I die. But I guess we should make a distinction based on popularity or something. My top four projects have only 675, 363, 122, and 96 stars.

You should pitch this to David Gelb / whoever is responsible for Chef’s Table on Netflix

The ones that come to mind are

- Hans Reiser, maintainer of ReiserFS. I think very few people use ReiserFS these days.

- Ian Murdock, creator of the Debian distribution. Debian lives on, but the project was also set up specifically to distribute maintenance.

- Jim Weirich, creator of the Rake build tool. I'm not a Rubyist so I don't know how it was affected, but I assume it's such a big part of Ruby other people took over.

- Peter Hintjens, co-creator of ZeroMQ. From what I understand, Hintjens was never the main developer but an active promoter. The project lives on as far as I know.

- Terry Davis, creator of TempleOS. I think development on TempleOS stopped.

I don't know about any broader statistics, but in my personal experience, I see all three of those. I think it's mostly a function of how large the user base is, how complicated the code base is, and whether or not there are any substitutes.

Other than it being a lot of work?

IMO, it has a lot to do with usage and the availability of alternatives. With ReiserFS, there were a lot of alternatives, both available at the time or announced shortly. While ReiserFS pioneered a lot of ideas, many of them showed up in alternatives fairly quickly. TempleOS is had a pretty limited user base.

I’ve seen many projects in the Clojure ecosystem get picked up and maintained by other folks. The key was always that the projects had an established user base of some notable size and something distinctive about them that made switching to other alternatives less desirable than continuing to push forward with a new and possibly more mundane maintainer and feature schedule. I’ve also seen a lot of “abandonware.”

So, it’s a bit of a mixed bag.

It depends. More common than getting hit by a bus is that the maintainer loses interest, or doesn't have the time to put into it anymore. When that happens I've seen all of the following happen:

* Someone forks the project, and eventually the fork replaces the original

* Another, possibly new, project that fills the same niche becomes more popular, and eventually replaces most usages of the first project.

* The original maintainer hands off maintenance to someone else.

* People keep using it, even though it is no longer maintained, and maybe make their own forks to fix issues they have, but none of the forks really catch on

One of the strengths of OSS is that if the developer disappears, or goes rogue, or changes the license terms, someone can fork the project and keep it going. With proprietary software, if the company (or individual) who makes it disappears, or decides to discontinue it, or change the terms to something unacceptable, you are just out of luck. Hopefully, you can find a competing product that meets your needs.

If it's open-source, and the original breaks for any reason, it's typically forked and continues life. See: Redis (recently).

This is theory

Any maintainer pairs want to reach out? I'll give it a shot.

Definitely seen this a lot in the JS/NPM ecosystem... You go searching for a module that does $thing... you find about 10, you sort and look at say the 3 most recently published an the 3-5 most downloaded/popular... is the repo open (github, usually), are there a lot of old issues left lingering with an old last publish date? Might take a passive look at the codebase to see if I can grok it and fix any issues I find if needed.

Choose what I feel is the best option. Trying to avoid dead packages, but not afraid to deal with older packages if they aren't just stale, but functionally complete. The shift towards ES import statements and TypeScript defs has also influenced my selection process.

I've seen plenty of cases where either a fork or new option effectively takes over. A lot of people are leaning towards Zod over Yue or Hono over Express. There's instances where the dev goes off the rails like with Faker and the community comes together to fork a solution.

All of the above examples definitely happen in practice. I'm guessing many packages all over the place have replaced various dependencies over the years.

When Bram passed away Vim was passed on to the core maintainers there.

Reiserfs died because alternatives, like ext3/ext4 and btrfs, became readily available.

TempleOS has a fork called ZealOS. Terry Davis really was the "Wesley Willis of programming", and he had friends and fans worldwide, some of whom have taken up TempleOS development under the ZealOS banner.