[jongleberry]

use `let ` or `const `. there's no need to use `var` in ES6+, ever.

[bluesnowmonkey]

But we're going to keep it around, aren't we? Because we can always add features but we can't really remove them. It feels like JS is getting cruftier. Would it be better if var already worked like let? Sure. Will JS be better with two slightly different ways of scoping a variable, one of which you really shouldn't use? Doesn't seem like it. One more thing to explain to newcomers.

[reissbaker]

So, you're right that nothing can be removed. But you can add new things, and via mode switches (e.g. "use strict", which enables strict mode currently, or "use strong", which is planned to enable strong mode) essentially remove old ones by disallowing them in the latest "mode." Old code will continue to run, but as long as you opt-in to the new way of doing things for your new code you can enforce not using the legacy constructs in the new code.

It's important to note that the modes are on a per-function basis, so opting into the new mode doesn't break existing libraries, etc even if you call those libraries from a newer mode.

It's also worth mentioning that strong mode doesn't introduce anything new. All that strong mode does is remove features. `let` and `var` both already exist; in strong mode, only `let` does.

[thomasfoster96]

Well, for newcomers we can either bring them up using `let` exclusively or the explanation of function scope can include a footnote on `let` versus `var`.

[lmm]

Hopefully we can tell newcomers to "use strict", always use "let", and to not worry about reading code that doesn't "use strict" to start with?

People who are new to FORTRAN get told "if it doesn't say "implicit none" at the top then don't try to read it yet".

[thalesmello]

So, if I want get the sum of an array of numbers, the only option is to use recursion or a reduce function? Is there a way to accomplish this using a for loop while sticking to let keywords?

[Skalman]

Perhaps you didn't catch that basically the difference between let and var is that let is block-scoped, while var is function-scoped?

  let result = 0;
  for (let i = 0; i < arr.length; i++) {
    result += arr[i];
  }