I'm not sure if this churn is unique to the javascript and front-end world.
When I used to work in Java a few years back, there was a new "favorite" framework every few months:
* build: ant, then maven and just when maven started getting massive traction, gradle.
* web frameworks: JSP, JSF, Spring MVC, Wicket, Tapestry, GWT, struts, dropwizard (and compiled java - Grails, Play etc...).
Even "standards" made by the "governing body" conflicted with each other - JDO, JPO and ESB (the persistence part, though I'm not sure if there was a JSR for that) for example.
A new web shop even had a hard time choosing the Language of the month: Groovy, Scala, Clojure.
If you go broader then the Java world, then the flavour of the week platform was even harder to pinpoint- ASP.net ,PHP,wordpress,drupal,rails, node etc...
Not to mention databases - from everything must be relational in one Monolith DBS (oracle mostly) to sharded mysql with memcache layer, to only noSQL (usually mongodb),then to polyglot persistence (I.E. use what fits) and now into the brave world of natively distributed sql (I.E. newSql).
I don't think it's the front-end that is high churn, I think web development as a whole has changed so much in the last few years that the technologies involved has changed drastically.
At least in front-end development you one language, and the knowledge of some universal standards (you aren't going to need to relearn HTML and css).
Also there is still jQuery- which regardless of how many things are built against it, it exists in practically every site.
> build: ant, then maven and just when maven started getting massive traction, gradle
I'm not sure that I would call 3 big build systems over the course of 20 years "churn" :-)
> web frameworks: JSP, JSF, Spring MVC, Wicket, Tapestry, GWT, struts, dropwizard (and compiled java - Grails, Play etc...)
The height of the churn corresponded to people trying to handle MVC on the server side, and seems to have subsided somewhat as people have simplified the server side (RESTful APIs) and moved the MVC to the client side.
I wonder if this churn is somehow intrinsic to the type of problem being solved (user interaction), rather than to the technology / language / community.
in regards to build, I was talking more about when these systems became popular/hyped/adopted rather then when they were released.
Maven didn't became really adopted until 2.0 came out, and, to me at least, Gradle gained traction extremely fast after Maven was adopted (along with sbt for scala and others). I think Maven laid out the foundation for the adoption of gradle.
But yes, it's a lot farther apart then Grunt vs Gulp. I was more trying to show that build systems change even for very stable languages/ecoSystems (relatively speaking).
In regards to problem solved - it's an interesting thought, I haven't done a lot of ui outside of web, I wonder if other people can shed some light on churn regarding ui frameworks on desktop (or even flash/silverlight/unity etc...)
There is some churn in layout recommendation and widget availability, but the fundamental application construction model in iOS 8 is the same as it was for OpenStep 20 years ago.
I wouldn't say it's the general case (and of course not about JS, that I know very little of) but sometimes the proliferation of tools in a field is just a simpton that either none of the tools have been really good (first rush, then technical debt) or that there's some intrinsic deficiency in how the field works.
Perhaps 2 of those 3 languages had the purpose to be the best general purpose language, at least for the JVM, but it's a stretch to say the same for Groovy. After the first three yrs of its existence, it's primarily been a business venture with 2 competing conflicting business purposes:
* to buttress one particular piece of software (i.e. Grails) so its project manager can spin a buck selling consulting and conference seats, flipping companies (twice), and take over control of bundled software (i.e. Spring if he hasn't already)
* to keep another project manager in employment by using the Groovy brand to promote himself, diluting control from the technical lead by employing another more compliant programmer, duplicating the functionality of 3rd party addons like Groovy++, setting up a personal website and subscription list to take product control away from Codehaus, etc
Only to the extent Groovy satisfies these purposes does it try to be the best language.
When I used to work in Java a few years back, there was a new "favorite" framework every few months:
* build: ant, then maven and just when maven started getting massive traction, gradle.
* web frameworks: JSP, JSF, Spring MVC, Wicket, Tapestry, GWT, struts, dropwizard (and compiled java - Grails, Play etc...).
Even "standards" made by the "governing body" conflicted with each other - JDO, JPO and ESB (the persistence part, though I'm not sure if there was a JSR for that) for example.
A new web shop even had a hard time choosing the Language of the month: Groovy, Scala, Clojure.
If you go broader then the Java world, then the flavour of the week platform was even harder to pinpoint- ASP.net ,PHP,wordpress,drupal,rails, node etc...
Not to mention databases - from everything must be relational in one Monolith DBS (oracle mostly) to sharded mysql with memcache layer, to only noSQL (usually mongodb),then to polyglot persistence (I.E. use what fits) and now into the brave world of natively distributed sql (I.E. newSql).
I don't think it's the front-end that is high churn, I think web development as a whole has changed so much in the last few years that the technologies involved has changed drastically.
At least in front-end development you one language, and the knowledge of some universal standards (you aren't going to need to relearn HTML and css).
Also there is still jQuery- which regardless of how many things are built against it, it exists in practically every site.