Xto6 modernizes your JavaScript code

For example, `class` has particularly bad performance characteristics because under the hood it has to set an object's prototype on the fly (at least this is how Babel implements it) [1] and `super` is also slow due to prototype lookup [2].

[1] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...

[2] https://jsperf.com/es6-classes-super-es5-vs-transpiled/2

However, I doubt that I would use it - most of the 'modernizations' are really dependent on the context of each change and require some tweaking.

For instance, ES6 classes do not allow for inline computed methods:

  const x = function () {};

  x.prototype.a = wrapFunction(function(){});

  class x {
     a() wrapFunction(function(){}); // invalid :-(
  }

Then you can't just rewrite all methods to arrow functions because they don't have prototypes, even when they're really tempting:

  var x = function () {};
  x.prototype.a = <foo>;

  var x = () => {};
  x.prototype.a = <foo>; // cannot set a of undefined

$0.02

  Person.prototype.getAge = function (birthYear) {
    var age = 2015;
    age -= birthYear;

    return result;
    // Do you mean return age?
  };

  Object.defineProperty(Person.prototype, 'age', {
    get: function () {
      return this.getAge();
      // getAge function takes a required parameter.
    }
  });

    var Person = function (name) {
      console.log('This is the constructor.');

      var _name = name;

      this.getName = function() {
          return _name;
      };
    };

Especially so if the goal is to migrate "old" javascript to get it "modern". Migrating bleeding edge JS to even more bleeding edge JS hardly seems like a very worthwhile endeavour.

People in the JS world should seriously drop the NIH syndrome and contribute to existing tools instead. The last thing we'd ever need is yet another framework/library/tool that's just a bit more than what's already existing.

http://www.isaacchansky.me/days-since-last-new-js-framework/

I like to take a wait-and-see on these language updates to see which parts get widespread adoption. I find the most important part at this point isn't the features, but having code that the majority of developers can understand.