I was asking myself this same question a few years ago. I felt that ES6 provided a terse, declarative syntax, that in combination with unit tests was reliable enough. Dynamic typing kept the code looking clean and left most functions generic and reusable for several data types. However, as your code base starts to grow and more and more "ad hoc" data types are introduced. It starts to become very hard to maintain and refactor code because you have to keep long call chains in your head and you sometimes don't know if you can remove a field from an object without introducing a runtime error. In essence, the less strict a programming language is the more you will have to test explicitly all the time. On top of that JavaScript is really good at coercing types in weird ways.

So the main benefit that TypeScript brings is static typing. You make your code more explicit, thereby limiting the number of unintentional behaviors that are possible. The compilers type checker can suddenly take care of testing these extra constraints for you and you start removing this burden from your unit tests. As a matter of fact TypeScript has a pretty advanced type system, a magnitude better than the current Java version (14) or Go-lang. One of these features are union types (aka. coproduct, sum type, etc). This lets you represent your types as "this thing" or "this other thing". Returning a disjoint union can make your code even more explicit and thus further limiting the number of unintentional behaviors. A simple example of this is the head function that returns the first element of a list. Either you get the value or you get undefined if the list is empty. A better approach is to return a Maybe type which is either an instance of Just(<value>) or Nothing. This tells you that the code calling head needs to handle exactly two possible cases. Languages with even stronger type systems like Elm and Haskell can even enforce that your code won't compile unless you handle all the possible cases for any union type. So again the compiler helps you avoid more runtime errors.

So to conclude the benefits of using a language with strong static typing:

• Compiler helps you avoid runtime errors
• Substantially reduce number of explicit unit tests
• Better security and reliability by preventing unintentional behavior
• Let's you refactor code with confidence
• Code becomes more self-documenting

I've been feeling the same way and it was almost too simple for me. First, strongly typed languages are objectively better for catching errors during development instead of during production so a small amount of work upfront pays huge dividends later. But the easy part is how actionable it is.

Find a codebase that you want to convert. For me, it was a server that I wanted to convert to Firebase cloud functions to go serverless. I took my server.js file and copied it as server.ts. I created a simple tsconfig.json file in the root with some standard settings online and then I let the VS Code IntelliSense guide the migration. It was so much easier than I expected and I learned TypeScript as I was converting my codebase.

It was almost too easy and now I have all of the benefits of feature-rich and built-in assistance in my code-editor. Documentation on hover, clear and clean errors. This was only about 2 weeks ago and I am not sure I'd ever go back to Vanilla JS now. It was love at first use with me.

TypeScript is a superset of ECMAScript, so you can continue to code in your familiar ES6 code style and then slowly sprinkle in some types when you feel like it. No need to dedicate extra time to learn it. TypeScript gives you more options without taking any of the options you have in plain ES6 away.

typescript provides static typing

The benefits of Typescript are more pronounced for codebases that are large and require ongoing maintenance. Having said that, Typescript was recently voted #2 most loved language behind Rust. Learning it won’t feel like a chore. You’ll have fun, write more maintainable code, and probably look back and wish you’d done it sooner :)

I am a big advocate for TypeScript. It even became a job requirement for me. I would probably refuse to work on a JavaScript codebase again.

Just to add to the other pieces of advice:

1 - Compile-time errors

Typed languages give you compile-time errors on top of runtime errors. If your code compiles it means you already have cleared a few bugs before you even start running your app.

2 - Documentation

Having typed properly your code gives your documentation. You know what is the type that any variables hold, You know what is the return type of every function... With pure JavaScript, you often have to rely on naming conventions. With TypeScript, you can enter any codebase and straight away know the type of variables, the shape of objects, etc...

3 - Auto-completion

Types give you auto-completion. Using a third-party library or accessing properties of an object, your IDE, will give you all the possible options and will moan (compile-time error) if you try to access a property that is not defined or try to map over an object for example.

4 - Let you learn other languages more rapidly

As a JavaScript developer, it is often impossible to read a codebase of a different type-language (java, swift...) and understand. Understanding types will allow you to (more) rapidly understand other programming languages.

TypeScript is not perfect in my opinion as it is not part of the JavaScript language, and you often struggle in trying to stop Typescript "complaining". But the pros largely overweight the cons in my opinion.

One important thing in setting up TypeScript is making sure you enable strict rules. Such as "strictNullChecks", "noImplicitAny", "strictFunctionTypes". If you TypeScript configuration is too permissive, you might be ending up writing more code for not that much safety. Basically you want to catch as many errors as you can in compile-time and only run the app once you feel confident it should work.

Well, I am using Webstorm which has JSdoc support so I am getting type info in the IDE.

I don't need an extra layer of complexity and compilation in my code.

Type Inference can help in reducing TypeScript verbosity and make it look more like vanilla JavaScript. Directory Listing

I use TypeScript because:

• incredible developer tooling and community support
• actively developed and supported by Microsoft (yes, I like Microsoft) ;)
• easier to make sense of a TS codebase because the annotations provide so much more context than plain JS
• refactors become easier (VSCode has superb support for TS)

I've switched back and forth between TS and Flow and decided a year ago to abandon Flow completely in favor of TS. I don't want to bash Flow, however, my main grievances are very poor tooling (editor integration leaves much to be desired), a slower release cycle, and subpar docs and community support.

I use TypeScript because it isn't just about validating the types I'm expecting to receive though that is a huge part of it too. Flow (JS) seems to be a type system only. TypeScript also allows you to use the latest features of JavaScript while also providing the type checking. To be fair to Flow (JS), I have not used it, but likely wouldn't have due to the additional features I get from TypeScript.

We originally (in 2017) started rewriting our platform from JavaScript to Flow (JS) but found the library support for Flow was lacking. After switching gears to TypeScript we've never looked back. At this point we're finding that frontend and backend libraries are supporting TypeScript out of the box and where the support is missing that the commuity is typically got a solution in hand.

I use TypeScript because the tooling is more mature (the decision to discontinue TSLint in favor of moving all its checks to ESLint is a thoughtful and mature decision), there's a ton of examples and tutorials for it, and it just generally seems to be where the industry is headed. Flow (JS) is a fine tool, but it just hasn't seen the uptake that TS has, and as a result is lacking a lot of the nicer small things, like thorough Visual Studio Code integration, offered by TS.

We use Underscore because it's a reasonable library for providing all the reasonable helper functions missing from JavaScript ES5 (or that perform poorly if you use the default ES5 version).

Since we're migrating the codebase to TypeScript , we'll likely end up removing most usage of it and ultimately no longer needing it, but we've been very happy with the library.

We currently use TypeScript at work. Previously we used Flow (JS) but it was sometimes really difficult to make the types work the way you want. Especially non-trivial types were problematic. And the IDE support wasn't good, Flow took too much resources and sometimes remain stuck and do not show errors (I use Visual Studio Code). With TypeScript we almost do not have these problems. IDE support is superb, working with types is much easier and typing system seems more mature and powerful. There are some downsides (like partion inheritance etc.), but TS team is still pushing it forward. So for me TypeScript is clear winner.

I use TypeScript because it's adoption by many developers, it's supported by many companies, and it's growth. AngularJS, React, @ASP.NET Core. I started using it in .NET Core, then for a job. Later I added more Angular experience and wrote more React software. It makes your code easier to understand and read... which means it makes other people's code easier to understand and read.

I use TypeScript for Web Applications and for both frontend and backend because it has a lot of tooling around it and they really got the types and type safety right. Flow (JS) on the other hand lacks tooling and most of the times I scramble to find the right way of building my contracts in which TypeScript is very intuitive and natural. Additionally TypeScript is very similar to Java so your backend engineers and full stack engineers can work with it without much of context switch.

The only time I think Flow shines is (based on probably my outdated knowledge) Flow is/was the only option if you want/wanted to build a React Native application mainly because React Native transpiler at the time I was working with it would only work with flow.

I use TypeScript because I tried both on a Meteor project, and found the quantity of errors it enabled us to catch and the simplification of code it allowed was higher than Flow (JS).

I use TypeScript because it's the most mature/issue-free Javascript type-checker available, as far as I've seen.

I use TypeScript because of broad support, on tools, repos, community ... the only reason to consider flow is if you're a facebook employee

If you will start a project from scratch I recommend to use TypeScript. But, If you work with legacy projects written in JavaScript I recommend Flow (JS). Both tools have the same objective: reduce the bad code (which create illegible code, generate bugs e problems to maintenance). Flex helps you to avoid fall in bad codes, but TypeScript prevent you to c you to create bad codes. I believe cause this some JavaScript fans don't like TS, because TS block you to write some types o code. This is the fundamental difference between TS and Flow: Flow avoid problems, but no force. TS force you to prevent problems.

I use TypeScript because i love to program in Angular and used in node as well

I recommend TypeScript. When used correctly, TypeScript can enable your application to be scalable, easy to refactor, safe, and stable. One of the biggest draws of working with any typed language is that it forces you to think about your functions' inputs and outputs. This is invaluable as it can lead to more declarative, functional style code that ultimately can be easier to reason about.

TypeScript is however not a silver bullet. Just like anything new it takes time to fully understand the concepts of types, interfaces, abstract classes, and enums. In my experience engineers who excel when using TypeScript are those who have experience working with a statically typed language.