Thnaks Pwevans, it is replies like yours I prefer. You don't have to agree with me. But you make your case and argue against points I made rather than focusing on how much they think I should know about the subject matter.
To offer some agreements and counterpoints to what you mention. I think for the JVM and the CLR it is of course great that they can grow over time by adding new languages. E.g. people can jump to Kotlin and use all the libraries they know and love. That is obviously a major advantage.
I will push back a bit on the memory safety part though. Garbage collection has been around for a while, and e.g. Go manages fine with garbage collection while compiling to native code. So I don't think you need a VM to have garbage collection.
As for stuff like WebAssembly. In that case the JVM and CLR seems to have been a negative. The garbage collectors creates problems in porting, thus the first languages that could target WebAssembly tended to be the ones that did manual memory management. That is quite ironic I think.
Finally I'd like to add one counterpoint to something like the JVM and CLR as a platform for evolving to new languages. Kotlin, Clojure and F# is all cool. But if you want to look at a platform where a complete shitft to a new language has happened and people are able to keep using their old skills then that is actually Apple's platform.
The transition from Objective-C to Swift has been swift (pun intended) and unprecedented in the industry. Kotlin has a lot of similarities with Java and seems like a better language to me, yet you don't see anything like the update Swift had on the JVM platform.
This points to another way of thinking about software which I am a champion of and that is software based on message passing. The whole Alan Kay idea. While Objective-C was native code, the fact that most functionality was exposed through message passing meant that transtioning to a whole different language was made a lot easier.
Objective-C was really good at integrating with other languages. E.g. you could call Objective-C libraries easily from Ruby, Python etc. The same could not be said of Java and C#. Try calling a Java library from Python.
When you are inside the JVM and CLR world, that is great, but they also create little islands for themselves which excludes a lot of other tools and languages.
Not saying there is a right or wrong here. There are tradeoffs. The JVM and CLR solution gives e.g. better type safety than message passing.
