The Art of TypeScript

The Art of Sustainable, Durable, and Scalable Code: Why Types Matter

Programming is a way for us to express our ideas and instruct computers to solve problems. Over the years, many programming languages have been developed to cater to different needs—C, C++, JavaScript, Python, to name a few. Each of these languages has its own set of advantages and challenges, but today, I want to focus on one of the most critical aspects of writing code that stands the test of time: sustainability, durability, and scalability.

We’ve all been there—writing code that seems perfectly clear to us at the time, but after a few days, weeks, or months, we return to it only to find that the clarity has faded. As the old joke goes, “I knew what this code did when I wrote it, but now only God knows!”

To combat this, developers have devised countless strategies, including various frameworks and programming paradigms like functional programming and object-oriented programming. However, one of the most effective tools for ensuring future maintainability is writing self-explanatory, well-defined code.

Enter: The Art of Types

Types, in programming, are like rules on a battlefield. Just as everyone on the battlefield must know the rules to coordinate effectively, well-defined types in code establish clear expectations for how each part of the system should behave. The better we define these rules, the more manageable and scalable our code becomes.

This is where TypeScript shines. TypeScript is like the “golden rulebook” of programming. It allows us to define the rules and expectations for each part of our code in a clear, self-explanatory way. By enforcing these rules, TypeScript ensures that both we, and any future developers, understand the intentions and constraints of the code—long after it’s been written.

Let’s look at an example:

function sum(num1, num2) {
    return num1 + num2;
}         

At first glance, this function seems fine, but what happens if a user calls it with mismatched types, like this:

sum('1', 2);         

Here, the first argument is a string, which could lead to unexpected behavior or even bugs. Without clear rules, this function could be easily misused.

Now, let’s see the same function in TypeScript:

 function sum(num1: number, num2: number): number {
    return num1 + num2;
}        

In this version, we’ve added type annotations. We’re telling both the developer and the compiler that this function expects two numbers as inputs and will return a number. If someone tries to break these rules, the TypeScript transpiler will step in and prevent it, ensuring the function is used as intended.

Why Types Matter for Sustainable Code

Types help us create sustainable code by setting expectations and enforcing them at compile time, rather than waiting for bugs to appear during runtime. They serve as a contract between the developer and the code, which helps maintain consistency and clarity as the codebase grows.

Scalability: As your project grows, having a strict typing system allows you to scale confidently. You know that each part of the code adheres to predefined rules, making collaboration smoother.

Durability: TypeScript’s ability to catch errors early (during development) ensures that your code remains durable and robust over time.

Maintainability: When you or someone else revisits the code in the future, the types act as documentation, reducing the learning curve and preventing misunderstandings.

Conclusion

Whether in life or coding, having a set of standardized rules to follow makes everything run smoother. TypeScript gives us this authority in the form of types, which guide us toward writing code that is not only functional but sustainable, durable, and scalable.

Incorporating types into your development process isn’t just about preventing bugs—it’s about communicating with your future self and others who will read or maintain your code. Embrace the art of types, and you’ll find that your code becomes clearer, more reliable, and easier to work with, no matter how much time passes.