Software Actually Dies Because of External Factors Not Natural Causes

People are often surprised to know that a software development project is never really finished when they ask me, “are you close to done” or “you still have a feature to implement on this project.” The reality is, unlike other industries, software never dies, not by itself at least.

Software Evolves

There is something different about software. They aren’t a fixed set of specifications that are fixed at the beginning of the project and followed during the whole development. It’s not like a house that doesn’t evolve much once finished or a cake that cannot be tested by the baker that cooked it.

It’s possible that the vision of the team evolved while working on the project or that a specific type of customer started using the software, shifting the focus to new features that wouldn’t have been developed otherwise.

On top of that, there is always a lot of improvements that can be made. I never encountered a codebase (in my short career) that was clean and didn’t need refactoring, optimizing, or libraries change.

Finally, all the bugs must be fixed. There is always something that breaks and, depending on the size of the project, might require a whole team to make sure that the service is working perfectly.

All those elements make it hard, if not impossible, to know or to tell when a project is finished. This raises the question: What is a finished project?

Definition of Done

The Agile Alliance defines the definition of done as follows: “a list of criteria which must be met before a product increment ‘often a user story’ is considered ‘done’.”. This is done at a very granular level. Let’s try to define the “Definition of Done” for software.

• Works flawlessly, everything works fine, and no further improvement or bug fixing is required.
• The team’s vision is reached, the team decides that the project has reached maturity and no new features will be implemented.
• Boredom of the team or the developer, this can happen in a smaller or one-person team. The projects aren’t as motivating as before or require too much time, and development is halted.
• High maintenance cost, sometimes choices made in the past can result in projects that are hard, if not impossible, to maintain. This is why pulling the plug might be the only solution.
• Competitors won the market, a new company release a product that simply wipes the market and everybody stops using your software.
• Lack of funding, this can take many forms. An investor exciting, a lack of workforce, other priorities are forcing the team to work on other projects, … An application requires significant funds, and lacking them can spell the end of the project.

Note that unlike the classical Definition of Done, only one of the elements can halt the development. Furthermore, the elements discussed define the end of a project, not its failure, which can be caused by other factors.

Immortal Software: Microsoft Word

I remember using Microsoft Word when I was a kid, creating spectacular pages with WordArt, or writing some of my thought on a file that I will never open again.

It’s crazy to imagine that Word is 37 years and that it’s still actively developed.
Word was initially developed for the Xenix (never heard of this OS before) and MS-DOS. Since then, Word can run on most modern operating systems and on the web. The IT landscape was completely different at the time, and Word evolved with it, supporting a new platform, adapting its UI/UX, and changing the styling of its documents.

None of the elements of the Definition of Done has been met. I bet that the backlog is still filled with bugs and features that can keep the team occupied for several years. Besides, Word is the golden standard of word processors, and it generated a ton of cash. This secures the position of the software in the catalog of software offered by Microsoft.

Software that is almost 40 years old may involve the use of outdated and difficult to use technology. It’s hard to know how Microsoft handled the modernization of its software, but it seems that they did an OK job. It’s hard to find information about the technical debt Microsoft is carrying. That’s understandable not something companies want to share.

All in all, Word is a powerful software that was built at a time where computers were a fraction of what computers offer today. Microsoft was able to keep developing the software, adapting it to new platforms and usages. The apparition of new competitors, mainly the Google Workspace, might impact Word domination, but competition isn’t bad.

Stale Project: MomentJS

MomentJS is a JavaScript library that helps developers working with time, dates, timezones, and local. This can seem trivial for non-developers, but I guarantee that working with a date is never a piece of cake. Currently, Moment is still in development and is downloaded 12 million times per week. Those numbers are impressive, yet I call Moment a “Stale Project” here is what the team has to say about it:

We now generally consider Moment to be a legacy project in maintenance mode. It is not dead, but it is indeed done.

The development of Moment isn’t stopped. They are still fixing bugs. However, no new features are developed, and no new version of the project is planned. Instead, the team recommends developers stop using Moment.

The high maintenance cost of the software is what caused its downfall. The JavaScript ecosystem changed a lot in the last decade, and Moment couldn’t evolve with it. Adopting the code to address the most common complaints (mainly mutable objects and size) would break many old projects and require a tremendous amount of work.

Besides, new libraries exist and fix both of those issues. It would be a waste to update Moment instead of recommending other libraries. Both elements that the team doesn’t want to tackle since alternatives exist.

Wrap Up

The two selected examples show two software, both are used by millions of people each week, but they are in a very different state. One is actively developed and receives several updates a year when the other is kept alive for now, but its future is uncertain.

It shows that having a user-base is not always sufficient to ensure the sustainability of a project. External factors are the most common cause of death for software.

Several aspects such as business, marketing, and strategic elements have been kept out of this article since they can be tied to a lack of funding.