On the one hand, I hear you and don't disagree - programming ergonomics is a big deal, and access to the language you like is important. I for one really don't want to program in a language that uses significant whitespace, if I can avoid it.

On the other hand, "keep up with JS" is something of a misnomer here. It's not javascript that's moving super-fast, it's the web ecosystem (plus the node one, in parallel). It's moving fast because new ideas are evolving at speed (functional-reactive approaches, new ways to think about mixins vs multiple inheritance, etc), and those ideas lead to new framework architectures gaining popularity as they exploit these new ways of thinking about organizing data flow through a complicated system.

Couple that with some baseline things that aren't changing here - you're still going to have to interact with the DOM, you aren't going to magically get re-entrant multithreading, and the event model isn't changing. There's still going to be a lot about web programming that feels different from systems programming, and things are still going to move quickly. Probably even more quickly (but I'm not certain about that - I imagine one major reason JS shifts quickly is that it has so many programmers working with it, if the population fragments there will probably be a number of slow-moving communities that neither shift often nor take advantage of new features, which feels like the kind of neophile - neophobe split that's already apparent in different areas of programming).

So: I am not convinced that a (say) rust or go compiler to WASM will suddenly make front-end programming feel like systems programming. It'll be a new language, sure, but there's a lot more to web development and the (reasonable) complaints people have about a shifting landscape than just javascript and its funky definition of OO and triple equals sign.

I am not sure I am qualified to really debate the merits of the JS ecosystem; perceived or real at this time. I tried to do front-end stuff when Knockout and Backbone were popular and Node was just starting. Maybe a better phrase is; I had a hard time keeping up... it was the paradigm changes (as you mentioned), but it was also the volume.

Paralyzation due to choice and only so much time to evaluate each framework. Couple that to "staying" power, that is, will this library be around in 6 months? I have taken a peek from time to time and been thoroughly aghast at the volume and not really seeing any of the old stand-bys around.

Now compare that to Python. There is no dearth of choice and one will find many of these choices have been around for more than a decade. They have evolved and changed of course, but not anywhere near the pace of JS. Again, I could take a 3 to 6 month break from looking at Python news and libraries... then come back and jump right into most of the libs I already know. Can a JS dev do that?

> Couple that with some baseline things that aren't changing here

Doesn't webASM give the power to abstract those things away? React creates a virtual DOM, right? Why can't Python create a virtual DOM via webASM?

I stand with you in that I agree things are going to move quickly once Python and others become peers with JS in the browser. I am sure it will be insane as everyone figures out which lib will have staying power like Django, or similar in another lang. I do think that people who generally gravitate toward languages like Python, Go, C#, Java will bring those attitudes with them... that is, they aren't going to re-invent the wheel every three months unless there is a super compelling reason to do so.

I think there's room all over for different kinds of ergonomics for software development. Languages play a big role here, for sure, and having access to more languages for the front end feels like it will be good by definition- more choices is usually better. There's a lot lot lot of new stuff for sure in JS, and it can be pretty overwhelming.

I think, though, that you could pretty easily take a break from JS dev and come back and still use the tools you had six or twelve months ago, just fine. For example, I maintain a pretty big angular 1 application that has a lot of pre-1.4 code in it. It runs fine, and I haven't touched my build tooling in over a year. There's still a lot of very relevant questions and answers on stackoverflow and so on.

Now, I may well want to use react or angular4 or something else for my next project, but nothing is stopping me from using angular 1, or backbone, or just plain jquery for that matter. They all still work.

As to the virtual DOM - abstraction libraries are really cool (although the vDOM isn't really that), but they introduce just yet another thing that changes over time. At the end of the day, the DOM is a pretty complicated thing, between its own structure, event models, css, and everything else, so the API to interact with it is going to be complicated no matter what language you use. Most frameworks (backbone, jquery, angular, react, etc) are all just different attempts to manage that complication, and all they ever really do is shove the complication from one place to another, but (for example with functional reactive models) that other place is something a group of people is willing to deal with.

I agree that js world move fast but there is lot of reinvention of wheel and every new shiny thing have relatively small "payload". Also lot of things are just workarounds for js badparts. Currently I feel that js is out newest Java: clearly technically behind but since it has all the libraries it must be best forever. Of course ecosystem size has benefits but there more than just "they can't keep up with js". Es5 -> es6 -> elm, why bother with hot fixes when major update is available?