[smt88]

I feel the exact opposite. It changed JS from a language I loathe to one I really like. There are no other mainstream languages with a similar type system, which means it's uniquely easy to do very complex things with type safety.

Even Rust is still nominally typed, which means you have a lot more boilerplate.

[austin-cheney]

I liked JavaScript before, but TypeScript is like a revelation. Type checking is great in general for preventing all kinds of errors, but the real power is in two areas:

1) Declaring functions with typed output and types on the arguments. This allows you to create large architectures with minimal confusion. It allowed me to write an OS in TypeScript.

2) Declaring message payloads as object interfaces. This imposes a set of predictability and consistency in your services. It's so obvious in hindsight, but before TypeScript I was putting all kinds of safe guards around my service payloads to account for unpredictability that really impacted how the application scaled.

I think where people discover the most challenges migrating to TypeScript is that it exposes some level of unnecessary complexity in prior practice and some people do incredibly weird things with their type definitions to make it feel more OOP.

[Southland]

I’m confused because the comment you replied to said “There are no other mainstream languages with a similar type system, which means it's uniquely easy to do very complex things with type safety.”, but with the examples you gave, I don’t see why other statically typed languages cannot do this. Or are you just referring to the benefits in general and not a TS specific aspect?

[smt88]

> I don’t see why other statically typed languages cannot do this

It's not that they can't (mostly), it's that it's much harder.

TypeScript gives you a lot of strict typing for free. You can just throw data around, and TypeScript keeps track of its type. If you paste a blob of JSON into TypeScript, there's a new type created behind the scenes, and you can even reuse it with very little extra code.

The magic parts are the structural typing (overlaps quite a bit with duck typing) and type inference. It means that even your basic JavaScript with zero type annotations are type-checked against each other. If you just feed JavaScript into TypeScript, you'll uncover a lot of errors you didn't know were there.