What Is JavaScript? The Language of the Web, Explained

JavaScript Is the Language of the Web

JavaScript is the programming language that runs inside web browsers. When a page reacts to a click, validates a form, animates a menu, or loads new content without reloading — that's JavaScript. Every browser on every device ships with a JavaScript engine built in, which makes it the only language that runs natively on the web.

It also runs outside the browser now. Node.js, Deno, and Bun let you use JavaScript for servers, command-line tools, build scripts, and APIs. The same language powers the frontend and the backend, which is a big part of why it's so widely used.

A tiny taste of what JavaScript looks like:

Three lines, three ideas: declare a variable, call a built-in, print a templated string. You'll see all three on every page of real JavaScript code.

Where JavaScript Runs

JavaScript itself is just a language spec (called ECMAScript). To actually run it, you need an engine — a program that reads your code and executes it. The two you'll meet:

• Browsers. Chrome and Edge use V8. Firefox uses SpiderMonkey. Safari uses JavaScriptCore. Open a page, press F12, and paste JavaScript into the Console tab — it runs instantly.
• Node.js. Takes V8 out of the browser and gives it access to the filesystem, network, and OS. That's what makes server-side JavaScript possible.

// Run in a browser console:
document.title = "New tab title";

// Run with Node.js:
// $ node script.js

Browser JavaScript can touch the page (the DOM), but not your filesystem. Node.js JavaScript can read files and open sockets, but has no page to manipulate. Same language, different superpowers.

What JavaScript Is Used For

The short answer: almost anything the web touches. The longer answer, roughly in order of how you'll encounter them:

• Interactive web pages. Form validation, dropdowns, modals, live search, drag-and-drop.
• Single-page apps. Gmail, Figma, Notion, Linear — entire applications rendered and updated by JavaScript, usually through a framework like React, Vue, or Svelte.
• Backend servers. REST APIs, GraphQL endpoints, and real-time services built with Node.js, Express, Fastify, or NestJS.
• Build and dev tooling. Bundlers (Vite, esbuild, webpack), linters (ESLint), test runners (Vitest, Jest).
• Cross-platform apps. Desktop apps via Electron (VS Code, Slack, Discord) and mobile apps via React Native.

You don't need to know all of this on day one. It's worth knowing it exists so the phrase "just JavaScript" doesn't sound limiting.

How JavaScript Actually Runs

A very simplified mental model: you write source code, the engine parses it into an internal representation, and then executes it. Modern engines use JIT (just-in-time) compilation — they start interpreting quickly and then optimize hot code paths into machine code while the program runs.

You don't compile JavaScript to a binary before shipping it. You hand the source to the browser (or Node) and the engine takes care of the rest:

Paste that into a browser console or save it as greet.js and run node greet.js — same output either way. No compile step, no build config, nothing to install for code this simple.

JavaScript vs Java

They sound alike and they are not alike. JavaScript was named that way in 1995 to ride on Java's popularity at the time — a marketing decision that has confused beginners ever since.

	JavaScript	Java
Typing	Dynamic	Static
Runs on	Browsers, Node.js	JVM
Paradigm	Multi-paradigm, prototype-based	Class-based OOP
Compilation	JIT, no build step required	Compile to bytecode first

If someone tells you "I learned Java, so I know JavaScript" — they don't. Treat them as separate languages that happen to share four letters.

JavaScript vs TypeScript

TypeScript is JavaScript with a type system bolted on. You write code with type annotations, the TypeScript compiler checks them, and the output is plain JavaScript that runs anywhere JavaScript runs.

// JavaScript — types are implicit:
function add(a, b) {
    return a + b;
}

// TypeScript — types are explicit:
function add(a: number, b: number): number {
    return a + b;
}

Every valid JavaScript file is a valid TypeScript file, which means TypeScript isn't a competitor — it's a superset. Most large codebases today use TypeScript, but learning JavaScript first is the right order. You can't understand TypeScript's job without understanding what it's adding types to.

A Short History, So the Quirks Make Sense

JavaScript was written in ten days in 1995 by Brendan Eich at Netscape. That origin story matters because some of the language's rough edges (loose equality, automatic semicolon insertion, typeof null === "object") come from decisions made under extreme time pressure and then frozen in place to keep the web backwards-compatible.

The language is standardized as ECMAScript, and a new version ships every year (ES2015 was the big one — let, const, arrow functions, classes, modules). When someone says "ES6" or "modern JavaScript," they mean roughly the 2015-and-later feature set that's now universally supported.

Modern JavaScript is genuinely pleasant to write. The older bits are still there, but you can mostly avoid them with habits we'll cover throughout this course.

What You Take Away

• JavaScript runs in every browser and, via Node.js, on servers too.
• It's used for almost everything the web touches — UI, backend, tooling, even desktop and mobile apps.
• It's not Java. TypeScript is a superset that adds static types.
• The language has some historical quirks; modern JavaScript (ES2015+) is what you'll actually write.

Next: Running JavaScript

Enough context — time to actually run some code. The next doc covers the three places you'll run JavaScript as a beginner: the browser console, an HTML file, and Node.js on the command line.