TypeScript Guide

An overview of TypeScript (the language superset of the language JavaScript) from my perspective and experience.


TypeScript is a language I've used daily from my software creation toolbox daily since 2020 for all of Murmur Labs projects and all of my side projects.

Hello there, fellow developers!

Have you ever found yourself struggling with the loose nature of JavaScript?

If so, let's introduce you to TypeScript.

TypeScript is a statically-typed superset of JavaScript.

It's like JavaScript, but with a twist that adds a layer of reliability and efficiency to your code.

The goal of TypeScript is to help catch mistakes early through a type system and to make JavaScript development more efficient.

But why should we bother learning TypeScript, especially when we're already familiar with JavaScript?

The benefits lie in TypeScript's ability to enhance code readability, reduce errors, and improve the development experience.

But, as with all good things, there are trade-offs to consider.

So, are you ready to understand what TypeScript is all about, why it could be a preferable alternative to JavaScript, and what considerations you should keep in mind when choosing it?

Let's dive into this world of TypeScript together, and take a look at how it can transform your JavaScript coding experience.

A Brief Background of TypeScript

Once upon a time in the world of programming, around 2012 to be precise, Microsoft saw the increasing complexities in JavaScript applications and decided to step in.

The company set out to create a tool that would bring order to the chaos, a tool that could handle larger JavaScript projects with ease, a tool that we now call TypeScript.

The brains behind TypeScript desired to make JavaScript development more similar to statically-typed languages, such as C# or Java.

The goal was simple: keep JavaScript's flexibility, but add a layer of safety to prevent common bugs that developers face due to JavaScript's dynamic typing.

TypeScript was designed to be a superset of JavaScript, meaning every JavaScript program is also a valid TypeScript program.

TypeScript just adds some extra features, the most notable being static types.

Since its inception, TypeScript has steadily grown in popularity among developers.

As of now, it's been adopted by major companies like Google, Microsoft, and Airbnb, and is used in popular frameworks like Angular and Vue.js.

In the subsequent sections, we'll dig deeper into what TypeScript is, explore why it's an appealing alternative to JavaScript, and discuss some trade-offs that come along with its use.

So, as you navigate the fascinating landscape of programming languages, TypeScript is indeed a compelling pit stop.

In-Depth Explanation: Unraveling TypeScript

TypeScript, as the name might suggest, places a great emphasis on "types".

It's a statically-typed language, which means you assign a type (like number, string, boolean) to your variables, function parameters, and function return values.

This type-checking feature is the cornerstone of TypeScript, and it’s what sets it apart from JavaScript.

At its core, TypeScript is a superset of JavaScript.

This means that it includes all JavaScript functionalities, with the added benefit of static typing.

If you have a JavaScript file, you can essentially rename it to a TypeScript file (with a .ts extension), and it would be valid TypeScript code.

But the true power of TypeScript comes when you start using its typing system.

The TypeScript compiler (also known as the tsc) is your silent, backstage helper.

It checks your TypeScript code for errors and then compiles it down to plain JavaScript, which can run in any environment where JavaScript runs – browsers, Node.js, etc.

One particularly handy feature of TypeScript is its robust tooling and editor support with autocompletion, type inference, and more.

This makes your code easier to navigate and refactor, and these tools can provide helpful hints or warnings about your code.

So in a nutshell, TypeScript is JavaScript, but with the bonus of static types, robust tools, and a friendly compiler helping you write better, safer code.

The Added Benefits of TypeScript

Now that we've covered the basics of what TypeScript is, let's delve a bit deeper into some of the key benefits that TypeScript offers over JavaScript: Generics, Type Safety, and Enumerated Types.


Just like in other statically-typed languages, TypeScript gives us Generics. This fantastic feature allows you to create components that can work with a variety of data types rather than a single one. Generics enhance code reusability while keeping a consistent type safety check.

Example: Generics In Action

Imagine you need a function that can take an array of any type and return the first element of the array.

In JavaScript, this function would look like this:

function getFirstElement(arr) {   return arr[0]; }  

const num = getFirstElement([1, 2, 3]); // we can pass in anything we want here!
const num = getFirstElement("test"); 
const num = getFirstElement(undefined); 

Plain JavaScript like this can cause a lot of frustration in both reading and debugging code.

Without generics, you could make the function take an array of any type, but then the function would also return any type, losing the information about the type of the array's elements:

function getFirstElement(arr: any[]): any {   return arr[0]; }  

const num = getFirstElement([1, 2, 3]);  // num is of type 'any', not 'number'

In this case, TypeScript doesn't know what type num is, so it can't help us catch any type errors we might make when using num later.

With generics, you can write the function in a way that maintains the type information:

function getFirstElement<T>(arr: T[]): T {   return arr[0]; }  

const num = getFirstElement([1, 2, 3]); // num is of type 'number'

In this version of the function, T is a type variable—a stand-in for any type. In the function body, T is used as the type of the array's elements and as the return type of the function. When we call getFirstElement with an array of numbers, TypeScript figures out that T should be number in this case, so it knows that num is a number.

As a result, we've created a function that works with any type of array and maintains the type safety of the array elements.

That's the power of generics!

Type Safety

The bread and butter of TypeScript is its type safety feature.

By enabling you to specify types for your variables and function returns, TypeScript makes your code predictable and less prone to runtime errors.

The TypeScript compiler checks your code and nags you about any potential type mismatches or dubious operations.

This acts as an early warning system before your code gets to production.

It helps reduce bugs and makes your code more readable and maintainable.

It's like having a friendly, yet strict, code guardian looking over your shoulder.

Example of Type Safety: Keeping Errors at Bay

TypeScript's primary selling point is its ability to enhance type safety.

But how exactly does it help? Let's illustrate this with an example.

Let's say we take the classic example of a simple JavaScript function that adds two numbers:

function addNumbers(a, b) {   return a + b; } 
const result = addNumbers(5, '7'); console.log(result); // Output: 57

The function addNumbers is supposed to add two numbers.

However, in JavaScript, due to dynamic typing, we can accidentally pass a string instead of a number. JavaScript tries to make the best of the situation and coerces the number 5 into the string '5' before performing the addition, resulting in the string '57'—which is probably not what we wanted!

Now let's see how TypeScript can save us from this subtle bug with type safety:

function addNumbers(a: number, b: number): number {   
	return a + b; 
const result = addNumbers(5, '7'); // Error: Argument of type 'string' is not assignable to parameter of type 'number'.

In this TypeScript version of the function, we've specified that both a and b should be numbers.

Now, if we try to pass a string as an argument to addNumbers, TypeScript will give us a compile-time error.

It helps us catch this bug before we even run the code, saving us from potential confusion and debugging time.

Through type safety, TypeScript serves as a friendly guardian, protecting us from unintended and hard-to-spot bugs.

Enumerated Types (Enums)

Enumerated Types, or Enums as they are more commonly called, are a feature not available in JavaScript but provided in TypeScript. Enums allow developers to define a set of named constants, making the code more readable and reducing the chance for errors.

They are particularly useful when you have a value that can only be one of a few specific things. For example, you might have a variable representing the four cardinal directions (North, South, East, West). With Enums, you can express this in a type-safe way in your code.

To sum up, TypeScript offers an enriched toolset that can enhance JavaScript code's predictability, reusability, and maintainability. It's like adding a new set of power tools to your coding toolbox.

Example of Enumerated Types: Clarity and Safety in Your Constants

Enumerated types, or Enums as they are affectionately called, are a handy feature in TypeScript that's missing from JavaScript.

Enums allow us to define a type that can have one of a predefined set of values, which can make our code easier to read and less error-prone.

Let's see an example to better illustrate their usefulness.

Suppose we're building a weather application and we have a function that takes the cardinal direction of the wind.

In JavaScript, we'd probably use a string to represent the direction:

function displayWindDirection(direction) {   
	// ... 


This works, but it's easy to make mistakes. We could accidentally pass 'nort' or 'North' and our function would still run, but it wouldn't work as expected.

With TypeScript's Enums, we can define a Direction type that can only be one of the four cardinal directions:

enum Direction {   

function displayWindDirection(direction: Direction) {   
	// ... 

displayWindDirection(Direction.North); // Correct 
displayWindDirection('north'); // Error: Argument of type 'string' is not assignable to parameter of type 'Direction'.

With this setup, TypeScript will give us an error if we try to call displayWindDirection with anything other than Direction.North, Direction.East, Direction.South, or Direction.West.

It's a simple way to make our code safer and more expressive.

Trade-offs: The Other Side of TypeScript

While TypeScript offers many appealing features and advantages, it's important to understand that it's not a silver bullet. Like any tool, it has its downsides and may not be the best fit for every project or team.

Let's explore some of the trade-offs you might encounter when using TypeScript instead of JavaScript.

Learning Curve

One of the main trade-offs of TypeScript is the additional learning curve.

If you're coming from JavaScript, you'll need to learn about types and the syntax for defining them, generics, interfaces, enums, and other TypeScript features.

This requires time and effort, particularly for developers who are new to statically-typed languages.

Development Speed

While TypeScript can make your code safer and more maintainable, it can also slow you down, especially in the early stages of a project.

TypeScript requires you to write more code for type annotations, and dealing with type errors can sometimes be frustrating, particularly when working with complex types or third-party libraries.

Tooling Requirements

To get the most out of TypeScript, you need a development environment that supports it.

Modern code editors like VS Code come with excellent TypeScript support out of the box, but if you or your team are using other tools, there might be some setup work required.

Potential Overhead

For small projects or prototypes, TypeScript might be overkill.

The benefits of static typing become more apparent in large codebases and teams, where the code needs to be robust and maintainable.

For small, simple projects, the overhead of setting up and maintaining TypeScript might outweigh the benefits.

Wrapping up Trade-offs

TypeScript is a powerful tool with clear benefits, but it's not without its trade-offs.

When deciding whether to use TypeScript, it's essential to consider the nature of your project, the makeup of your team, and the potential impact on your workflow and productivity.

Wrapping Up Your Tour of TypeScript

TypeScript, a statically-typed superset of JavaScript, has undoubtedly carved a prominent position for itself in the programming world.

By offering robust type safety, generics, and enumerated types, it substantially enhances JavaScript's capabilities, making your code safer, more readable, and ultimately more manageable.

However, like any tool, it doesn't come without its trade-offs.

The additional learning curve, potential overhead, and need for specific tooling are considerations to bear in mind before jumping on the TypeScript train.

In essence, TypeScript is like a powerful set of power tools in a workshop.

While they can significantly improve the quality of your work, they require learning, maintenance, and are more beneficial for larger, more complex projects.

For simpler tasks, sometimes a basic hand tool (in this case, JavaScript) may suffice.

The journey of exploring TypeScript is a voyage of understanding your needs and assessing the cost-benefit ratio.

As always, the right tool depends on the job at hand. So, is TypeScript right for your next project? That's for you to decide.

Remember, programming languages are tools designed to solve problems.

Finding the best one for you is not about jumping on the latest trend but rather understanding its strengths, weaknesses, and how these align with your particular situation.

Happy coding!

Share on Twitter