I started writing TypeScript in 2015, back when admitting that out loud in certain circles got you looks. It was barely past 1.0, the tooling was rough outside Visual Studio, and half the people I respected thought I’d lost the plot. I tried it on a side project, saw the editor catch a whole class of dumb mistakes before I’d even saved the file, and that was it. I was in.
The reaction was rough, and I don’t mean mild scepticism. I mean arms-folded, this-is-a-trap hostility from a decent chunk of the JavaScript world.
What’s easy to forget is how loud that was, because it’s almost completely gone now, and nobody seems to want to talk about where it went.
When Microsoft first showed TypeScript off in late 2012, the Slashdot headline literally called it “Microsoft’s Replacement for JavaScript.” That framing tells you everything about the mood. Plenty of people read it as an invasion. The top objection in every thread was the same three letters: EEE. Embrace, extend, extinguish. People had watched Microsoft do it before and were absolutely certain TypeScript was the embrace step, that one day the carpet would get yanked and we’d all be locked into some proprietary Microsoft dialect we couldn’t escape.
That fear felt reasonable in 2015. It just turned out to be wrong, and wrong for a boring technical reason. TypeScript compiles down to plain, standards-compliant JavaScript that runs anywhere. There’s no runtime, no lock-in, no Microsoft-only engine you have to ship. You can fork the compiler and run it on whatever you like. What people feared most was the one outcome the design made impossible.
The other big camp wasn’t worried about Microsoft at all. They were purists who thought adding static types to JavaScript was missing the entire point of JavaScript. There’s an old GitHub gist from that era, just titled “hate-typescript,” and it’s a perfect time capsule. The complaints are that TypeScript was inventing its own features that might never land in the real ECMAScript spec, that it had almost no community governance, that you’d end up sprinkling any everywhere so the “use as much or as little as you like” pitch was a lie, and that the real future was Babel plus Flow.
That last point is the one everyone forgets. TypeScript did not win by default. It had serious competition.
Google had AtScript, built for Angular 2, with its own take on annotations and runtime type checks. Facebook shipped Flow in 2015, and Flow had a strong argument: its type system was designed to be sound, where TypeScript openly chose to be unsound in places so it could stay practical and fast to adopt. There was Dart off doing its own thing. For a year or two it honestly wasn’t obvious which of these would be the one. A lot of smart people bet against TypeScript, and they weren’t being silly. They were reading the board as it looked at the time.
Then the board changed. In early 2015 Microsoft and Google announced they’d fold the AtScript work into TypeScript instead of competing, which is how we got decorators. Flow slowly lost momentum, partly because Facebook tuned it for Facebook’s enormous codebase and the rest of us found it slower and clunkier to live with day to day. By the time TypeScript 2.0 landed in late 2016 with proper null safety, the question had quietly stopped being “types or no types” and started being “which typed JavaScript.” TypeScript was already pulling away.
The numbers since then are almost comical. TypeScript first showed up on the Stack Overflow survey in 2016 with under one percent usage. The State of JS 2025 results, which dropped earlier this year, had 40% of respondents writing exclusively TypeScript, up from 34% the year before, and only 6% writing nothing but plain JavaScript. Two thirds now write more TypeScript than JavaScript. The survey’s own conclusion didn’t bother hedging it. The headline was simply that TypeScript has won, not as a tool, but as the language. A thing a vocal slice of the industry actively despised became the default way to write JavaScript inside a decade.
So, where did they all go?
Most of them converted, and they converted so gradually they don’t even register it as a change of heart. The funny part is almost nobody who hated TypeScript in 2015 will tell you “I was wrong, it’s great.” What happened instead is they took a job where the codebase already used it, or a library they depended on shipped types, or their editor started giving them autocomplete and inline errors for free and they slowly stopped noticing. By the time anyone thought to ask, they’d been writing it for years.
A smaller group didn’t convert, they just got drowned out. When the entire ecosystem moves, the people standing still don’t change their minds, they just stop being audible. The threads moved on without them. You can still find the holdouts if you go looking, but the centre of gravity left them behind years ago.
And then there’s the third group, the ones who still hate it and are loud about it on purpose. The most famous flare-up was DHH ripping TypeScript out of Turbo 8 in 2023. He said he’d never been a fan, that the source read better without it, and he merged the change in a couple of hours over the objections of contributors who’d written more of the codebase than he had. Rich Harris, who makes Svelte, called the move, and I’m quoting him exactly here, “user-hostile dickwaddery.” The whole thing kicked off for a week.
And even that, the most public TypeScript rebellion of the last few years, got treated as exactly what it was, an outlier. Svelte got dragged into the same story, but what Svelte did was different. They moved their source from .ts files to plain .js with JSDoc comments, while still running TypeScript to check everything. They kept the type checking and just changed how the files were written. That’s a team so committed to types they’re fine-tuning how they live with them, not one walking away.
That, more than any survey, is how I know the war is over. The argument isn’t “should JavaScript have types” anymore. Nobody serious is having that fight. The argument now is about syntax and ergonomics and where the types should live, which are the kind of squabbles you only get to have once everyone already agrees on the fundamental thing. There’s even a TC39 proposal to let JavaScript itself carry type annotations and just ignore them at runtime. It’s still early, sitting at stage one, so don’t hold your breath. But the direction is the tell. And while the committee takes its time, Node.js went ahead and shipped native TypeScript execution anyway, stripping the types out as it runs, stabilised in v25 late last year. You can now hand a .ts file straight to Node and it just works. The proprietary Microsoft trap everyone panicked about in 2015 ended up baked into the runtime almost everyone uses, with no Microsoft anywhere in sight.
I don’t think the haters were stupid, for what it’s worth. Some of their concerns were fair. DefinitelyTyped was a maintenance headache for years. You really can any your way out of any guarantee if you’ve got no discipline. The early tooling was painful. They were right about the warts. They were just wrong about the warts being fatal, and they badly misread how much developers would value catching a typo before runtime once they’d felt it a few times.
I got lucky on this one. I picked the right horse in 2015, mostly on a gut feeling about that first editor experience rather than any grand insight. I didn’t win anybody over though. The argument resolved itself while everyone was busy shipping, and one day I looked up and the people who used to fight me about it had stopped mentioning it.
Which is how most of these tech wars end. The losing side rarely gets convinced or beaten. They just get older, take new jobs, inherit a codebase that already made the call, and one day notice they’ve been on the other side for years without ever deciding to switch.