What is JavaScript

A plain-English introduction to JavaScript — what it does, where it runs, and why it matters.

What it is, in plain English: JavaScript is a programming language that makes web pages interactive. It runs inside your browser (so users can click, type, and see things change) and also on servers (via Node.js, so you can build the backend too). One language — two homes.

JavaScript in plain English

Imagine a web page is a house. HTML is the walls and rooms — the structure. CSS is the paint and furniture — how it looks. JavaScript is the electricity — it makes things actually work. Lights turn on. Doors open. Things react when you touch them.

Without JavaScript, every web page is a static document — like a printed poster. You can read it, but nothing changes when you click. With JavaScript, a page becomes an application: buttons do things, forms validate your input before sending, content updates without reloading the page.

Two homes: browser and server

JavaScript is unusual because it runs in two completely different places:

🌐 In the browser

Every modern browser (Chrome, Firefox, Safari, Edge) has a JavaScript engine built in. When you visit a website, the browser downloads the JS file and runs it — no install needed. This is how Google Maps, Instagram, and YouTube work.

🖥️ On the server (Node.js)

In 2009, Node.js was invented so JavaScript could also run on a server — the computer that sends you the web page in the first place. Now the same language works everywhere: front-end, back-end, desktop apps, command-line tools.

This "two homes" fact is important because some things work in the browser but not Node.js (like document and window) and vice versa. We'll flag this clearly on every relevant page.

What JavaScript is used for

Web interactivity — menus, dropdowns, carousels, modals, form validation
Web applications — Gmail, Figma, Notion, VS Code (yes, VS Code is JS)
Backend APIs — via Node.js (Express, Fastify)
Mobile apps — via React Native
Desktop apps — via Electron (Slack, Discord, VS Code again)
Command-line tools — via Node.js

How JavaScript relates to Python

If you know Python: JavaScript has a very similar structure — variables, loops, functions, objects. The main differences you'll feel immediately:

JS has no significant whitespace — indentation doesn't matter, curly braces { } do
JS is weakly typed — it quietly converts between types (which causes surprises)
JS has two homes — browser and Node.js have different built-in tools
JS is asynchronous by nature — fetching data, waiting for clicks, timers are all central

How JavaScript runs

When a browser loads a JavaScript file, a program called the JavaScript engine reads and executes it. Chrome and Node.js use the V8 engine (written by Google in C++). Firefox uses SpiderMonkey. Safari uses JavaScriptCore. They all implement the same language standard (ECMAScript), so your code works the same everywhere.

You don't need to know how the engine works — just know that JS is interpreted (not compiled to a binary like C), runs line by line (mostly), and executes very fast because these engines are highly optimised.

A note on the name

JavaScript was named after Java in 1995 as a marketing move. They are completely different languages. Java is to JavaScript what "car" is to "carpet" — same letters, completely unrelated things. Don't let the name confuse you.

The official name of the language standard is ECMAScript (ES for short). When you see "ES6", "ES2020", "ES2023" — those are version numbers of the ECMAScript standard. JavaScript is the name we use in practice.

Try It Yourself

The JavaScript ecosystem

ECMAScript — the standard behind JavaScript

JavaScript is governed by the ECMA International standards body. The specification is called ECMAScript (ECMA-262). TC39 is the committee of engineers from browser vendors, companies, and the open-source community that decides what goes into the language.

New features go through a 5-stage proposal process (Stage 0 → Stage 4). Stage 4 means it's in the spec; Stage 3 means browsers are starting to implement it. You'll often see "this is a TC39 proposal" or "this reached Stage 3" in documentation.

The execution model

JavaScript is single-threaded — it runs one thing at a time. But it's also non-blocking via the event loop: when something takes time (fetching data, waiting for a timer), JS offloads it and keeps running. When the slow thing finishes, a callback is queued. This is why JavaScript can handle thousands of simultaneous connections in Node.js without threads.

Understanding the event loop is key to understanding async/await, Promises, and setTimeout. We cover this in the Scope & Closures page and the async reference pages.

Module systems

Modern JavaScript uses ES Modules (ESM): import and export. Node.js historically used CommonJS: require() and module.exports. Both exist in the wild. ES Modules is the standard going forward.

The browser environment

In the browser, JavaScript has access to:

window — the global object (all globals live here)
document — the DOM (the page's HTML, manipulable via JS)
navigator — browser/device info
fetch() — make HTTP requests
localStorage / sessionStorage — persist data in the browser

The Node.js environment

In Node.js, JavaScript has access to:

process — the running process (args, env vars, exit)
fs — the file system (read/write files)
path — file path utilities
http / https — build HTTP servers
global — the global object (equivalent to window)

There is no document or window in Node.js.

JavaScript versions you'll encounter

Version	Year	Key additions
ES5	2009	Strict mode, JSON, Array methods
ES6 / ES2015	2015	let/const, arrow functions, classes, Promises, template literals, destructuring — the modern JS turning point
ES2017	2017	async/await
ES2020	2020	Optional chaining (?.), nullish coalescing (??), BigInt
ES2022+	ongoing	Top-level await, class fields, Array.at(), Object.hasOwn()

Write ES2015+ (modern JS). You'll see old pre-ES6 patterns in legacy codebases — var, function() {} everywhere, prototype chains. Understand them; don't write new code in them.

Under the hood — V8, JIT, and the spec

How V8 executes JavaScript

V8 (Google's JS engine, used in Chrome and Node.js) compiles JavaScript to native machine code at runtime using a Just-In-Time (JIT) compiler. The pipeline:

Parser — reads source text, produces an AST (Abstract Syntax Tree)
Ignition — the interpreter; compiles AST to bytecode, executes it immediately
Sparkplug — a fast non-optimising compiler for frequently-called functions
Maglev — a mid-tier optimising compiler (added V8 v9.4)
TurboFan — the full optimising compiler; produces highly optimised machine code for hot functions using type feedback collected by Ignition

V8 profiles which functions run often ("hot paths") and re-compiles them at progressively higher optimisation tiers. If type assumptions are violated (e.g. a function always received numbers but suddenly receives a string), TurboFan deoptimises back to Ignition.

Hidden classes and inline caches

V8 assigns hidden classes (also called "shapes" or "maps") to objects at creation time. Objects with the same property order share a hidden class, letting V8 cache property lookup offsets. Adding properties to an object after creation creates a new hidden class — a common performance pitfall. Always initialise all properties in the constructor.

The ECMAScript specification

The spec (ECMA-262) is the authoritative definition of JavaScript. It describes every operator, every built-in method, and the exact order of operations using abstract operations and the Abstract Machine model. When browser implementations disagree, the spec wins.

Key spec concepts to know: the Completion Record (how control flow propagates exceptions), Reference Records (how property access and variable resolution work), Realm (an isolated JS environment with its own globals — important for iframes), and Agent (a thread; JS agents share memory only via SharedArrayBuffer).

The event loop — specification level

The HTML spec (not ECMAScript) defines the event loop. The loop:

Pick one task from the task queue (macrotask queue) — e.g. a setTimeout callback, a script load
Run it to completion (JS is single-threaded — no preemption)
Process the entire microtask queue (Promise callbacks, queueMicrotask) until empty
If needed, do a rendering update
Go to step 1

This explains why Promise.resolve().then(fn) runs before setTimeout(fn, 0) — Promises are microtasks, setTimeout is a macrotask.

Memory model — SharedArrayBuffer and Atomics

Multiple JS agents (Workers) can share a SharedArrayBuffer. The ECMAScript memory model defines the ordering guarantees: without Atomics, reads/writes to shared memory are unordered (data races allowed). Atomics.load(), Atomics.store(), and Atomics.wait() provide sequentially-consistent ordering — the same model as C++11's std::atomic.

Official Sources

The Codex links only to official documentation and the ECMAScript specification. No third-party tutorials.