Being typed means, well, TypeScript's variables have types and they are checked in compilation time. Types can seem to slow down development at first, and devs will say things like: "I know that this object has a name, don't bother me!". But as your code base grows as well as the number of developers, you might forget that one has object has a name field and another one doesn't, so now, you have two options: dig the code to discover every possible field of one object; or ask someone, and neither of these two options is viable in the long run. In this case, if the objects were typed you could easily check what it has or doesn't have. The conclusion about types is:
Types make your code more readable, therefore more maintainable
Types have an extra step of positive additions, and that's broader and better auto-completion since the code tells the editor directly what a type has or doesn't have, the editor can tell the dev with a function call is wrong, or you forgot to initialize some property in the constructor.
You know how you installed
Babel in every JS project for the last couple of years, in order to have some handy features like destructors, the same thing applies to TypeScript. Our friend TS has everything plain JS and Babel JS has and more, like functions that are only proposals. The image below explains a little better:
The tooling around TypeScript is amazing. The compiler accepts a lot of configurations out of the box, even path mapping, say goodbye to
../../../user.ts and hello to
src/entity/user.ts and even rules to avoid common errors like using the
any type excessively. And TSLint is a comprehensive tool to help developers standardize their code, helping your code base to feel like it was written by a single person.