As the lead author of JMVC, CanJS, StealJS, etc, let me try to address some of the criticisms of this article. I didn't write it, but I reviewed it.

Yes, this is a blatant advertisement. We worked hard on these open source project, believe they are great, and were trying to argue for their use from a commonly overlooked perspective. It should surprise no one that an article on our site advocates for one of our open source projects. I don't think arguing for something you benefit from should disqualify the argument. Instead, it should make any claims we make fall under more intense scrutiny.

Now about longevity, there really isn't a fair comparison. JavaScriptMVC is far older then Backbone, Knockout, Angular and React. They, for the most part, haven't even had to evolve. Their technology is, for the most part, still pretty modern. We'll see how they do.

Here's how JavaScriptMVC evolved:

JavaScriptMVC started on PrototypeJS. It did almost everything a Backbone + RequireJS + Karma + DocJS setup does today. Except much worse! It used:

- PrototypeJS (jQuery had only first released)

- RhinoJS (the only viable server-side JS runtime)

- EJS for templates like `<%= foo %>`

- Steal syntax for loading scripts `steal(dependencies)`

- Selenium for test driving

It had the only working "event delegation" system. This was one of its big features. It also had:

- basic modeling

- basic routing

Since that time, we've probably done more then anyone else to adapt and evolve the tools and technology so a reasonable person could upgrade. Some of my favorite highlights:

1. We updated StealJS to support AMD/CJS/ES6 syntaxes while still supporting the old steal syntax. We also migrated its build system from RhinoJS to NodeJS.

2. We swapped out Prototype for a compatibility layer that runs on jQuery / Zepto / Dojo / Mootools / YUI
3. I helped jQuery add event delegation so we could drop it from JMVC in jQuery 1.4.

4. We added live-binding EJS templates.

5. We added live-binding Handlebars-like templates. And then re-wrote that again to be 2x faster.

6. We added custom elements, two-way bindings.

7. I'm currently rewriting how we do data-connection: http://connect.canjs.com/, while still providing a backwards compatible version: http://connect.canjs.com/doc/can-connect%7Ccan%7Cmodel.html

8. Live-reload technology

9. A progressive bundling algorithm.

10. Migrated documentjs from Rhino to NodeJS, make it support multi-versioned docs.

If this article had come out 3-4 weeks from now you'll see we added:

1. Server-side rendering (Isomorphic / Universal JavaScript)

2. Worker-thread rendering with virtual dom merges.

We started when JavaScript was in its infancy and managed to evolve our tools and technology to keep pace with innovation constantly happening in our space. I really don't think there's another project that's undergone such a transformation.

When Angular was released, people thought putting click handlers back in a template was silly. Same with React's Virtual DOM approach. Those things have turned out to be great. We've added them (or are just about to).

We've tried to keep changes as small as possible between major versions. I think we've walked the line well between change and backwards compatibility.

So in the end, we're very proud of these accomplishments. We believe they are unique and mean something. That's what this article was about.

Btw, I give a free weekly JS training tomorrow. Its got open Q+A at the end if anyone wants to discuss more, you can join it here: https://plus.google.com/u/1/b/117481170193954630503/events/c... Open QA will be at approx. 12:45 CST.