Is migrating your app from JavaScript to TypeScript worth it?

Photo by Greg Rakozy on Unsplash

Companies that build large apps often prefer using TypeScript over JavaScript to keep their codebases tight. But why do they use TypeScript and should you follow their example?

Let’s compare JavaScript vs. TypeScript from the development and business perspectives to learn if migrating your engagements to TypeScript is worth it.

What is TypeScript?

TypeScript is a programming language compiled to JavaScript. It’s been developed and supported by Microsoft first since 2012. So now the language is matured, with a lot of new features released every year.

TypeScript was created to bring class-based programming to the JavaScript world without breaking compatibility with existing JavaScript code. Apart from that, this JavaScript superset added some OOP-related ideas inherited from C#. This happened under the influence of C# engineers participating in the TypeScript development.

TypeScript and JavaScript application setup

Setting up a TypeScript app is similar to the same process conducted with JavaScript. All popular frameworks have tools for generating and scaffolding TypeScript projects. Developers just need to select required options for the new project in their command-line tool. The boilerplate code is then generated automatically.

However, not all project setup tools provide out-of-the-box support for TypeScript. Sometimes developers have to take additional actions to get TypeScript to work in your application. For this, they usually follow instructions from the selected framework’s manuals. Those additional requirements and settings are quite simple and quick to complete.

Migrating from JavaScript to TypeScript

TypeScript and JavaScript can be used together in one project, which makes migration smooth and gradual. You can rewrite your application code into TypeScript module by module, file by file, or even have JavaScript and TypeScript mixed in one file. It means you can retain old parts of your project in JavaScript and write new modules in TypeScript. It won’t break anything in your app.

JavaScript vs.TypeScript development speed

Writing TypeScript code requires additional effort compared to JavaScript. This is because developers should add a type definition to every variable and function argument. Also, they should do type checking because frameworks and libraries they use may have specific types defined for their APIs.

If you need to speed up feature delivery, developers can skip type checking. But doing this leads to the accumulation of technical debt, which negates the benefits of TypeScript. Developers should avoid skipping type checks and do it only in exceptional cases: for example, when a third-party library they use doesn’t have type definitions.

Code quality and app maintenance

With time the codebase of any application grows. So does the technical debt. In TypeScript apps, the technical debt accumulates slowly. The presence of types in the code makes relations between different entities more clear. Therefore the code is easier to refactor. Apart from that, type annotations together with the code editor’s features make refactoring fast and less of a hassle.

TypeScript support in third-party libraries

Major JavaScript frameworks and libraries, such as React or Angular, have TypeScript support. Some even have their code written in TypeScript. Still, less popular libraries may have neither out-of-the-box nor community-built type definitions. To use them, developers have to spend additional time creating custom type definitions. Alternatively, they can skip type checking in the code where the library is used.

Sometimes after another release of a new version of a third-party package, its type definitions become outdated. This often leads to type check errors. That’s why it’s important to update your project dependencies with a prior check of TypeScript support.

TypeScript vs. JavaScript bug-fixing efforts

Debugging, or fixing bugs often takes a lot of time. It’s especially true for dynamically typed languages, such as JavaScript. It may take developers several hours or days before they find out that the app doesn’t work correctly because some variable is undefined. However, TypeScript helps to avoid such situations, as developers properly define types for all variables and function arguments.

Since TypeScript performs type checks at compilation time, it helps prevent runtime errors before the application is even started. This feature saves a lot of bug fixing time and makes a big difference between TypeScript and Javascript.

Developer skillset

TypeScript has a steeper learning curve than JavaScript. That’s the price to pay for its benefits. It’s harder for a developer to switch to TypeScript from other scripting languages, such as Python, Ruby, or PHP, than to JavaScript. This is because TypeScript is more alike with strongly typed languages like Java or C#.

On the downside, developers who previously worked with scripting languages need to embrace a new way of thinking. On the upside, developers with knowledge of statically typed languages can master TypeScript very quickly and take advantage of all their previous experience.

Project onboarding time

When new developers join the team it takes some time for them to dive into the code and reach maximum productivity. TypeScript has type annotations that make code more readable for a developer who is new to the project.

Type annotations help to understand the application code and data flow faster, especially in large projects. It allows to engage developers from another team or hire a freelancer and get them familiar with the application quickly.

Finding the right people

According to different ratings, JavaScript is several times more popular than TypeScript. This can be easily explained by its simplicity and low entry threshold. However, the popularity of TypeScript keeps growing. With time, TypeScript has every chance to become an industry standard.

JavaScript developers of junior and middle levels often don’t write code in TypeScript. However, the majority of senior JavaScript developers do. That’s because the more experienced developer is, the easier it is for them to learn new stuff. To build an app with TypeScript, you should hire senior JavaScript developers.

Conclusion

TypeScript brings a lot of benefits for large-scale applications. For example, it helps developers to write clean and properly structured code and reduces the number of potential bugs.

The migration process from JavaScript to TypeScript is very smooth and flexible, with almost no overhead.

Those benefits come at the price of slightly increased time for writing TypeScript code together with higher requirements for the developers’ qualification.