Is TypeScript worth it?
Tags: typescript
Published: 2020-01-17 14:39:54

---
title: Is TypeScript worth it?
published: true
date: 2020-01-15 14:56:49 UTC
tags: typescript
canonical_url: https://blog.logrocket.com/is-typescript-worth-it/
cover_image: https://thepracticaldev.s3.amazonaws.com/i/07z8gvjjumfr7jz3v9hs.png
---
**Written by [Paul Cowan](https://blog.logrocket.com/author/paulcowan/)**✏️

Before I start, I would like the jury to know that I am, for the most part, a TypeScript fan. It is my primary programming language for frontend React projects and for any backend Node work that I do. I am on board, but I do have some nagging doubts that I would like to discuss in this post. I have programmed in nothing but TypeScript for at least three years now across numerous contracts, so TypeScript _is_ doing something right or is fulfilling a need.

TypeScript has defied some insurmountable odds to become mainstream in the realm of frontend programming. TypeScript is no.7 in [this post](https://www.agiratech.com/most-in-demand-programming-languages-learn-2020/) that lists the most in-demand programming languages.

Whether you use TypeScript or not, the following practices should be in place for any software team irrespective of size:

- Well written unit tests should cover as much of the production code as is deemed reasonable
- Pair programming– an extra set of eyes can catch a lot more than syntactical errors
- A good peer review process — proper peer reviews catch many bugs that a machine cannot
- Use of a linter such as [eslint](https://eslint.org/)

TypeScript can add an extra layer of safety on top of these, but I feel it’s last by a country mile in the list of in-demand programming languages.

[![LogRocket Free Trial Banner](https://i0.wp.com/blog.logrocket.com/wp-content/uploads/2017/03/f760c-1gpjapknnuyhu8esa3z0jga.png?resize=1200%2C280&ssl=1)](https://logrocket.com/signup/)

## TypeScript is not a sound type system

I think this is possibly the main problem with the current incarnation of TypeScript but, first of all, let me define what _sound_ and _unsound_ type systems are.

## Soundness

A _sound_ type system is one that ensures your program does not get into invalid states. For example, if an expression’s static type is `string`, at runtime, you are guaranteed only to get a `string` when you evaluate it.

In a sound type system, you should never be in the position at compile-time **OR RUNTIME** where the expression does not match the expected type.

There are, of course, degrees of **soundness** and soundness is open to interpretation. TypeScript is sound to a certain degree and catches the type errors below:

```jsx
// Type 'string' is not assignable to type 'number'
const increment = (i: number): number => { return i + "1"; }

// Argument of type '"98765432"' is not assignable to parameter of type 'number'.
const countdown: number = increment("98765432");
```

## Unsoundness

Typescript is entirely upfront about the fact that 100% soundness is not a goal and non-goal no.3 on the list of [non-goals of TypeScript](https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals) clearly states:

> Apply a sound or “provably correct” type system. Instead, strike a balance between correctness and productivity.

What this means is that there is no guarantee that a variable has a defined type during runtime. I can illustrate this with the following somewhat contrived example:

```jsx
interface A {
    x: number;
}

let a: A = {x: 3}
let b: {x: number | string} = a; 
b.x = "unsound";
let x: number = a.x; // unsound

a.x.toFixed(0); // WTF is it?
```

The above code is _unsound_ because `a.x` is known to be a number from the `A` interface. Unfortunately, after some reassignment shenanigans, it ends up as a string, and the following code compiles but errors at runtime.

Unfortunately, the expression shown here compiles without any error:

```jsx
a.x.toFixed(0);
```

I think this is possibly the biggest problem with TypeScript, as soundness is not a goal. I still encounter many runtime errors that are not flagged by the `tsc` compiler that would be if TypeScript had a sound system. TypeScript has one foot in both the sound and unsound camp with this approach. This halfway house approach is enforced with the `any` type, that I’ll mention later.

I still have to write just as many tests, and I find this frustrating. When I first started getting TypeScript, I wrongly concluded that I could stop the drudgery of writing so many unit tests.

TypeScript challenges the status quo, claiming that lowering the cognitive overhead of using types is more important than type soundness.

I understand why TypesScript has gone down this path, and there is an argument that states that the adoption of TypeScript would not have been as high if a sound type system is 100% guaranteed. This is disproved as the [dart language](https://dart.dev) is finally gaining popularity as Flutter is now widely used. Soundness is a goal of the dart language which is discussed [here](https://dart.dev/guides/language/sound-dart).

Unsoundness and the various ways that TypeScript exposes an escape hatch out of strict typing make it less effective and unfortunately make it **better than nothing** right now. My wish is that, as TypeScript gains popularity, more compiler options are available to enable power users to strive for 100% soundness.

## TypeScript does not guarantee any runtime type checking

Runtime type checking is not one of TypeScript ‘s goals, so this wish will probably never happen. Runtime type checking would be beneficial when dealing with JSON payloads returned from API calls, for example. A whole category of errors and many unit tests would not need to exist if we could control this at the type level.

We cannot guarantee anything at runtime so this might happen:

```jsx
const getFullName = async (): string => {
  const person: AxiosResponse = await api();
  
  //response.name.fullName may result in undefined at runtime
  return response.name.fullName
}
```

There are some supporting libraries like [io-ts](https://github.com/gcanti/io-ts), which is great but can mean you have to duplicate your models.

## The dreaded `any` type and strictness option

The `any` type means just that, and the compiler allows any operation or assignment.

TypeScript tends to work well for small things, but there is a tendency for people to `any` type anything that takes longer than one minute. I recently worked on an Angular project and saw a lot of code like this:

```jsx
export class Person {
 public _id: any;
 public name: any;
 public icon: any;
```

TypeScript is letting you forget the type system.

You can blast the types out of anything with an `any` cast:

```jsx
("oh my goodness" as any).ToFixed(1); // remember what I said about soundness?
```

The `strict` compiler option enables the following compiler settings which do make things more sound:

- ` --strictNullChecks`
- `--noImplicitAny`
- ` --noImplicitThis`
- ` --alwaysStrict`

There is also the eslint rule [@typescript-eslint/no-explicit-any](https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/no-explicit-any.md).

The proliferation of `any` can destroy soundness in your typing.

## Conclusion

I must reiterate that I am a TypeScript fan, I use it on my day to day job, but I do feel it is coming up short and the hype is not entirely justified. Airbnb claims [38% of bugs could have been prevented by TypeScript](https://www.reddit.com/r/typescript/comments/aofcik/38_of_bugs_at_airbnb_could_have_been_prevented_by/). I am very skeptical of this precise percentage. TypeScript is not turbocharging existing good practices. I still have to write just as many tests. You could argue, I am writing more code, and I might have to write type tests. I am still getting unexpected runtime errors.

TypeScript offers above basic type checking, but soundness and runtime type checking are not goals, and this leaves TypeScript in an unfortunate halfway house with one foot in a better world and one where we currently are.

Where TypeScript shines is with good IDE support, like vscode, where we get visual feedback if we mistype something.

![Typescript error in VS Code](https://i0.wp.com/blog.logrocket.com/wp-content/uploads/2020/01/squigly.png?resize=352%2C128&ssl=1)<figcaption id="caption-attachment-12577">TypeScript error in vscode</figcaption>

Refactoring is also enhanced with TypeScript and breaks in code (such as changes in method signatures) are instantly identified when running the TypeScript compiler against the modified code.

TypeScript has enabled good type checking and is definitely better than no type checker or just plain eslint but I feel it could do much more and sufficient compiler options could be exposed to those of us who want much more.

* * * 
## Plug: [LogRocket](https://logrocket.com/signup/), a DVR for web apps
 
![LogRocket Dashboard Free Trial Banner](https://i2.wp.com/blog.logrocket.com/wp-content/uploads/2017/03/1d0cd-1s_rmyo6nbrasp-xtvbaxfg.png?resize=1200%2C677&ssl=1)
 
[LogRocket](https://logrocket.com/signup/) is a frontend logging tool that lets you replay problems as if they happened in your own browser. Instead of guessing why errors happen, or asking users for screenshots and log dumps, LogRocket lets you replay the session to quickly understand what went wrong. It works perfectly with any app, regardless of framework, and has plugins to log additional context from Redux, Vuex, and @ngrx/store.
 
In addition to logging Redux actions and state, LogRocket records console logs, JavaScript errors, stacktraces, network requests/responses with headers + bodies, browser metadata, and custom logs. It also instruments the DOM to record the HTML and CSS on the page, recreating pixel-perfect videos of even the most complex single-page apps.
 
[Try it for free](https://logrocket.com/signup/).
* * *

The post [Is TypeScript worth it?](https://blog.logrocket.com/is-typescript-worth-it/) appeared first on [LogRocket Blog](https://blog.logrocket.com).