Node.js

Node.js is a runtime environment that lets you run JavaScript outside the browser — on servers, your laptop, even IoT devices. It's built on Chrome's V8 engine, which compiles JavaScript directly into machine code.

Why developers love it:

JavaScript everywhere — Same language for frontend and backend. No context switching.

Non-blocking I/O — Node doesn't sit and wait for slow operations (like reading files or calling APIs). It moves on and comes back when the result is ready.

Blazing fast — V8 engine + event-driven architecture = speed.

NPM — The world's largest package ecosystem with over 2 million packages.

What Node.js is great for:

REST APIs and GraphQL servers

Real-time apps (chat, live notifications)

Microservices

CLI tools (like npm, eslint, prettier)

Streaming applications

What it's NOT great for:

Heavy CPU computations (video encoding, machine learning) — it's single-threaded, so long calculations block everything.

In short, Node.js made it possible for frontend developers to become full-stack developers using just one language.

The Event Loop is the heart of Node.js. It's what makes Node able to handle thousands of connections without creating thousands of threads.

The big picture:

Node.js is single-threaded. But it doesn't just do one thing at a time. When it hits a slow operation (file read, API call, database query), it hands it off to the system and moves on. When the result is ready, the callback gets added to a queue, and the Event Loop picks it up.

How it works (simplified):

1. Your code runs (Call Stack)
2. Async operation starts → handed to OS/thread pool
3. Main thread continues with next code
4. Operation completes → callback added to queue
5. Event Loop checks: "Is the Call Stack empty?"
6. If yes → picks callback from queue → runs it
7. Repeat forever

The phases of the Event Loop:

| Phase | What runs |

|-------|-----------|

| Timers | setTimeout, setInterval callbacks |

| Pending | System-level callbacks (TCP errors, etc.) |

| Poll | I/O callbacks (file reads, network) |

| Check | setImmediate callbacks |

| Close | socket.on('close') callbacks |

Between every phase, Node processes:

process.nextTick() callbacks (highest priority)

Promise .then() callbacks (microtasks)

This is why process.nextTick always runs before setTimeout(fn, 0).

NPM (Node Package Manager) is two things:

1. A command-line tool for installing and managing packages

2. An online registry with over 2 million open-source packages

package.json is your project's manifest file. It describes:

{
  "name": "my-app",
  "version": "1.0.0",
  "scripts": {
    "start": "node server.js",
    "dev": "nodemon server.js",
    "test": "jest"
  },
  "dependencies": {
    "express": "^4.18.0"
  },
  "devDependencies": {
    "nodemon": "^3.0.0"
  }
}

Key fields:

| Field | Purpose |

|-------|---------|

| name | Your project name |

| version | Follows SemVer (major.minor.patch) |

| scripts | Custom commands (npm run dev) |

| dependencies | Packages needed in production |

| devDependencies | Packages needed only for development |

Common commands:

npm init -y — Create package.json with defaults

npm install express — Add to dependencies

npm install -D nodemon — Add to devDependencies

npm ci — Clean install (for CI/CD, uses lockfile exactly)

package-lock.json locks exact versions of every dependency. Always commit it — it ensures everyone gets the same package versions.

Node.js supports two module systems. Here's the difference:

CommonJS (the classic way):

// Exporting
module.exports = { add, subtract };
module.exports = function greet() {};

// Importing
const { add } = require('./math');
const express = require('express');

ES Modules (the modern way):

// Exporting
export function add(a, b) { return a + b; }
export default function greet() {}

// Importing
import { add } from './math.js';
import express from 'express';

| Feature | CommonJS (require) | ES Modules (import) |

|---------|---------------------|----------------------|

| Loading | Synchronous | Asynchronous |

| When parsed | At runtime | At parse time (static) |

| Tree-shaking | Not possible | Possible (smaller bundles) |

| Top-level await | No | Yes |

| Default in Node | .js files | .mjs files or "type": "module" |

How to use ES Modules in Node.js:

1. Use .mjs file extension, OR

2. Add "type": "module" in your package.json

Tip: Most modern projects use ES Modules. If you're starting a new project, go with import/export.

Express.js is the most popular web framework for Node.js. It takes the bare-bones http module and adds powerful features like routing, middleware, and easy request handling.

Creating a basic server:

import express from 'express';
const app = express();

// Middleware to parse JSON
app.use(express.json());

// Routes
app.get('/', (req, res) => {
  res.json({ message: 'Hello World!' });
});

app.get('/users/:id', (req, res) => {
  const userId = req.params.id;   // URL parameter
  const sort = req.query.sort;     // Query string ?sort=name
  res.json({ userId, sort });
});

app.post('/users', (req, res) => {
  const userData = req.body;       // Request body
  res.status(201).json(userData);
});

// Start server
app.listen(3000, () => {
  console.log('Server running on port 3000');
});

Why Express?

Minimal and unopinionated — you structure your app how you want

Huge middleware ecosystem (cors, helmet, morgan)

Dead simple routing

Works perfectly with any database

Key methods:

app.get(), app.post(), app.put(), app.delete() — Route handlers

app.use() — Apply middleware

req.params, req.query, req.body — Access request data

res.json(), res.send(), res.status() — Send responses