Node.js Intro

Node.js Intro: Modern Server-Side JavaScript & V8 Engine Architecture

Node.js is an open-source, cross-platform JavaScript runtime environment built on Google Chrome's V8 engine. It enables developers to execute JavaScript on the server side, powering asynchronous, event-driven web applications, microservices, and micro-backend APIs.

V8 Engine and Event Loop Execution Model

Unlike traditional multi-threaded Web servers (such as Apache) that allocate a thread per HTTP request, Node.js uses a single-threaded non-blocking I/O event loop model. Asynchronous operations are delegated to Libuv thread pools or system kernel primitives.

flowchart TD
    A["Client Request"] --> B["Node.js Event Loop Thread"]
    B -->|"Synchronous Code"| C["V8 Call Stack"]
    B -->|"Async I/O / File / Network"| D["Libuv Worker Thread Pool"]
    D -->|"Task Complete"| E["Event Queue Callback"]
    E --> B

Core Node.js architectural pillars:

1. V8 Engine: Compiles JavaScript directly to native machine code before execution, providing fast execution speeds.
2. Single-Threaded Event Loop: Manages request dispatching without context switching overhead across thousands of threads.
3. Asynchronous Non-Blocking I/O: Operations return promises or invoke callbacks when disk, network, or database queries finish.

Practical Code Example

import http from 'node:http';

// Create a simple, high-performance HTTP server
const server = http.createServer((req, res) => {
    const responsePayload = JSON.stringify({
        status: 'success',
        message: 'Welcome to Node.js Server Environment',
        runtime: process.version,
        timestamp: new Date().toISOString()
    });

    res.writeHead(200, {
        'Content-Type': 'application/json',
        'Content-Length': Buffer.byteLength(responsePayload)
    });
    
    res.end(responsePayload);
});

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

Best Practices & Gotchas

• Never Block the Event Loop: Avoid CPU-bound synchronous computations (e.g. synchronous crypto or huge loops) on the main thread; offload them to Worker Threads or Child Processes.
• Always Handle Unhandled Rejections: Register process.on('unhandledRejection') and process.on('uncaughtException') handlers to prevent process crashing or hidden silent failures.
• Use Modern ES Modules: Prefer standard import/export syntax over legacy CommonJS require() in modern Node.js projects (v18+).

Self-Check Challenge

Write a short script to log the active Node.js runtime version string (process.version) and memory footprint (process.memoryUsage()) to the console.