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 project to TypeScript is worth it.
What is TypeScript?
TypeScript (TS) is a programming language compiled to JavaScript (JS). It’s been developed and supported by Microsoft since 2012. So now the language is mature with a lot of new features released year by year.
TypeScript was created to bring class-based programming to the JavaScript world without breaking compatibility with existing JavaScript code. Apart from that, this JS superset added some OOP-related ideas inherited from C#. This happened under the influence of C# engineers participating in the TypeScript development.
TS and JS application setup
Setting up a TS app is similar to a JS one. All popular frameworks have tools for generating and scaffolding TS 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 TS 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 JS to TS
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.
Js vs.TS 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.
TS support in third-party libraries
Major JS frameworks and libraries—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.
TS vs. JS bug fixing efforts
Debugging and 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.
Developers 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, TS 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 JS 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 JS 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.
