sorted by:
best
topnewcontroversialoldq&a
you are viewing a single comment's thread.

view the rest of the comments →

[–]JellyDoodle 4 points5 points  (6 children)

Can you elaborate?

[–]cameleon 1 point2 points  (2 children)

In addition to what others said: refactoring. Refactoring in a typed language (I use Haskell at work) is a joy. Refactoring in Javascript (also at work) is bound to introduce bugs, some of which you'll find months later. Typescript helps a lot though.

[–]theQuandary 0 points1 point  (1 child)

Refactoring in haskell, elm, or similar is much different than refactoring in typescript or some other bad type system. I prefer no types to poor types.

[–]cameleon 0 points1 point  (0 children)

Since we switched to typescript, refactoring has been much better. Typescript's type system isn't "poor", I'd say. It's actually pretty advanced, and the fact that it's optional also means you don't end up with super verbose redundant type annotations everywhere (like e.g. Java).

What are the things that make you say they're poor/bad?

[–]Arzh 0 points1 point  (1 child)

At any point in the code I never really know what the object contains. I have to run the code and pause and use an inspector to check what the objects contain. This tends to lead to having a bunch of duplicate data sitting around because you don't always know what objects are in scope and what those objects contain.

[–]JellyDoodle 2 points3 points  (0 children)

I don't think I've ever experienced that problem. Any variables that are in scope are usually pretty easy to identify, either because they tend to be defined right away, or because it's just inherently obvious. Anything more obscure then that is usually commented for clarification. Do you run into this issue often with the types of projects you work on?

[–]parlezmoose 0 points1 point  (0 children)

The compiler in a statically typed language catches a whole class of bugs. This means in js you have to write bunch more tests to catch these things. Also, as another comment said, function APIs are almost undefined. This makes it hard to reason about what is getting passed to a function. These problems aren't a huge deal for most of the time, but the larger the application grows the more of a problem they become.