TypeScript: A Philosophy Built on Imperfection

Written by Nap Joseph Calub on May 1, 2025

Philosophy TypeScript Development JavaScript

"Vanilla JS Is Fine"—So Why Learn TypeScript?

Someone mentioned to me a few years ago that they don't want to work with TypeScript because "Vanilla JavaScript is fine". And you know what? They're not entirely wrong.

You can absolutely build great things with plain JavaScript. If you're working on a small project, if you're just starting out, or if you're prototyping fast—it's simple, it's familiar, and it works.

But here's the key question: What happens when your codebase grows? When the team expands? When features shift, deadlines loom, and someone accidentally passes a string where a number was expected—two months after the code was written?

That's when "fine" stops being enough. That's when you need structure, intent, and tools that help you think before your code hits production.

TypeScript isn't here to replace JavaScript. It's here to help you outgrow its pitfalls.

Just like seatbelts don't make driving harder—they make it safer—TypeScript doesn't limit you. It enables you to move faster with confidence.

This post isn't about replacing your toolbox. It's about refining it. And TypeScript is the philosophical upgrade that helps you do just that.

Why TypeScript? Because Philosophy Matters

In the world of programming, we often ask what and how—what tools are fastest, how to ship quicker, what framework is trending. But the truly transformative technologies—the ones that stick—are built on a solid why.

TypeScript is one of them.

It's not just a language extension. It's a statement: That code should be intentional. That communication matters. That humans—not just machines—read code.

From JavaScript to TypeScript: A Philosophical Shift

JavaScript gave the world an open, flexible way to build for the web. It's dynamic, forgiving, and incredibly powerful. But as systems grew, that same flexibility became a liability. JavaScript lets you write anything, but it never asks why you're writing it that way.

With flexibility comes risk: missed assumptions, silent bugs, contracts that only exist in someone's head (and disappear when they leave the team).

Enter TypeScript. Not to replace JavaScript, but to bring intent to it.

Where JavaScript says, "Do whatever works," TypeScript asks, "What are you trying to do—and how can you make that explicit?"

// JavaScript
function calculateTotal(price, tax) {
  return price + tax;
}

calculateTotal("19.99", 5); // Whoops! String + number = '19.995'

// TypeScript
function calculateTotal(price: number, tax: number): number {
  return price + tax;
}

calculateTotal("19.99", 5); // Error: Argument of type 'string' is not assignable to parameter of type 'number'.

The difference? In JavaScript, you find the bug later. In TypeScript, you see it immediately.

TypeScript Is for Humans, Not Just Machines

Some developers think TypeScript is just for IDEs or compilers. But that's missing the point.

TypeScript is a way to explain your intent to other developers. It becomes the documentation that never goes stale. The types tell a story:

  • What this function expects.
  • What it guarantees.
  • What can go wrong—and what cannot.
type User = {
  id: number;
  name: string;
  email?: string; // Optional field
};

function sendWelcomeEmail(user: User) {
  if (user.email) {
    sendEmail(user.email, "Welcome!");
  }
}

Without needing to read any comments, you know exactly what kind of object you're dealing with. That's not just type safety—it's cognitive clarity.

The Bigger the Codebase, the Bigger the Benefit

In a 3-person hobby project, you can survive with JavaScript. In a 30-person team—or a 3-year-old codebase—TypeScript becomes your safety net, your roadmap, and your debugger before you even hit "Run."

You can refactor with confidence. You can onboard new developers without handholding. You can sleep at night knowing that your assumptions are enforced by the compiler.

Why Learn TypeScript?

Learning TypeScript isn't just about learning types—it's about adopting a mindset:

  • Explicit is better than implicit.
  • Collaboration is more important than cleverness.
  • Software should be robust, readable, and resilient.

When you embrace TypeScript, you're choosing to code with purpose. You're building a habit of clear thinking. You're creating software that's not just working, but understood.

But TypeScript Isn't Perfect—Because JavaScript Isn't

It's important to be honest: TypeScript inherits the flaws of JavaScript.

JavaScript was created in just 10 days. It was never designed to scale to the size of modern applications. It has quirks that are baffling even to seasoned developers:

[] + {}; // '[object Object]'
{} + []; // 0

typeof null; // 'object'

Or the classic:

NaN === NaN; // false

These aren't just oddities—they're reminders that JavaScript, for all its power, is built on shaky foundations. It prioritizes flexibility and permissiveness over consistency and correctness.

TypeScript doesn't fix that. It wraps JavaScript in structure, but the engine underneath still runs on JavaScript's rules. You're still constrained by its runtime behaviors, dynamic nature, and legacy baggage.

So Why Choose TypeScript Anyway?

Because there is no practical alternative—at least not one that works with the current ecosystem.

  • You can't throw away JavaScript. It's the language of the web.
  • Other compile-to-JS languages like Elm, ReasonML, or PureScript offer cleaner designs—but they come at the cost of isolation and friction with the broader JavaScript world.
  • TypeScript is the pragmatic middle ground. It improves safety, clarity, and developer experience—without demanding a complete break from the tools and libraries that power the modern web.

It's not perfect. But it's better. It helps you write clearer, safer, more maintainable code in a language that wasn't built for that. That's no small feat.

The Takeaway

TypeScript isn't a silver bullet—but it's a powerful lens. It helps you navigate the weirdness of JavaScript with more confidence and less risk.

In a world where the foundation is flawed, TypeScript is the scaffolding that lets us build responsibly.

And until we get a truly new web-native language with wide adoption, TypeScript is the best tool we have to write JavaScript like we mean it.