DEV Community: Kumar Ayush

🌐 Mastering HTTP, HTTPS & URL Modules in Node.js — The Foundation of Web Servers

Kumar Ayush — Wed, 02 Jul 2025 18:16:05 +0000

When working with Node.js, one of the core capabilities it offers is to create web servers from scratch using native modules — no frameworks like Express needed (though they help a lot!).

In this blog, we’ll explore three key core modules:

http – build your own basic web server
https – build secure servers using SSL/TLS
url – parse and manipulate URLs like a pro

We’ll also compare these native approaches with Express.js to see why frameworks matter.

📦 1. The HTTP Module — Your First Node.js Server
Node.js provides a built-in http module that allows you to spin up a web server without using Express or any third-party library.

🧠 Concept
An HTTP server listens for incoming requests on a port.
It then sends back responses based on the request URL or method.
💡 Basic Example

const http = require('http');

const server = http.createServer((req, res) => {
  if (req.url === '/') {
    res.end('Welcome to the Home Page');
  } else if (req.url === '/about') {
    res.end('About Page');
  } else {
    res.end('404 Not Found');
  }
});
server.listen(3000, () => {
  console.log('Server running at http://localhost:3000');
});
🔍 Breakdown
http.createServer(callback) – sets up a server
req.url – gives the URL path
res.end() – ends the response

🔐 2. The HTTPS Module — Secure Your Communication
While http is great, it’s not secure. That’s where https comes in.

✅ Why Use HTTPS?
Encrypts communication (SSL/TLS)
Mandatory for handling passwords, payments, etc.
Required in production environments
📁 Prerequisite: SSL Certificates
You need:

A private key (key.pem)
A certificate (cert.pem) Generate self-signed ones for testing:

openssl req -nodes -new -x509 -keyout key.pem -out cert.pem
💡 HTTPS Server Example

const https = require('https');
const fs = require('fs');

const options = {
  key: fs.readFileSync('key.pem'),
  cert: fs.readFileSync('cert.pem')
};
https.createServer(options, (req, res) => {
  res.writeHead(200);
  res.end('Hello from Secure HTTPS Server!');
}).listen(4433, () => {
  console.log('HTTPS Server running on https://localhost:4433');
});

🌐 3. The URL Module — Parsing Made Simple
Want to extract ?term=react or /products from incoming requests? That’s what the url module is for.

💡 Modern URL Parsing

const { URL } = require('url');

const myURL = new URL('https://example.com/products?category=books&id=101');
console.log(myURL.hostname);  // example.com
console.log(myURL.pathname);  // /products
console.log(myURL.searchParams.get('category')); // books

🔁 Comparing: Native https vs Express
Let’s see how things differ between native Node.js and Express.

🧪 Task: Parse /search?term=react

Using Native HTTPS:
const https = require('https');
const fs = require('fs');
const { URL } = require('url');

const options = {
  key: fs.readFileSync('key.pem'),
  cert: fs.readFileSync('cert.pem')
};

https.createServer(options, (req, res) => {
  const fullUrl = `https://${req.headers.host}${req.url}`;
  const parsedUrl = new URL(fullUrl);
  if (parsedUrl.pathname === '/search') {
    const term = parsedUrl.searchParams.get('term') || 'none';
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ message: 'Search term received', term }));
  } else {
    res.writeHead(404);
    res.end('404 Not Found');
  }
}).listen(4433);

Using Express (Much Simpler!)

const express = require('express');
const https = require('https');
const fs = require('fs');

const app = express();
const options = {
  key: fs.readFileSync('key.pem'),
  cert: fs.readFileSync('cert.pem')
};

app.get('/search', (req, res) => {
  const term = req.query.term || 'none';
  res.status(200).json({ message: 'Search term received', term });
});
https.createServer(options, app).listen(4433, () => {
  console.log('Express HTTPS server running at https://localhost:4433');
});

🔧 Bonus: Middleware Example in Express

const morgan = require('morgan');
app.use(morgan('dev')); // Logs every incoming request

In native https, you'd have to code logging, parsing, etc., all manually!

🎯 Conclusion
Understanding how Node.js works at the core level gives you control and insight into what frameworks like Express abstract away. Here’s what we learned:

Use http or https for learning or small utilities.
For production-grade apps, always use https with SSL.
Use the modern URL class for parsing.
Express makes development faster, cleaner, and more scalable.

🧪 Try It Yourself
✅ Generate SSL certs
✅ Build both native and Express-based HTTPS servers
✅ Parse query parameters from /search?term=yourvalue

Then… compare your code and see why Express is a game-changer!

🔍 Demystifying Node.js Core Modules: A Practical Dive into fs and path

Kumar Ayush — Mon, 30 Jun 2025 18:39:28 +0000

Whether you're just diving into backend development or brushing up on Node.js fundamentals, understanding the built-in fs and path modules is a game changer. These core modules—available without any external installation—lay the groundwork for working efficiently with files and directories across platforms.

🚀 Why Core Modules Matter
Node.js ships with powerful internal tools like fs (file system) and path (path utilities) to help developers:

Read, write, and manage files with ease

Build platform-agnostic paths that work seamlessly across Windows, Linux, and macOS

Let’s explore how these tools fit into your developer toolkit.

📁 Working with the fs Module
The fs module allows both synchronous and asynchronous file operations—ideal for learning and production use respectively.

**✍️ Writing Files
**js

// Synchronous
fs.writeFileSync('example.txt', 'Hello, Node.js!');

// Asynchronous
fs.writeFile('exampleAsync.txt', 'Async Hello!', (err) => {
  if (err) throw err;
  console.log('File created!');
});

📖 Reading Files
js

// Synchronous
const data = fs.readFileSync('example.txt', 'utf-8');
console.log(data);

// Asynchronous
fs.readFile('exampleAsync.txt', 'utf-8', (err, data) => {
  if (err) throw err;
  console.log(data);
});

➕ Appending Content
js

fs.appendFileSync('example.txt', '\nThis is a new line.');
fs.appendFile('example.txt', '\nAsync line here.', (err) => {
  if (err) throw err;
});

🗑️ Deleting Files
js

fs.unlinkSync('example.txt');
fs.unlink('exampleAsync.txt', (err) => {
  if (err) throw err;
  console.log('File deleted!');
});

🗂️ Directories and Listing Contents
js

// Create folder
fs.mkdirSync('myFolder');

// Read current directory
const files = fs.readdirSync('.');
console.log(files);

🧭 Navigating with the path Module
The path module keeps your file paths robust and cross-platform.

🛠️ Common Utilities
js

const path = require('path');

// Joins segments into a normalized path
const filePath = path.join('folder', 'file.txt');

// Gets full absolute path
const absolutePath = path.resolve('folder', 'file.txt');

// Extracts file name, dir, and extension
const base = path.basename('/users/kumar/index.js');
const dir = path.dirname('/users/kumar/index.js');
const ext = path.extname('index.js');

🧪 Utility Checks
js

path.isAbsolute('/folder/file.txt');  // true
path.normalize('folder/../folder2/./file.txt');  // 'folder2/file.txt'

🤝 In Tandem: fs + path
js
const fullPath = path.join(__dirname, 'notes', 'todo.txt');
fs.writeFileSync(fullPath, 'Complete MERN Day 2');

🎯 Wrap-Up
The fs and path modules offer an elegant way to work with files in a platform-safe, efficient manner. Mastering them early on sets the foundation for scalable file operations in real-world applications.

Stay tuned as I continue my MERN stack journey—next up, diving into server-side routing and handling requests using Express.js!!

🚀 Just dropped a beginner-friendly deep dive into Node.js—exploring its event-driven architecture, non-blocking I/O, and why it’s a game-changer for modern backend development.

Kumar Ayush — Sun, 29 Jun 2025 18:09:08 +0000

Kumar Ayush

Jun 29 '25

Getting Started with Node.js: A Beginner’s Guide

#backend #node #javascript #webdev

Comments

2 min read

Getting Started with Node.js: A Beginner’s Guide

Kumar Ayush — Sun, 29 Jun 2025 18:00:19 +0000

JavaScript has long been a front-end favorite, powering interactive experiences in browsers. But what if you could bring that same language to your server-side code? Enter Node.js—a lightweight, powerful runtime that lets you run JavaScript outside the browser.

🔍 What Is Node.js??
Node.js is an open-source, cross-platform JavaScript runtime built on Chrome’s blazing-fast V8 engine. It enables developers to build scalable network applications using JavaScript—on the backend.

Think of Node as your way to bring JavaScript everywhere—from browser to server, from simple scripts to full-blown APIs.

✨ Key Features That Make Node.js Shine
Single-threaded but scalable: Handles multiple tasks with one thread using smart asynchronous operations.

Non-blocking I/O: Keeps the event loop flowing, allowing it to handle multiple requests without waiting.

Built-in modules: Native support for the file system, HTTP, streams, and more.

npm ecosystem: Access to a massive library of packages via Node Package Manager.

Real-time magic: Perfect for apps like chats, games, and live dashboards.

🧠 Under the Hood: How Node.js Works
At first glance, using a single thread for all your server logic sounds... risky. But Node makes it work with a clever mechanism:

🌀 The Event Loop
Node is event-driven—it doesn’t block the thread while waiting for tasks like file reading or database calls. Instead:

It delegates long tasks to the system.

Keeps accepting new tasks while others are “in progress.”

When those tasks complete, Node gets notified and calls your callback functions.

It’s like a restaurant where the chef (Node) doesn’t cook everything personally but delegates certain items, keeps taking new orders, and calls the server when food’s ready.

⏱️ A Quick Example: setTimeout

console.log("Start");

setTimeout(() => {
  console.log("Inside Timeout");
}, 0);

console.log("End");

Output

Start
End
Inside Timeout

Even with a 0ms delay, the function gets queued and executed after the synchronous code finishes. That’s the event loop in action!

🆚 Blocking vs Non-Blocking Code

🔒 Blocking:

const data = fs.readFileSync('file.txt');
console.log(data.toString());

This pauses everything until the file is read.
🔓 Non-Blocking:

fs.readFile('file.txt', (err, data) => {
  console.log(data.toString());
});
console.log("File read requested...");

🎯 When Should You Use Node.js??
Node excels when:

You’re building REST APIs and services

You want real-time apps (chat, games, live updates)

You need custom CLI tools

You want server-side rendering or streaming data

🌟 Final Thoughts
If you’re looking to build fast, modern, real-time applications—all while speaking the JavaScript you already know—Node.js is your gateway to full-stack brilliance. Its non-blocking model, rich ecosystem, and performance make it an excellent choice for developers of all levels.

Curious where to go from here? Next up: dive into setting up your first Node.js server!

System Design : Observer Design Patterns

Kumar Ayush — Sun, 23 Mar 2025 18:14:22 +0000

Welcome to Day 2 of my System Design Learning Series! Today, let's dive into Design Patterns, Observer Pattern.
📌 Use Case: Payment methods in e-commerce (Credit Card, PayPal, UPI).
🔹 Observer Design Pattern (Brief Overview)
The Observer Pattern establishes a one-to-many dependency between objects, so when one object (Observable) changes, all dependent objects (Observers) are notified.
📌 Use Case: Notification systems, event listeners, stock price updates.
🔍 Deep Dive: Observer Pattern – Walmart SDE Interview Question
❓ Implement a notify function to notify all subscribers when an event occurs.
💡 Solution:
1️⃣ Define an Observable (Publisher) that maintains a list of observers.
2️⃣ Implement attach, detach, and notify methods.
3️⃣ Product extends Observable : Whenever the product properties changes, all observers get updated.
4️⃣ The Observers (Subscribers) react when notified.

Here’s the Observer Pattern implementation for the problem using javascript:

class Observable {
 constructor() { 
 this.observers = []; //maintaining list of observer
 }

 attach(observer) {
 this.observers.push(observer); //adding new observer
 }

 detach(observer) {
 this.observers = this.observers.filter(obs => obs !== observer); 
 //removing an observer in case of unsubscribing from notification service
 }

 notify(data) {
 this.observers.forEach(observer => observer.update(data));
 }
}

class Product extends Observable {
 constructor(name, price) {
 super();
 this._name = name;
 this._price = price;
 }

// calling notify() whenever product value changes
 set name(newName) {
 this._name = newName;
 this.notify(`Product name updated to: ${newName}`);
 }

 set price(newPrice) {
 this._price = newPrice;
 this.notify(`Price updated to: $${newPrice}`);
 }
}


// creating an observer class to identify each observer
class Observer {
 constructor(name) {
 this.name = name;
 }

 update(message) {
 console.log(`${this.name} received update: ${message}`);
 }
}

// Usage Example:
const product = new Product("Laptop", 1000);

const observer1 = new Observer("Observer 1");
const observer2 = new Observer("Observer 2");

product.attach(observer1);
product.attach(observer2);

product.price = 1200; // Notifies observers
product.name = "Gaming Laptop"; // Notifies observers

observable.notify("New Event Occurred!"); // Both observers get notified

const product = new Product("Laptop", 1000);

const observer1 = new Observer("Observer 1");
const observer2 = new Observer("Observer 2");

product.attach(observer1);
product.attach(observer2);

product.price = 1200; // Notifies observers
product.name = "Gaming Laptop"; // Notifies observers

observable.notify("New Event Occurred!"); // Both observers get notified

🌟 Key Takeaways
✅ Loose Coupling: The observable and observers interact with minimal dependency.
✅ Flexibility: New observers can be added/removed dynamically.
✅ Real-World Use Cases: Notification services, stock market updates, event-driven systems.
What’s your take on the Observer Pattern? Have you encountered it in real-world scenarios? Let’s discuss in the comments! 🚀