Using analogy: the wheel has a radius of 40cm and thickness of 10cm, I need a wheel of radius 30cm and thickness 15m. Sure, I can cut off the edge, mold it, and graft it onto the side, but it's a lot easier to just grind a new stone.

In real life: the old library covers 80% of my use cases. The problem is that it's not extensible, so in order to add the remaining 20% I have to fork it. Moreover, it has a lot of extra features I don't want, but get in the way when adding my 20%, so it would be less work to rewrite the entire thing from scratch with only the features I need.

Either way, now there are 2 similar versions of the same thing. Then someone else encounters the same problem, except their wheel needs ridges for all-terrain, or their library must be in the language that the rest of their code is written in (and FFI sucks). Now there are 3 similar versions. And so on...

Why not just make a "one-size-fits-all" library which can be extended any way? People have tried and will continue trying, but what they end up producing is the definition of "over-engineered": a bloated mess which is buggy, inefficient, hard to understand, and still manages to only cover 95% of my use-cases.

Don't get me wrong, code reuse (even legacy code) is a good thing, and there are plenty of cases where developers would be better off using an existing library. Maybe they'd to write a bit of glue code to fit their purpose, maybe they'd need to sacrifice some performance or non-essential feature (which is probably performance-related and/or a dumb idea anyways), maybe they understand this but simply choose to spend time writing their own unnecessary library because it's more fun.

But as our world becomes more complex and competitive, especially in web-dev, those couple niche extra features or performance gains or developer pain-point mitigations that only a full rewrite would provide, become worthwhile enough to warrant the rewrite.

It’s hard to know what’s pointless reinvention and what is evolution. We’ll only really know in hindsight.

Look at the wheel itself, it has been reinvented many times, depending on how that terms is defined. Maybe it started with a tree truck or a stone disk, then a solid wood wheel, then a hub and spoke design, then adding rubber, than an air inner tube, then something more akin to modern tires and wheels. Even now, new wheels and tires are being made to better work with electric vehicles, airless tires have been in development for years, and we’ll continue to make them better.

How much of tech is reinventing basic concepts vs improving on those basic concepts to make them easier to use and more reliable?

Couldn't you look at much of the Linux userspace as an example?

For instance there all the GNU tools like bash, gawk, gdb, GNU binutils, GNU make, GNU m4. People use them all the time. They do get updates

https://lists.gnu.org/archive/html/info-gnu/2022-09/msg00003...

but it's not like javascript frameworks. Not to mention gnu emacs, vim, etc. All of these tools are basically compatible with development tools from UNIX and other minicomputer OS.

Another thing that interests me is the procession of "chat" and related software (e.g. there is a lot of overlap between things like IRC, Whatsapp, Skype, Zoom, etc.) in that almost all the apps are incompatible with each other and individual platforms seem to get some traction (often by obsessive attention to the onboarding process) but eventually the owners go into a harvesting mode where they can't be bothered to keep up with a changing environment and the apps rot. Somebody comes around and says they want you do use a new chat application and when you're skeptical they say "it really works... like Skype did 10 years ago."

I imagine the counterfactual world where XMPP or some other standard became... standard and we would have seen steady competition for apps to get better, or maybe not.

There can never been any stack that works for everyone, as long as "everyone" refers to individuals with their own autonomy and biases.

Some people like a framework/language because it "vibes", not necessarily because it's the best. Whatever tool allows you to build the software you want/need, is, by definition, the right tool for the job.

If the planet depended on writing software, wouldn't you want someone to use what they're productive with, rather than slowing them down with some objectively "best" stack?

I appreciate this discussion :)

I'm definitely out of the loop in the tech world, but there's a lot of fragmentation. You see a post here every few days about a new language. Does that mean that the pre-existing options were that bad? Was there no way to extend what was previously there and compromise? Obviously there's better and worse, but what's the threshold for creating something from scratch? Maybe that should be higher and occur less frequently.