What is Node.js?

Introduction: The JavaScript Revolution

Node.js is a **JavaScript runtime** built on Chrome's V8 engine. It lets you run JavaScript on your computer/server, not just in browsers.

**Created:** 2009 by Ryan Dahl **Purpose:** Run JavaScript everywhere **Impact:** Revolutionized backend development

Why Node.js Matters

``` Before Node.js: - Frontend: JavaScript - Backend: PHP, Python, Java, Ruby - Result: Learn 2+ languages

After Node.js: - Frontend: JavaScript - Backend: JavaScript (Node.js) - Result: One language for everything! ```

**Benefits:** - **One Language** - JavaScript for frontend and backend - **Fast** - V8 engine compiles to machine code - **Non-Blocking** - Handles thousands of requests - **Huge Ecosystem** - npm has millions of packages - **Easy to Learn** - If you know JavaScript, you're ready!

Complete Node.js Overview

``` ┌─────────────────────┐ │ JavaScript Code │ │ (Your Application) │ └──────────┬───────────┘ │ ┌──────────▼───────────┐ │ Node.js Runtime │ │ ┌────────────────┐ │ │ │ V8 Engine │ │ ← Executes JavaScript │ │ (Chrome's) │ │ │ └────────────────┘ │ │ ┌────────────────┐ │ │ │ libuv │ │ ← Handles async I/O │ │ (Event Loop) │ │ │ └────────────────┘ │ │ ┌────────────────┐ │ │ │ Node.js APIs │ │ ← fs, http, crypto │ └────────────────┘ │ └──────────┬───────────┘ │ ┌──────────▼───────────┐ │ Operating System │ │ (File System, │ │ Network, etc.) │ └──────────────────────┘

What Node.js Does: ├── Runs JavaScript outside browser ├── Accesses file system ├── Creates web servers ├── Connects to databases ├── Handles network requests └── Much more! ```

The Problem: JavaScript Was Limited

Before Node.js (2009), JavaScript could only run in browsers:

``` ┌─────────────────────────────────┐ │ Browser │ │ ┌──────────────────────────┐ │ │ │ JavaScript Engine │ │ │ │ (V8, SpiderMonkey) │ │ │ └──────────────────────────┘ │ │ │ │ ✅ Can manipulate DOM │ │ ✅ Can handle events │ │ ❌ Can't access files │ │ ❌ Can't create servers │ │ ❌ Can't connect to databases │ └─────────────────────────────────┘

Backend Development: ├── PHP ├── Python ├── Java ├── Ruby └── C# / .NET

Result: Different languages for frontend and backend! ```

The Solution: Node.js

Node.js lets you run JavaScript **outside the browser** on your computer/server.

``` ┌─────────────────────────────────┐ │ Node.js Runtime │ │ ┌──────────────────────────┐ │ │ │ V8 JavaScript Engine │ │ │ │ (Same as Chrome!) │ │ │ └──────────────────────────┘ │ │ ┌──────────────────────────┐ │ │ │ System APIs │ │ │ │ - File System (fs) │ │ │ │ - Network (http) │ │ │ │ - OS (os) │ │ │ │ - Crypto │ │ │ └──────────────────────────┘ │ │ ┌──────────────────────────┐ │ │ │ Event Loop │ │ │ │ (Non-blocking I/O) │ │ │ └──────────────────────────┘ │ └─────────────────────────────────┘

✅ Can access files ✅ Can create servers ✅ Can connect to databases ✅ Can do everything backend languages do! ```

How Node.js Works

### Architecture Diagram

``` ┌─────────────────────────────────────────┐ │ Your JavaScript Code │ └─────────────────┬───────────────────────┘ │ ┌─────────────────▼───────────────────────┐ │ Node.js Runtime │ │ ┌──────────────────────────────────┐ │ │ │ V8 Engine (JavaScript Parser) │ │ │ │ - Compiles JS to machine code │ │ │ │ - Executes code │ │ │ └──────────────────────────────────┘ │ │ ┌──────────────────────────────────┐ │ │ │ libuv (C++ Library) │ │ │ │ - Handles async operations │ │ │ │ - Thread pool for heavy tasks │ │ │ │ - Event loop │ │ │ └──────────────────────────────────┘ │ │ ┌──────────────────────────────────┐ │ │ │ Node.js APIs │ │ │ │ - fs, http, crypto, etc. │ │ │ └──────────────────────────────────┘ │ └─────────────────────────────────────────┘ │ ┌─────────────────▼───────────────────────┐ │ Operating System │ │ (File System, Network, etc.) │ └─────────────────────────────────────────┘ ```

**Key Components:** 1. **V8 Engine** - Executes JavaScript (same engine Chrome uses) 2. **libuv** - Handles asynchronous operations 3. **Node.js APIs** - Provides system access (fs, http, etc.)

Before vs After Node.js

### Before Node.js (2009)

``` Frontend Development: ┌─────────────┐ │ JavaScript │ → Browser only └─────────────┘

Backend Development: ┌──────┐ ┌────────┐ ┌──────┐ ┌──────┐ │ PHP │ │ Python │ │ Java │ │ Ruby │ └──────┘ └────────┘ └──────┘ └──────┘

Problem: Learn 2+ languages! ```

### After Node.js

``` Full-Stack Development: ┌─────────────────────────────────┐ │ JavaScript │ │ ┌─────────────┐ ┌──────────┐ │ │ │ Frontend │ │ Backend │ │ │ │ (Browser) │ │ (Node.js) │ │ │ └─────────────┘ └──────────┘ │ └─────────────────────────────────┘

Solution: One language for everything! ```

The Event Loop: How Node.js Handles Multiple Requests

### Traditional Server (Blocking)

``` Request 1 → Process → Wait for DB → Response (2 seconds) Request 2 → Wait... → Wait... → Process → Response (4 seconds) Request 3 → Wait... → Wait... → Wait... → Response (6 seconds)

Problem: Each request blocks others! ```

### Node.js Server (Non-Blocking)

``` Request 1 → Start DB query → Don't wait → Continue Request 2 → Start DB query → Don't wait → Continue Request 3 → Start DB query → Don't wait → Continue

DB responds → Handle Request 1 → Send Response DB responds → Handle Request 2 → Send Response DB responds → Handle Request 3 → Send Response

All requests handled in ~2 seconds! ```

### Event Loop Flow

``` ┌─────────────────────────────────────┐ │ Event Loop │ │ │ │ 1. Execute JavaScript code │ │ 2. If async operation (DB, file): │ │ → Send to thread pool │ │ → Continue to next line │ │ 3. When async completes: │ │ → Callback added to queue │ │ 4. Process callbacks │ │ 5. Repeat │ └─────────────────────────────────────┘

Result: Single thread handles thousands of requests! ```

What Node.js is Good For

### ✅ Great For:

**1. APIs and Web Servers** ``` ┌──────────┐ ┌──────────┐ │ Client │─────▶│ Node.js │ │ │◀────│ Server │ └──────────┘ └──────────┘ Fast response! ```

**2. Real-Time Applications** - Chat apps (WhatsApp, Slack) - Gaming servers - Live notifications - Collaborative editing

**3. Microservices** - Small, independent services - Easy to scale - Fast deployment

**4. CLI Tools** - npm, yarn - Build tools - Automation scripts

**5. Streaming Applications** - Video processing - File uploads - Data pipelines

### ❌ Not Ideal For:

**1. CPU-Intensive Tasks** ``` ❌ Video encoding ❌ Image processing ❌ Machine learning ❌ Heavy calculations

Why? Node.js is single-threaded. Use: Worker Threads or other languages ```

**2. Heavy Computation** - Mathematical calculations - Data analysis - Scientific computing

Your First Node.js Code

```javascript // hello.js console.log('Hello from Node.js!');

// Run it // $ node hello.js // Output: Hello from Node.js! ```

Simple HTTP Server

```javascript const http = require('http');

const server = http.createServer((req, res) => { res.writeHead(200, { 'Content-Type': 'text/plain' }); res.end('Hello World!'); });

server.listen(3000, () => { console.log('Server running on http://localhost:3000'); }); ```

**What happens:** 1. Import `http` module 2. Create server 3. Handle requests 4. Listen on port 3000

Node.js vs Other Technologies

| Feature | Node.js | PHP | Python | Java | |---------|---------|-----|--------|------| | Language | JavaScript | PHP | Python | Java | | Speed | Fast (V8) | Medium | Medium | Fast | | Async | Native | Limited | Limited | Limited | | Learning | Easy (if you know JS) | Easy | Easy | Hard | | Ecosystem | Huge (npm) | Large | Large | Large | | Use Case | APIs, Real-time | Web pages | Data science | Enterprise |

Key Takeaway

Node.js = JavaScript + V8 Engine + System APIs + Event Loop. It enables full-stack JavaScript development with a non-blocking architecture perfect for I/O operations. Single-threaded but handles thousands of concurrent connections through event loop. Start with Node.js if you know JavaScript and want to build backends.