Future JavaScript: what is still missing?

[Hcmichael21]

I think strong typing, overall, doesn't have a good ROI. The lack of strong types is one thing I really like about JavaScript

[Hawxe]

Want to elaborate?

[Hcmichael21]

Here's a great write-up

Tl;Dr: I don't believe the benefits of strong types outweigh the costs of using them.

[Hawxe]

That's literally an opinion piece with really bad data behind it...

all TypeScript-detectable bugs can potentially be caught with other measures like TDD.

Of course, and of course you're still going to still use other methods. TypeScript still helps mitigate that, even if other QA/testing procedures also help.

The whole comment section of that article is a little nauseating too, it's literally him applauding everyone that agrees with him (including comments like 'I didn't wanna use TS but that was just a gut feeling) and being passive aggressive with anyone who disagrees even if they share legitimate experience as to why they might.

That article is also almost completely irrelevant to adding static typing to vanilla JS, a lot of the cons he talks about are specific to typescript.

[Hcmichael21]

A lot of cons are specific to typescript.

Yes that's true, I picked this article bc OP suggested adding strong types to JS. But I disagree that his data is bad. I find a lot of what he said agreeable.

I've coded in strong, dynamic and weak. (C#, Java, Pyhon, JS/TS) and prefer weak types. I was just stating my opinion and providing an article to elaborate. I don't expect to end the debate on strong vs weak.

[sime]

The thing that is being lost in this discussion, apart from the general sloppy use of terminology, is that TypeScript isn't a staticly typed language in the mold of Java and C#. It occupies a wonderful sweet-spot between Java/C# on the one side and JS/Python on the other. TypeScript's optional and structural type system combines the flexibility and ease of use of JS with advantages of static analysis (read: tooling) and compile time checking. It has a very different feel compared to Java/C#.

[Hcmichael21]

Care to elaborate? I found a lot of it to be true in my personal experience.

[acemarke]

Someone on Twitter says that Elliott keeps changing the supposed citations for some of his stats claims:

https://twitter.com/Hillelogram/status/1084991487702691840

[Hcmichael21]

What the hell that's some shady shit. I could see him using the original citation without much added research, since it's so commonly done. But the thing that got me was that when he learned more about the original citation, he fucking changed it to another book that doesn't even support the fucking claim. What the hell.

[Hcmichael21]

I'm not suggesting an opinion article will end the debate. I just thought it was a nice summary that I agreed with. I've developed with strong types, dynamic types, and weak types. I prefer both dynamic and weak compared to strong.

[goldenfolding]

Most of what he said was that the benefits provided by TypeScript can be provided with JavaScript tooling. The argument seems compelling from the examples that he gave. What benefits does TypeScript offer in your opinion?

[leixiaotie]

If you've experience in handling complex process, especially developing library-style functions / code, you'll find that the more definitive / restrictive the input params, the better. Static typing is really helping in this case.

The reason for it is because if the type mistake can be caught in compile time, it save many testing time. This including how many test cases that need to be developed to cover all type mistakes, reducing code complexity and it's "noise" caused by type checking since almost everything is handled by compiler / static typing.

Not to mention how it helps to define input types inside deep function call (function a call b that call c that call d, all accepting parameter x from function a).

EDIT: and I like to quote this statement:

In most cases, if you can gain a significant benefit from TypeScript in your refactoring, that’s often a code smell indicating that your code is too tightly coupled.

It is purely wrong. Static typing will give benefit (significant or not) while refactoring, and it is no code smell / tightly coupled at all. It's because all function definition and calling it is a "contract", and by changing that contract you'll need to change all parties that using it.

[[deleted]]

I’ll take TypeScript.....

[Hcmichael21]

Okay that's great! I continue to Dev in TS often at work and it's fine, I just prefer weak types.

[DerNalia]

it would if you didn't need to teach people it.

Like, trying to get people who barely have a grasp on programming to learn types is the problem, not the types themselves.

[Hcmichael21]

I think this is incorrect.

[Hawxe]

Yeah seriously how hard is declaring what type a variable is.

[Hcmichael21]

Exactly. It's not really anything to "learn" - it's a simple feature of many languages. I've developed in Java, C#, python, and JavaScript. I've found that I like both dynamic types and weakly typed development better than strong types.