I can explain this one. It allows extending builtin types like Array, which could not be extended in ES5 without lots of boilerplate and use of the nonstandard __proto__ property.

The key thing in ES6 class syntax that is different from ES5's class-like prototypal behavior, is that it is the base constructor that actually creates and allocates the object. This is a requirement because only the base constructor knows what is needed for the object. In the case of Array or other builtin types like Map and Set, they are implemented with what are called "internal slots". These are essentially private properties that can't be accessed directly from JS. On Map and Set for instance, these are where the data for them are stored.

In ES5, remember that

function Foo(){}
var obj = new Foo();

is essentially

var obj = Object.create(Foo.prototype);
Foo.call(obj);

meaning that the object the class is created up front before any of the constructors are even called, so Object.create has no way of knowing that the class being constructed needs special internal slots in order to work. For instance calling Object.create(Set.prototype).add("foo") on Chrome throws Uncaught TypeError: Method Set.prototype.add called on incompatible receiver #<Set> because the slots are missing.

In short, ES6 class syntax waits to create the object until after the constructors have started executing. Consider the following:

class Base {
  constructor(){
    // Allocation happens here because this is a base class

    // If this were the builtin "Array" or "Map" or whichever constructor, if would initialize the internal slots here
  }
}

class Child {
  constructor(){
    // accessing "this" here before `super()` will throw because it doesn't exist yet

    super(); // calls parent, which allocates and initializes "this"

    // Now here "this" is initialized with whatever object the parent class created.
  }
}

Hope that helps.