Introduction to TypeScript

Introduction

TypeScript is an open-source programming language, developed and maintained by Microsoft, that adds static types on top of JavaScript. Every valid JavaScript program is already valid TypeScript — TypeScript is a strict superset, meaning it does not replace JavaScript, it extends it with an optional type system layered on top.

This lesson introduces what TypeScript is, why Microsoft built it, the philosophy that shapes every design decision in the language, and gives you your very first taste of actual TypeScript code.

What is TypeScript?

TypeScript is a statically typed, compiled superset of JavaScript. "Statically typed" means you can describe the shape and type of your variables, function parameters, and return values, and the TypeScript compiler checks that everything lines up correctly before your code ever runs. "Compiled" — more accurately "transpiled" — means TypeScript source code (.ts files) is translated into plain JavaScript (.js files) that any browser or Node.js runtime can execute directly, since neither browsers nor Node understand TypeScript syntax natively.

Crucially, TypeScript's type system is entirely a compile-time construct. Once your code is compiled, every type annotation, interface, and generic is stripped away — the output is ordinary JavaScript with zero runtime overhead or extra libraries required. If you already know JavaScript, you already know most of TypeScript; you are simply learning to describe the shapes your data already has.

Who Created TypeScript, and Why

TypeScript was created at Microsoft under the leadership of Anders Hejlsberg, a veteran language designer whose earlier work includes Turbo Pascal, Delphi, and C#. Development began internally around 2010, and TypeScript was publicly announced and open-sourced on October 1, 2012.

Microsoft's own engineering teams were running into the limits of plain JavaScript as their applications grew. JavaScript is dynamically typed by design — a variable can hold any type of value at any time, and that flexibility is wonderful for small scripts but becomes a liability once a codebase reaches hundreds of thousands of lines, maintained by large teams. Typos in property names, functions called with the wrong argument types, and objects missing expected fields were all bugs that JavaScript could only catch at runtime, often in production. TypeScript was designed to catch that entire category of mistakes at compile time instead.

The Problem TypeScript Was Built to Solve

As JavaScript applications grew from small scripts into full single-page applications and large Node.js backends, teams found that the language's dynamic nature — a strength for quick prototyping — became a real cost at scale. Without types, editors could not reliably autocomplete object properties, "rename symbol" refactors were dangerous because the tool could not know every place a property was used, and a huge share of bugs were simple things like calling `.toUpperCase()` on a value that turned out to be a number.

TypeScript's creators set out to keep everything that made JavaScript productive — no build step required to get started, the same runtime semantics, access to the entire npm ecosystem — while adding an optional type layer that IDEs and the compiler could use to catch mistakes before code ever ran, and to power much richer autocomplete, navigation, and refactoring tools.

Core Philosophy

Every feature TypeScript has — and the careful way it stays compatible with JavaScript — traces back to a small set of guiding principles.

Key Features at a Glance

Your First Taste of TypeScript

No introduction to a language is complete without seeing actual code. Here is a small TypeScript function with type annotations on its parameter and return value.

function greet(name: string): string {
  return `Hello, ${name}!`;
}

console.log(greet("TypeScript"));

The `: string` after `name` and after the closing parenthesis are type annotations — they tell TypeScript that `name` must be a string, and that `greet` must return a string. Try calling `greet(42)` and the compiler will refuse to compile, catching the mistake before the code ever runs. Once compiled, the output JavaScript looks almost identical, just without the annotations — they are only for the compiler's benefit.

Where TypeScript Is Used Today

TypeScript has become the default choice for serious frontend and Node.js backend development. Many of the tools and frameworks developers use every day are themselves written in TypeScript.

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

You now know what TypeScript is, who built it, why it exists, and what its guiding philosophy is. You have also seen your very first line of runnable TypeScript code. Next, you will dig deeper into TypeScript's history — from Microsoft's early internal work through the major version milestones that shaped the language you'll be learning.