All Roadmaps›🟩 Node.js›Phase 1›What is Node.js & The V8 Engine

What is Node.js & The V8 Engine

📖 Concept

Node.js is a JavaScript runtime built on Chrome's V8 engine that allows you to run JavaScript outside the browser — on servers, CLIs, IoT devices, and more.

Why Node.js matters:

  • Single language for frontend and backend — reduces context-switching
  • Non-blocking I/O — handles thousands of concurrent connections efficiently
  • npm ecosystem — the largest package registry in the world (2M+ packages)
  • Enterprise adoption — Netflix, PayPal, LinkedIn, Uber, NASA all run Node.js in production

How V8 works under the hood:

  1. Parsing — V8 parses your JavaScript into an Abstract Syntax Tree (AST)
  2. Ignition (Interpreter) — Converts AST to bytecode for fast startup
  3. TurboFan (Compiler) — Hot code paths are compiled to optimized machine code (JIT)
  4. Garbage Collection — V8 uses a generational GC (Scavenger for young gen, Mark-Sweep-Compact for old gen)
Source Code → Parser → AST → Ignition (Bytecode) → TurboFan (Optimized Machine Code)
                                    ↑                        ↓
                                    ← Deoptimization ←------←

Node.js ≠ V8 alone. Node.js adds:

  • libuv — Cross-platform async I/O library (event loop, thread pool, file system, DNS, networking)
  • C++ bindings — Bridge between JavaScript and native system APIs
  • Core modules — fs, http, path, crypto, stream, etc.

Node.js architecture layers:

Layer Purpose
Your Code Application logic in JavaScript
Node.js APIs Core modules (fs, http, crypto)
Node.js Bindings C++ glue connecting JS to native code
V8 JavaScript engine (parsing, compilation, execution)
libuv Event loop, thread pool, async I/O
OS System calls, network sockets, file descriptors

🏠 Real-world analogy: Think of V8 as the engine in a car — it's powerful, but the car (Node.js) adds the wheels (libuv), steering (core modules), and dashboard (APIs) to make it useful on the road.

Single-threaded but not single-process: Node.js runs your JavaScript on a single thread, but libuv maintains a thread pool (default 4 threads) for heavy operations like file I/O, DNS lookups, and crypto. This is why Node.js is "non-blocking" — I/O doesn't block the main thread.

💻 Code Example

codeTap to expand ⛶
1// Understanding Node.js runtime capabilities
2

3// 1. Check your Node.js version and V8 version
4console.log("Node.js version:", process.version);     // e.g., v20.11.0
5console.log("V8 version:", process.versions.v8);       // e.g., 11.3.244.8
6console.log("Platform:", process.platform);             // e.g., darwin, linux, win32
7console.log("Architecture:", process.arch);             // e.g., x64, arm64
8

9// 2. V8 memory information
10const v8 = require("v8");
11const heapStats = v8.getHeapStatistics();
12console.log("\n--- V8 Heap Statistics ---");
13console.log("Total heap size:", (heapStats.total_heap_size / 1024 / 1024).toFixed(2), "MB");
14console.log("Used heap size:", (heapStats.used_heap_size / 1024 / 1024).toFixed(2), "MB");
15console.log("Heap size limit:", (heapStats.heap_size_limit / 1024 / 1024).toFixed(2), "MB");
16

17// 3. Demonstrate that Node.js is NOT just a browser
18// ❌ Browser-only APIs (these DON'T exist in Node.js)
19// document.getElementById("app")  → ReferenceError
20// window.location                 → ReferenceError
21// localStorage.setItem()          → ReferenceError
22

23// ✅ Node.js-only APIs (these DON'T exist in browsers)
24const os = require("os");
25console.log("\n--- System Information (Node.js only) ---");
26console.log("CPU cores:", os.cpus().length);
27console.log("Total memory:", (os.totalmem() / 1024 / 1024 / 1024).toFixed(2), "GB");
28console.log("Free memory:", (os.freemem() / 1024 / 1024 / 1024).toFixed(2), "GB");
29console.log("Home directory:", os.homedir());
30console.log("Hostname:", os.hostname());
31

32// 4. Process information — unique to Node.js
33console.log("\n--- Process Information ---");
34console.log("PID:", process.pid);
35console.log("Working directory:", process.cwd());
36console.log("Uptime:", process.uptime().toFixed(2), "seconds");
37console.log("Memory usage:", JSON.stringify(process.memoryUsage(), null, 2));
38

39// 5. Environment variables — critical for production
40// Set: NODE_ENV=production node app.js
41console.log("\nEnvironment:", process.env.NODE_ENV || "development");
42

43// 6. Command-line arguments
44// Run: node app.js --port 3000 --verbose
45console.log("Arguments:", process.argv);
46// process.argv[0] = path to node
47// process.argv[1] = path to script
48// process.argv[2+] = your arguments
49

50// 7. V8 JIT optimization demonstration
51// Functions called many times get optimized by TurboFan
52function hotFunction(a, b) {
53  return a + b; // Called with consistent types → optimized
54}
55

56// Warm up the function (V8 will optimize after ~100-1000 calls)
57for (let i = 0; i < 10000; i++) {
58  hotFunction(i, i + 1); // Always numbers → TurboFan optimizes
59}
60

61// ❌ BAD: Passing different types causes "deoptimization"
62// hotFunction("hello", "world"); // String + String after Number training
63// V8 has to throw away the optimized code and recompile

🏋️ Practice Exercise

Exercises:

  1. Run node -e "console.log(process.versions)" and list all the components Node.js bundles
  2. Write a script that prints all environment variables sorted alphabetically
  3. Create a CLI tool that accepts --name and --greeting flags and prints a custom message
  4. Use v8.getHeapStatistics() to monitor memory before and after creating a large array of 1M objects
  5. Write a script that detects whether it's running on macOS, Linux, or Windows and prints OS-specific info
  6. Benchmark a function by running it 1M times — compare results with console.time() and process.hrtime.bigint()

⚠️ Common Mistakes

  • Thinking Node.js is a programming language — it's a runtime environment for JavaScript, not a language itself

  • Assuming Node.js is single-threaded means it can only do one thing at a time — libuv's thread pool handles I/O in parallel behind the scenes

  • Using browser APIs like document, window, or alert() in Node.js — these don't exist on the server

  • Not understanding the difference between Node.js and npm — Node.js is the runtime, npm is the package manager that ships with it

  • Ignoring V8's JIT optimization by writing polymorphic code (mixing types) in hot paths — this causes deoptimization and performance degradation

💼 Interview Questions

🎤 Mock Interview

Mock interview is powered by AI for What is Node.js & The V8 Engine. Login to unlock this feature.

Next →The Event Loop — Deep Dive