TypeScript sucked out much of the joy I had writing JavaScript
twitter.comI 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.
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.
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?
> 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.
Anyone try out the tenets in Reliable Javascript (2015), pre-Typescript?
The authors praise--and begin with an example from--D3.js, and work through handrolled dependency injection, aspects, and test-driven development with Jasmine.
Truly understanding `this`, .bind, .apply, and .call may be essential to a mastery of (vanilla) Javascript.
And "prototype" and closures.
Never have I related less with a take. TypeScript has elevated a truly mediocre language to being the one I am most productive in because its type system strikes such a nice balance. Where is the joy in looking at a variable named `opts` and having no clue what properties it can have?
This is the same typed vs. untyped argument which is as old as vi vs. emacs. Different devs have different requirements and preferences. Neither is "wrong". Some people are just naturally anal retentive pedants who must know their code is correct while writing it, even if it means downloading 500mb of build tools and requiring a jury rigged non-standard transpilation step for it to run. The fact that there's not a single example of a well written non-bloated open source project that uses TypeScript won't put them off, and that's perfectly OK! To each their own! Having yet another flame war about it, no matter how deluded many devs are, is just unproductive.
Rather than defend JavaScript, I just want to say that learning Ruby, and Rails, to me was an amazing experience. I've always enjoyed programming, and I've always preferred loosely typed languages, it was really fun to learn Ruby+Rails because it sets out to maximize the amount of joy that you can have writing code. That mindset is normally constrained to people writing hobby projects in uncommon languages. I think Rails is unmatched in striking a balance between code that is fun to write, and yet extremely productive.
(For those who don't know, the tweet author is the Rails creator.)
Writing TypeScript can be a bit hard or difficult at times. You can definitely get sucked into battles trying to figure out a lot of dumb shit that obviously works great but that you need to contort to something TypeScript can grok. Some of the errors it complains about are awful.
But on the other side, writing code consuming TypeScript libraries is amazing. Seeing all the type information in the IDE reveals so much, resolves so many questions, and builds confidence so quickly.
The other issue with TypeScript is that tooling is all awful & terrible. Tsconfig is a drag. There's a serious lack of good conventions to follow & tons of ad-hoc stringing shit together. Ideally libraries should output both esm & cjs but typescript literally doesn't support it & you have to run typescript twice, so now you maybe are introducing yet more new tools like concurrently if you want to do a good job. Oh and now your "watch" script is even more janked up too. Deno does a good job of making this pain all go away, but in general TypeScript is one of multiple layers of tooling that simply sucks, that thieves energy & attention.
“I can’t pretend my shitty code actually works and get pissy when my coworkers don’t intuitively understand the garbage I’ve written”
General response to this is assuming the contrarians don't like type or see no type benefit. But there are those who love static typing enough to dislike Typescript. It's ugly and unsound, how could someone loves static type to death likes Typescript.