Is TypeScript a fad or is my manager delusional?

Imo they'll add typing to vanilla js, which will kill ts.

CoffeeScript was a fad because it didn’t solve anyone’s problems. It was basically “look how cool code you can write”.

TypeScript is gaining popularity because static typing solves real problems. It’s also a superset of JavaScript instead of being a completely new language from scratch, which makes it easier for JavaScript devs to learn.

CoffeeScript wasn't a fad, it just became obsolete because JS adopted the syntax sugar CoffeeScript was selling. In a way, it did its job.

Developers are still catching up, but it will be one-way traffic from here.

Honestly I disagree, maybe I exist in a bit of an echo chamber, but it seems like since around ES2020 or so (some) people have been transitioning from TS to write JS with JSDoc and modern JS style rules.

I've basically transitioned to Go for work(where I can), but don't really mind writing modern JS

that will /should probably make their way into JS.

Not really, IMHO. The main advantage of TS is that it will help you catch errors without having to run a particular piece of code - i.e. you won't have to move to the third page of some multi-page form to discover a particular bug. In other words, it helps you catch bugs before your code even reaches your browser, so it doesn't bring you much to have them in the browser.

(There is a proposal to allow running TS in the browser, which would be nice, but you'd still run a type checker separately to actually catch the bugs.)

Hoping this is true. The biggest annoyance with typescript is needing some kind of compiler. Haven't used Bun or Deno very much, both of which natively support TS, but there are still incompatibilities with the way Node does things and how certain modules were built (CommonJS vs ESM). I like writing JavaScript but the tooling is utter crap.

Your manager is a fad.

If only...

Some of us are old enough to remember the browser wars and EEE, so I definitely understands not wanting to be sucked into some mega corps eco system with future lock-ins. Often you can't do anyhhing else, but that doesn't mean it doesn't suck.

I mean it is fair to say sometimes it depends on the mega corp, if the whole thing relies on one corp if they're funding dries up then the whole project dies. But I also don't really think typescript would die without Microsoft now

[Object object] would like a word

Can't they just use JSDoc?

Dynamic typing is not a fad.

Python is older than Java, older than me. It is still going strong.

It might not be a fad, but it's definitely a local maximum and/or a limitation that many devs seem to be stuck with.

So there is no productivity loss/learning curve unless you want there to be.

It's not significant but an extra build step can be annoying

Even then, it just leaves behind an illegible mess that the next dev has to gut and replace with typescript later. If someone wants to use JS on their hobby project, go for it. The extra tools that types enable are super valuable for a team.

TypeScript sometimes is the testing ground for the future features of ECMAScript

They have an explicit policy to only include features that are stage 3 already (i.e. that are pretty much certain to land in the language as-is). The only times they've diverged from this is long in the past (I think enum is the main remnant of that, for which I'd recommend using unions of literal string types instead), and experimentalDecorators under pressure from Angular - which has always been behind a flag explicitly named experimental.

So I really wouldn't worry too much about that.

The issue with TypeScript/Sass etc. is that it requires a compiler and that’s totally obnoxious and completely defeats the point of having interpreted code on browsers.

Shouldn't WebAssembly be a solution to this? I.e. so you don't have to interpret code but rather run the wasm binary (which is kinda interpretation as well but you get what I mean).

MSFT is known for changing names a lot, but not for killing technologies.

Silverlight would like a word ;)

I strongly disagree with this, web dev is great because you can serve hundreds of different devices with the same code, I can't imagine developing native solutions to each one, yikes

You should check out Google Web toolkit, totally signs like your kind of thing.

Typescript is for people who hate JavaScript, for the most part. The bulk of the people who have been writing JavaScript for years and aren't Java converts are still using JavaScript and will continue to do so. The Java developers will continue writing Java, no matter what language they are programming in.

The point of calling something is fad is a way to tell you that you shouldn't invest a lot of time into this because that knowledge will become obsolete soon.

I mean this is particularly relevant in the JS world because every week there's a new revolutionary framework that renders the previous framework obsolete. (Although, not sure if that's slowing down now...)

Unfortunately when it comes to my manager, I can't just ignore what he says as his opinions actually has an influence on what technology we use and such.

When will Wasm grow, according to your gut? I feel like I've been waiting for a decade now.

I think you've got a point here, in that the sort of Devs who want to be able to refactor their code without breaking everything are also going to be the group who lean more into having code that actually runs quite fast; but given that reasonML is awesome and didn't get much mindshare my position here is that wasm will only start to eat into tyspecript's lunch well after a huge subset of TS can be compiled to wasm (or maybe python ((I blame the xkcd guy for python's unreasonable popularity, I feel it's hugely overrated))).

They already said he is a manager, no need to repeat

20 years into the future, once WASM has been widely adopted, a browser within a browser will have been created, with its own equivalent javascript, which will then lead developers to create a WASM equivalent for a web browser running in a WASM browser, running on a bloated OS.

We use TS on the back end to leverage our teams existing skill set and libraries we've built up.

I know you said this, but I'm still curious why not just something like Go, which I was able to basically learn in 3 days- just coming from a mostly JS and C++ background

But it's so sexy. Strongly typed language? *Scoff

I honestly think this is fearmongering. Yes, Microsoft is a shitty company that has done shitty things, but:

• the Typescript repo is licensed with Apache 2.0, which means the community can always fork it if they do bad/evil stuff
• there are competing type checkers in the works, which would fully remove any Microsoft influence from a developer using Typescript
• there already are competing compilers which are broadly used

The only real option they have to do what you're describing is to implement new features that could be used for monetizing it - there would be some inertia regarding community forks. But even then I can't come up with any monetization model that could make sense. Do you have a specific example in mind?

That's just Typescript with extra steps.

Though I have also done this once or twice for single-file projects where I didn't want to deal with actually running tsc. It has some annoying downsides though, e.g. you don't get to have a tsconfig.json and the syntax sucks.

Microsoft had a proposal to allow TS annotations in JavaScript which would have been awesome and fixed the syntax issue.

Looks like it was discussed a year ago and hasn't really made much progress. Seems like lots of people wanting to shoehorn runtime type checking onto it.

What's so special about Ocaml's type system?

Is there some huge benefit that I’m missing?

For example I recently fixed a bug where a function would return an integer 99.9999% of the time, but the other 0.0001% returned a float. The actual value came from a HTTP request, so it started out as a string and the code was relying on dynamic typing to convert that string to a type that could be operated on with math.

In testing, the code only ever encountered integer values. About two years later, I discovered customer credit cards were charged the wrong amount of money if it was a float value. There was no exception, there was nothing visible in the user interface, it just charged the card the wrong amount.

Thankfully I'm experienced enough to have seen errors like this before - and I had code in place comparing the actual amount charged to the amount on the customer invoice... and that code did throw an exception. But still, it took two years for the first exception to be thrown, and then about a week for me to prioritise the issue, track down the line of code that was broken, and deploy a fix.

In a strongly typed language, my IDE would have flagged the line of code in red as I was typing it, I would've been like "oh... right" and fixed it in two seconds.

Yes — there are times when typing is a bit of a headache and requires extra busywork casting values and such. But that is more than made up for by time saved fixing mistakes as you write code instead of fixing mistakes after they happen in production.

Having said that, I don't use TypeScript, because I think it's only recently become a mature enough to be a good choice... and WASM is so close to being in the same state which will allow me to use even better typed languages. Ones that were designed to be strongly typed from the ground up instead of added to an existing dynamically typed language.

I don't see much point in switching things now, I'll wait for WASM and use Rust or Swift.

Can’t you just use try/catch blocks

No, because what if whatever you're calling is updated and suddenly it throws a new exception where before it didn't? Python or JavaScript or other interpreted languages will never warn you about that.

if the data structure of whatever you’re working with isn’t what you expected?

That sounds like a whole lot of boilerplate I have to write to verify every time that something is what I expect. Static typing does that for me much easier and more reliably.

Some languages like Rust have so good type systems that often when a program compiles, it just works. You don't have to run the code to know that it functions if you only make a small change.

What kind of systems have you worked in? In small systems, the static analysis doesn't matter as much, but the benefits become bigger and bigger the more code there is to analyze.

Let me reverse this question and ask what is the benefit of dynamic typing? What is gained from vaguely defined objects?

The purpose of typed languages is to ensure the bare minimum when it comes to safety. That when you're accessing a field of an object that field is real, and that field is always going to be an int or a string.

Try/catch only goes so far before it becomes way more cumbersome than necessary, as is checking every field of an object.

Typescript is an example of a language that does static typing poorly, because by design it has to. It's a quick bandaid fix over an inherently awful language.

I like typescript because my API can generate types for my FE project.
So, if i change my API, i pull in fresh types and fix the errors, and i get in-ide hints for the shape of payloads, responses and events. Not everything is simple CRUD.
Also, if you pull in a library, having types is a godsend

Interesting argument. I have used both typescript and JavaScript, but I spend 99% of my time writing firmware in C, because of this I LOVE strongly typed languages, and I get kinda annoyed/paranoid when my variable COULD change type quietly so end up doing (perhaps too much) type checks etc.

I can say with surety I hate programming in both Typescript and JavaScript, but I definitely hate Typescript less because of the typing.

Having said that, I don't really like the compiled javascript that comes out of the typescript compiler, because it puts some distance between the user and the code and I am all for clarity, especially when people have to go out of their way to not run this code.