This is absurd. A finished project is a dead project. If it isn't improving, it's dying.
Never finish your projects (unless you're just doing homework). Software is a system. Systems of any non-trivial complexity are living things that must adapt and evolve. Constantly.
(Also, there is absolutely nothing wrong with abandoning a project. Gain as much as you can from your experience and quickly move on to something better / more meaningful.)
> A finished project is a dead project. If it isn't improving, it's dying.
This might be true for large and broadly scoped projects, but for small Unix-style modules/tools it isn't always the case.
To use real-world examples, see point-in-polygon[1] and robust-point-in-polygon[2]. The tools are both "finished" and any further API scope/modifications would be harmful to the software that has come to depend on them.
They could forever be improved in documentation, discovery (i.e. a website), etc but at a certain point it is better to place your effort into new tools.
I disagree, based on personal experience. I have a few projects no longer in active development, but I use them frequently. They do what they are supposed to, they don't break down and require no maintenance other than changing the expiry date on the credit card associated with the hosted account every few years.
By that token a substantial proportion of the tools I rely on on a daily basis are dead.
(not least if you consider the actual contents of the linked article, which makes it clear that by "finish" he means to make it functionally complete, not to stop fixing bugs or e.g. ensuring it still compiles)
> A finished project is a dead project. If it isn't improving, it's dying.
Define 'improving', because there have been quite a few major projects that have been getting 'worse' (slower, buggier, less secure, more bloated, breaking changes, feature creep, inconsistent documentation) as time goes on. So what exactly are we prioritizing?
Wintel conquered the world by maintaining backwards compatibility. These days the majority of 'improving' seems to be for getting around breaking changes introduced by others and making unnecessary UI changes. Reliability and consistency is not a priority anymore. Instead no software can ever truly be finished because the assumptions under which it operates change unpredictably and inconsistently.
I mean really, once you finish something like a file renaming utility, what else is there to do? If it stops working due to changes made by someone else, then it needs to be updated, but that isn't improvement. If on the other hand it's working as intended, then the only way to further improve it is by changing priorities. Engineering is all about tradeoffs, but priorities are now being driven almost entirely by cultural forces, and I've seen this render working software inoperable for no other reason than it didn't fit the fashion of the time.
Reality doesn't change to the point that a chair, or even a microprocessor, stops working. Software on the other hand does, and if the platform you're targeting isn't stable, then you can never finish a project, let alone improve it. And this 'no updates' = 'dying project' philosophy is a big part of the problem, because it forces developers to unnecessarily update a project just so people believe it's relevant, while the only metric we should be using is that the software is fit for the purpose we use it for.
You had to fish hard for this example, didn't you?
Sometimes, genius strikes and you get something so precisely thought out and so well executed that it lasts for generations.
Still, I'd have to answer your question in the affirmative. The original TeX is quite dead indeed. It (and the ecosystem around it) have evolved significantly over the years and continue to evolve as we speak, so it is far from finished.
Never finish your projects (unless you're just doing homework). Software is a system. Systems of any non-trivial complexity are living things that must adapt and evolve. Constantly.
(Also, there is absolutely nothing wrong with abandoning a project. Gain as much as you can from your experience and quickly move on to something better / more meaningful.)