Programming languages never die
Programming languages never die. Not really, not entirely. They can certainly be dethroned from a dominant position, it has happened many times and will keep happening, but losing the first place does not mean that a language will disappear in the turn of of a couple of years and for a very natural reason: the engineers that have mastered that language will continue to be around for a while and so will be the community around that language.
This is an heated, recurring programming discussion, fueled by the naivety of "x is out, y is dead". Before you consider abandoning an older language for a trending alternative, because it's going to die soon, there's a lot more to consider.
The first thing I like to do in such cases is to look at history. IT is a relatively new field, but technology existed as long as humans have, altogether with their impact on societies and organized groups of people. The rules that apply to technological changes work with IT as well, and there are a few relevant to this discussion.
Technological advancement whenever a new technology becomes available is not istantaneous as it takes a while to master the new technology to the point it can compete with existing things. During this phase there will be early adoption, especially for activities that would be otherwise impossible, but the standard remains the old thing, which gets replaced over time. This replacement more often than not happens with a generation change, as the experts in the old technology retire and are replaced by youngs that are going to be more familiar with the new technology. That's an important take out: mastering a technology does not happen in a weekend, so older systems will still have a competitive edge for a while.
The second take out is that advancement can be painful and expensive and being in the lead with an old technology, does not guarantee leadership with a new one. A few times in history it occured that a new technology evened the field between a powerful country and a rising power, for example when the British introduced fast steam ships, they also obsoleted their immense fleet of sailships and evening out the field and giving other countries the possibility to compete with the Royal Navy.
Imagine a company that decided to move from Python to Golang when it came out a few years ago. There were no Golang experts except the authors themselves and few learning resources, making learning Golang hard and expensive and then there's the effort for porting the code. After the code has is ported, the Python experts working for the company lose their effectiveness as they are working in a language they have yet to master, and need more time for delivering features. Now the competition can use the situation and faster time-to-market to erode the company's market share.
Major technologies, even when utterly obsoleted never really disappear. A technology is invented for specific reasons and it's likely it still fullfills its original requirements. Payphones for example, once a prominent feature, now are rarely seen but they have not disappeared entirely either, because they still provide a convenient way to make calls when nothing else is available.
The last take away is that often older technologies are simpler and thus cheaper.
Take PHP, which is considered by many a dead language, while it powers more than half the existing websites. PHP is kind of old, it lacks many of the newer features, but it's simple, cheap, has many experienced engineers available and it's effective for simple websites. PHP will not power the future of the web, but it will not disappear overnight either and it will likely take at least another decade before it becomes a minor language in terms of web presence and even then, mass rewrites of PHP to newer languages are not going to happen.
Sometimes technologies do die: when no one remembers them. Only at that point a technology is finally dead. So if you're thinking about using an old programming language, it may not be ideal, but definitely not dead.
With these premises, whether you're choosing a programming language for a new project or deciding to move to a newer one, you can start to make pondered conclusions and consider the effort, the cost and side effects of newer languages against the benefits. Today's IT tends toward discarding the cheap and old and go for new things even when their features are unnecessary and their complexity offsets their benefits but it does not have to be so.
I don't enjoy making my life harder than it should be, so I stick with Python even if I know Elixir. My Python mastery allows me to do much more in less time; Elixir comes with great solutions and fresh takes on many issues, however it will take some time before I reach the same proficiency, if ever. On top of that, Elixir relies on more complex abstractions than Python, while these are the abstractions that make its killer features possible, to benefit from them I'd need to understand them very well.
I apply the same reasoning to Kubernetes. Many small companies decide to run their apps in Kubernetes, simply because it's the new cool thing. Now they have extra complexity they don't need at extra cost they can't afford, while ignoring simpler and equally effective solutions.
Don't buy in the new shiny things as they are launched, consider them for what they are; don't ignore the old tool in the belief it's going to disappear because it's not.