Hello, TypeScript

TypeScript is JavaScript with a static type system layered on top. Every valid JavaScript file is already valid TypeScript — you could rename app.js to app.ts and it would compile. What TypeScript adds is a compile-time checker: it reads your code, verifies that the types line up, and reports a whole class of bugs before the program ever runs.

Why does TypeScript exist?

Plain JavaScript happily accepts code like this:

const user = { name: "Alice" };
console.log(user.nmae.toUpperCase()); // typo — crashes at RUNTIME

In JavaScript you discover the nmae typo only when someone actually runs that line — maybe in production. TypeScript flags it the moment you write it, because it knows user has a name property and nothing called nmae.

That is the entire pitch: move bug discovery from runtime (expensive, public) to compile time (instant, private). The bonus is world-class tooling — autocomplete, go-to-definition, and safe renames all work because the editor knows the type of every value in your program.

Your first program

const greeting: string = "Hello, TypeScript!";
console.log(greeting);

Two things to notice:

• : string is a type annotation. It declares "this variable holds a string." If you later try to assign a number to greeting, the compiler refuses.
• console.log(...) prints its argument to standard output followed by a newline — exactly like JavaScript, because at runtime it IS JavaScript.

You do not have to annotate everything. TypeScript infers types: const greeting = "Hello" is already known to be a string without any annotation. When and where annotations pay off is the subject of the next lesson.

The trap: types vanish at runtime

The single most important mental model in TypeScript:

const greeting: string = "Hello, TypeScript!";

// After compilation, the emitted JavaScript is just:
// const greeting = "Hello, TypeScript!";

The compiler checks your annotations, then erases them. At runtime there are no types — no checks, no speed penalty, and no protection against bad data arriving from a network response or user input. TypeScript is a static analyzer, not a runtime bodyguard. Beginners often expect : string to throw an error if a number sneaks in while the program runs. It will not — the annotation no longer exists by then. Runtime validation is code you still have to write yourself.

Your exercise

Write a program that prints exactly:

Hello, TypeScript!

One console.log with a string literal is all it takes. The grader compares your output character by character, so the mistakes it will catch are:

• Wrong capitalization — it is Hello, TypeScript! with a capital H, capital T, and capital S (not Typescript, not hello).
• A missing comma after Hello, a missing space after the comma, or a forgotten ! at the end.
• Extra output — print the greeting and nothing else.

console.log adds the trailing newline for you; do not add your own \n.