Technology popularity and longevity don’t always walk hand in hand.
We often look for successors to legacy technologies, hoping that newer solutions will automatically displace those from the 1970s. Meanwhile, the C language, created by Dennis Ritchie, remains the ultimate foundational system software after more than 50 years, powering almost every server on Earth. Even a strong contender like Rust hasn’t managed to dethrone it.
Right about now, some smart-aleck will ask: “If C is so great, why don’t we use it for everything?”. Fair point, but the answer is simple-because we don’t need to. C is the lingua franca for hardware communication and is perfectly suited for managing the deepest basements of the operating system. Over the years, languages and tools were created to abstract and speed up coding for specific purposes and platforms-yet C remained the foundation they all run on.
Web backend development can be done in many technologies, and their undisputed leader is PHP. Although its funeral has been announced multiple times, it’s doing great-powering 7 out of 10 websites today, with the other three most popular being Ruby, JavaScript, and Java. Does that list sound like a rehashed menu from a decade ago? Exactly-nobody rewrites entire applications on a whim or switches technologies every few months, or even years!
Current popularity statistics are in no way proportional to the total volume of software actually running on a given technology. PHP hasn’t been the number one choice for younger developers for a while now and stands a good chance of eventually being replaced by another language-maybe JavaScript (on the backend), maybe Golang, or maybe something else entirely. Time will tell, as each alternative offers a different edge over the previous solution.
When it comes to the user interface layer, JavaScript has held the crown for years. A few frameworks currently dominate the market (React, Vue, and Angular), yet they are nowhere near the scale of their older brother, jQuery. It is estimated that jQuery still runs on 60-70% of active websites, largely driven by WordPress, which powers over 40% of the web.
As we can see once again, popularity and longevity don’t always walk hand in hand forever. This allows us to predict that more elements-differing from their predecessors in shape and functionality-will eventually join the foundations and bricks that build today’s internet. Therefore, it’s worth investing not just in currently trending technologies, but primarily in the most antifragile programming competencies that will continuously stand the test of time.
Unfamiliar with the Lindy Effect?
Check out this article for some food for thought:
Article: The Lindy Effect in IT
Medium: The Lindy Effect in IT
Top comments (8)
The jQuery stat is the one that always makes this point land, because it's the tech nobody lists on a résumé anymore that's quietly running more of the web than React. WordPress alone keeps it Lindy no matter how the framework charts move.
Spot on! The quiet giants just keep running the world!
Sometimes I compare my resume from decade (or more ago) with a kind of nostalgia ;)
Mention jQuery in your resume, and everyone will know you have 20 years of experience 😂
I liked your point on how the Fetch API replaced XHR for better streaming. Do you think Service Workers will eventually make traditional server‑side rendering obsolete, or will they just complement it? Following you for more deep dives – would love to swap thoughts!
I think they’ll definitely complement each other. Rendering HTML on the server remains the gold standard for SEO and fast initial loads.
Did you have a specific edge case in mind (like worker-side templating), or are you seeing a broader trend here? Would love to hear your thoughts (followed-back)!
The thing this framing misses is why the old stuff sticks around, and it's not inertia or "antifragility" — it's that the incumbents keep quietly eating their successors' best ideas. PHP in 2010 was a genuinely bad language to write large systems in; PHP today has real types, JIT, proper package management via Composer, and an FFI. The reason nobody rewrote off it is that the reasons to leave got patched before the migration cost ever paid off. Same with C: it didn't win the argument against Rust, it just doesn't have to move.
That changes your prediction. The winners aren't the "most antifragile competencies" in the abstract — they're the incumbents with a maintainer culture willing to absorb the challenger's killer feature. jQuery is the counterexample that proves it: it didn't adapt, the platform did (querySelectorAll, fetch), and now it's coasting on WordPress's install base, not on anyone choosing it. Longevity-by-adaptation and longevity-by-legacy-lock-in look identical in a popularity chart and mean opposite things for where you should invest.
Fair point. "Longevity-by-adaptation vs. longevity-by-legacy-lock-in" is a crucial distinction. Thanks for pushing the framing further!
The ultimate survivors adapt to be "just-enough" not to be replaced. I think the same refers to us Programmers: we constantly need to adapt as no one would lock-us-in in Tech forever.
Some comments may only be visible to logged-in visitors. Sign in to view all comments.