[kerkeslager]

As someone who has worked in Javascript basically since Javascript was invented, it's been "quickly changing" that entire time, and the majority of the changes have made things worse, not better. It used to be that you could trace your code through 15 layers of callback hell and eventually find the problem. Now there's 10 different syntactic sugars around callbacks, so you get to save a few characters of typing and then trace your bugs through 50 layers of callback hell, most of which are in some 0.0.1-alpha-versioned promise library which may actually just be a XSS attack. Improvement? I think not.

Just because more people are doing it, doesn't mean it's improving.

I'll believe things are going in a good direction when `{}.foo` throws an exception in all major JS implementations. But I'm not optimistic about that ever happening.

My only hope for JavaScript right now is that it might die because WebAssembly lets a reasonable language achieve dominance.

[crooked-v]

> I'll believe things are going in a good direction when `{}.foo` throws an exception in all major JS implementations. But I'm not optimistic about that ever happening.

It does. That's a SyntaxError.

[kerkeslager]

Okay, please make a little effort to understand meaning rather than taking things completely literally.

Try one of the following:

    > ({}).foo
    undefined
    > var a = {};
    undefined
    > a.foo
    undefined

Now imagine hundreds of lines of code and a bunch of asynchronous callbacks occur between the last two lines, and imagine what that does for your debugging experience. Or watch Wat[1] and see if any of that is what you want your language to do when it happens.

The fact that JavaScript throws an exception on `{ foo: 'bar' }.foo` and not `({}).foo` isn't exactly a defense of the language.

[1] https://www.destroyallsoftware.com/talks/wat

[crooked-v]

({}).foo returning undefined is exactly what I'd expect. That's a basic part of how accessing properties in Javascript works, and wanting it to work differently is like wanting NullPointerException generation in Java to work differently.

> Now imagine hundreds of lines of code and a bunch of asynchronous callbacks occur between the last two lines, and imagine what that does for your debugging experience

That's what using typed signatures for your objects is for. It's not even substantially different from having, say, Java with an object with properties that can be nullable or Optional.empty().

[kerkeslager]

> ({}).foo returning undefined is exactly what I'd expect. That's a basic part of how accessing properties in Javascript works,

This is an excellent and succinct explanation of why JavaScript is a badly-designed language, and why I use better designed languages when possible.

If the basic properties "work" when it makes no sense for them to work, your language is broken.

> That's what using typed signatures for your objects is for.

Explain more?

[crooked-v]

> Explain more?

With Typescript or even just JSdoc and a good IDE, you can do:

    const a: {propertyA?: true; propertyB?: 'cats';} = {};

    // or

    /**
     * @type {object}
     * @property {true=} propertyA
     * @property {'cats'=} propertyB
     */
    const a = {};

...and get warnings later when you attempt to access anything that's not propertyA, propertyB, or a JS builtin, as well as warnings if you attempt to use either without verifying whether it's undefined or not, as well as warnings if you then try to use them in places restricted to non-matching types.

With Typescript, you can turn on full strictness and make these build-rejecting compile-time errors, too.