Introduction

In October 2012, Microsoft made an announcement that would change the direction of JavaScript development: TypeScript. At the time, teams maintaining large JavaScript applications were facing an increasingly obvious problem — code that grew quickly and became impossible to maintain without static typing. TypeScript was created precisely to address that pain, promising to bring the safety and maintainability of static typing without abandoning the JavaScript ecosystem. More than a decade later, it has become the de‑facto industry standard. This is the story of how an internal experimental project became the foundation of virtually every modern framework.

2012: TypeScript was born

TypeScript was created by Microsoft in 2012 with the goal of providing a language that is compatible with JavaScript but adds static typing. The idea was to enable developers to write code that is safer and more maintainable without sacrificing JavaScript’s flexibility and dynamism. TypeScript was released as an open‑source project and quickly attracted attention from the developer community.

Anders Hejlsberg and gradual typing

One of the main architects behind TypeScript was Anders Hejlsberg, a well‑known software engineer who worked on projects such as Delphi and C#. Hejlsberg is a proponent of gradual typing, which lets developers use static and dynamic typing together, according to the project's needs. This approach was crucial to TypeScript's success, because it allowed developers to start using the language without having to rewrite all existing code.

Initial resistance from the community

However, the developer community was not immediately receptive to TypeScript. Many developers saw the language as a threat to JavaScript's flexibility and freedom and feared that static typing would make code harder to write and maintain. Additionally, there were concerns about TypeScript's compatibility with existing libraries and frameworks. In my experience, it took some time for the community to be convinced of TypeScript's benefits, but eventually the language gained acceptance.

Angular 2 used TypeScript

One of the main factors that contributed to the adoption of TypeScript was the Angular 2 team's decision to use it as the official language for the framework. It was a masterstroke, because Angular 2 was one of the most popular frameworks at the time, and adopting TypeScript helped increase the language's visibility and credibility. The Angular 2 team worked closely with the TypeScript team to ensure the language met the framework's needs, and this helped establish TypeScript as a viable language for developing complex applications.

The ecosystem adopted

As the language gained acceptance, the ecosystem around TypeScript began to grow. Popular libraries and frameworks, such as React and Vue.js, started supporting TypeScript and the developer community began creating their own libraries and tools for the language. This helped establish TypeScript as a mature language ready for production use.

---

TypeScript 5.x and the future

These days, TypeScript is a mature and stable language, with an active community and a rich ecosystem. The 5.x version of TypeScript introduced a series of improvements and new features, including support for decorators and enhancements to type inference. In my experience, TypeScript is a language that continues to evolve and improve, with an active development team committed to making the language increasingly useful and effective.

Code Examples

To illustrate how TypeScript can be used in a real project, let's consider a simple example. Suppose you're building an application that needs to handle a list of users. With TypeScript, you can define an interface to represent a user and use static typing to ensure the code is safe and maintainable.

interface Usuario {
  nome: string;
  idade: number;
}

const usuarios: Usuario[] = [
  { nome: 'João', idade: 30 },
  { nome: 'Maria', idade: 25 },
];

function imprimeUsuarios(usuarios: Usuario[]) {
  usuarios.forEach((usuario) => {
    console.log(`Nome: ${usuario.nome}, Idade: ${usuario.idade}`);
  });
}

imprimeUsuarios(usuarios);

This example demonstrates how TypeScript can be used to create safe, maintainable code, with the help of static typing and type inference.

Practical Tips

In practice, I've worked on many projects that used TypeScript and I can say that the language is a powerful tool for any developer. Here are some practical tips for those who are starting to use TypeScript:

• Start with a small, simple project to get familiar with the language and ecosystem.
• Use static typing whenever possible, as it helps ensure code safety and maintainability.
• Learn to use type inference, as it can help reduce the amount of code you need to write.
• Leverage existing libraries and frameworks for TypeScript, as they can help speed up development and reduce code complexity.

Conclusion

In short, TypeScript is a language that has gone from an experimental project to an industry standard. With the help of gradual typing and type inference, TypeScript is a powerful tool for any developer who wants to write safe, maintainable code. Here are the main takeaways from the article:

• TypeScript is a language that was created by Microsoft in 2012 to provide a safer, more maintainable alternative to JavaScript.
• Gradual typing is a core feature of TypeScript, as it allows developers to use static and dynamic typing together.
• The ecosystem around TypeScript is rich and active, with many popular libraries and frameworks that support the language.
• TypeScript is a mature and stable language, with an active development team committed to making the language increasingly useful and effective.
• TypeScript can be used in a variety of projects, from web applications to mobile and desktop applications.