Node.js

Node.js runs JavaScript outside the browser on Google's V8 engine, paired with libuv — a C library that provides the event loop and a thread pool for I/O. Node is single-threaded for your JavaScript, but I/O is offloaded so it never blocks.

Node's model is single-threaded, non-blocking, event-driven. One thread runs your JS; libuv handles file, network, and timer work in the background and queues callbacks for the loop to run.

The event loop processes work in phases, in order, each draining its queue:

1. timers — setTimeout / setInterval callbacks.
2. pending callbacks — deferred I/O callbacks.
3. poll — retrieve new I/O events; execute their callbacks.
4. check — setImmediate callbacks.
5. close — close events (e.g. a socket closing).

Node supports two module systems:

Three generations of asynchronous style, each built on the last:

Streams process data in chunks instead of loading it all into memory — essential for large files and network data. Four types:

• Readable — source you read from (fs.createReadStream, an HTTP request).
• Writable — destination you write to (a file, an HTTP response).
• Duplex — both readable and writable (a TCP socket).
• Transform — a duplex stream that modifies data passing through (gzip, encryption).

Connect them with pipe() or, preferably, stream.pipeline(), which propagates errors and cleans up:

const { pipeline } = require("node:stream/promises");
await pipeline(
  fs.createReadStream("in.txt"),
  zlib.createGzip(),
  fs.createWriteStream("out.txt.gz")
);

Much of Node's core is built on the EventEmitter pattern — objects that emit named events and call registered listeners. Streams, HTTP servers, and sockets are all emitters.

const { EventEmitter } = require("node:events");
const bus = new EventEmitter();
bus.on("order", (id) => console.log("processing", id));
bus.emit("order", 42);

• on(event, fn) / once(event, fn) — subscribe (persistent / one-shot).
• emit(event, ...args) — fire synchronously to all listeners in registration order.
• off() / removeListener() — unsubscribe to avoid leaks.

Error handling depends on the async style:

• Sync & async/await — try/catch.
• Callbacks — check the error-first argument every time.
• Promises — .catch(); an unhandled rejection emits process.on("unhandledRejection").
• EventEmitters — listen for the "error" event.

One Node process uses one CPU core for JS. To use more — or to keep the loop responsive under heavy compute — Node offers three tools, chosen by the kind of work:

npm manages dependencies via package.json; package-lock.json pins exact versions for reproducible installs. Versions follow semver (MAJOR.MINOR.PATCH): ^1.2.3 allows minor/patch updates, ~1.2.3 only patch.

Frequently used built-in (node:) modules:

• fs / path — files and cross-platform paths.
• http / https — servers and clients (plus the global fetch).
• os / process — system info, env vars (process.env), arguments.
• crypto — hashing, HMAC, encryption.
• node:test + node:assert — the built-in test runner, no dependency needed.