🟢 What is Node.js?

What Node.js Really Is

A web browser has a secret engine inside it that reads your JavaScript and turns it into instructions the computer can run. In Chrome that engine is called V8. In 2009 a developer named Ryan Dahl had a simple but radical idea: what if you pulled V8 out of the browser and wrapped it in a program that could talk to files, networks, and the operating system? That program is Node.js.

The word "runtime" trips people up. It just means "the environment your code runs in, plus the extra abilities that environment hands you." The browser's runtime gives JavaScript the DOM and fetch. Node's runtime gives JavaScript the file system, raw network sockets, and the ability to spawn other programs — the toolkit a server needs.

The Problem Node.js Solves

Before Node, most web servers handled each visitor with a dedicated thread — a worker who stays glued to one request from start to finish. That works fine until thousands of people arrive at once, most of them just waiting: waiting for a database, waiting for a file to load, waiting for another API. Threads sitting idle still consume memory. Scale up and you drown in overhead.

Node took a different bet: one main thread, never allowed to sit and wait. When a slow operation starts (read a file, query a database), Node hands it off and immediately moves on to the next request. When the slow thing finishes, a callback is queued and run. This is event-driven, non-blocking I/O, and it lets a single Node process juggle tens of thousands of connections.

💬 Ryan Dahl's original pitch: Node was built to solve the I/O-scaling problem with an event-driven, non-blocking model that handles thousands of concurrent connections with minimal overhead.

A quick history

Key Features

Asynchronous & event-driven

Node's built-in APIs are non-blocking by default. You start an operation and give Node a callback (or a promise) to run later; Node never freezes waiting for the result.

Single-threaded, yet highly scalable

Your JavaScript runs on one thread, so you rarely worry about locks or race conditions. The event loop, backed by a small pool of background threads, delivers concurrency without the cost of a thread-per-request model.

Fast execution via V8

V8 compiles JavaScript straight to optimized machine code — no slow line-by-line interpretation — which is why Node is quick for I/O-heavy workloads.

Cross-platform & batteries included

The same code runs on Windows, macOS, and Linux. Core modules (fs, http, path, os, events) ship in the box, and npm — the largest open-source registry in the world — supplies almost everything else.

Node.js vs Browser JavaScript

The language is identical, but the surroundings differ. There is no window, no DOM, and no document in Node — instead you get global, process, and direct access to the machine.

Installing & Your First Program

1. Install the LTS build

Download the LTS (Long-Term Support) version from nodejs.org. LTS releases get bug fixes for years and are the safe choice for real projects.

2. Verify it works

node -v   # e.g. v22.11.0
npm -v    # e.g. 10.9.0

Two version numbers means Node and npm are both installed and on your PATH.

3. Run your first script

Create hello.js:

// hello.js — your first server-side JavaScript

console.log('Hello, World!');

// process.argv holds the command-line arguments.
// Index 0 = path to node, 1 = path to script, 2+ = your args.
const name = process.argv[2] || 'World';
console.log(`Hello, ${name}!`);

console.log(`The current time is: ${new Date().toLocaleTimeString()}`);

Run it:

node hello.js
node hello.js Ada

$ node hello.js
Hello, World!
Hello, World!
The current time is: 9:42:15 AM

$ node hello.js Ada
Hello, World!
Hello, Ada!
The current time is: 9:42:31 AM

4. Serve a web page from your own server

This is the moment Node clicks — JavaScript answering real HTTP requests:

// server.js
const http = require('node:http');

const server = http.createServer((req, res) => {
    res.statusCode = 200;
    res.setHeader('Content-Type', 'text/html');
    res.end(`
        <!DOCTYPE html>
        <html>
          <head><title>My First Node Server</title></head>
          <body>
            <h1>Hello from Node.js!</h1>
            <p>Served at ${new Date().toLocaleString()}</p>
          </body>
        </html>
    `);
});

const PORT = 3000;
server.listen(PORT, () => {
    console.log(`Server running at http://localhost:${PORT}/`);
});

Run node server.js, open http://localhost:3000, and your browser is talking to a server you wrote in JavaScript. In the next few lessons Express will make this far cleaner — but it's all built on exactly this.

When to Reach for Node

Node is a specialist, not a silver bullet. It shines when your program spends most of its time waiting on I/O, and struggles when it needs to crunch numbers non-stop.

The takeaway: Node handles concurrency beautifully as long as no single task hogs the thread. Keep the main thread free and it will happily serve thousands at once.

Practice & Quiz

// greet.js
// Run as:  node greet.js Grace
// TODO: read the name from process.argv and print a greeting

// greet.js
const name = process.argv[2] || 'friend';

if (name.toLowerCase() === 'admin') {
    console.log('Welcome back, administrator. 🔑');
} else {
    console.log(`Hello, ${name}! Welcome to Node.js.`);
}

const http = require('node:http');

const server = http.createServer((req, res) => {
    res.setHeader('Content-Type', 'text/html');

    if (req.url === '/') {
        res.statusCode = 200;
        res.end('<h1>Welcome!</h1>');
    } else if (req.url === '/about') {
        res.statusCode = 200;
        res.end('<h1>About</h1><p>A tiny Node server.</p>');
    } else {
        res.statusCode = 404;
        res.end('<h1>404 — Not Found</h1>');
    }
});

server.listen(3000, () => console.log('http://localhost:3000/'));

Best Practices & Pitfalls

✅ Do

• Install the LTS release for anything you intend to keep running
• Prefer asynchronous APIs so you never freeze the event loop
• Use the node: prefix for core modules (require('node:fs')) to make intent clear
• Keep CPU-heavy work off the main thread — reach for Worker Threads

❌ Don't

• Reach for window, document, or the DOM — they don't exist in Node
• Assume synchronous *Sync functions are fine in a server — they block every other request
• Confuse Node (the runtime) with Express (a framework that runs on it)

const fs = require('node:fs');

// ❌ In a server, this freezes EVERY request until the disk responds:
const data = fs.readFileSync('big.txt', 'utf8');

// ✅ Non-blocking — other requests keep flowing while the disk works:
fs.readFile('big.txt', 'utf8', (err, data) => {
    if (err) throw err;
    console.log(data.length);
});

Summary

📚 Additional Resources

• Node.js — Introduction to Node.js
• Node.js — Official API Documentation
• Node.js — Download the LTS release

🚀 What's Next?

You know what Node is and why it exists. Next we open the hood: how the event loop and the libuv thread pool actually deliver that non-blocking magic, phase by phase — in Node.js Architecture and the Event Loop.