DEV Community: Dhvani

We Own you a lot vercel

Dhvani — Wed, 03 Sep 2025 10:22:23 +0000

A Love Letter to Vercel!

Mahdi Jazini ・ Sep 2

JavaScript’s New structuredClone() Function – Say Goodbye to Deep Cloning Headaches!

Dhvani — Tue, 18 Mar 2025 05:30:22 +0000

Deep cloning in JavaScript has always been a bit of a struggle. We’ve tried everything from using JSON.parse(JSON.stringify())—which fails with functions and circular references—to relying on libraries like lodash’s cloneDeep(). But now, there’s a native solution: structuredClone().

What is `structuredClone()`?

structuredClone() is a built-in deep-cloning function that accurately copies most types of data. Unlike JSON.stringify(), it handles many data types correctly:

Dates, Maps, Sets, and TypedArrays: Clones these without losing their type.
Circular References: Easily clones objects that refer to themselves.
Browser & Node.js Support: Available in modern browsers and Node.js (v17+).

Old vs. New Deep Cloning

The Old Way (Using `JSON.stringify()`)

Consider this example:

const obj = { 
  date: new Date(), 
  func: () => "Hello" 
};

const cloned = JSON.parse(JSON.stringify(obj));

console.log(cloned.date instanceof Date); // false — Date becomes a string!
console.log(cloned.func); // undefined — Functions are lost!

The New Way (Using `structuredClone()`)

Now, see how structuredClone() improves the situation:

const obj = { 
  date: new Date(), 
  func: () => "Hello" 
};

const cloned = structuredClone(obj);

console.log(cloned.date instanceof Date); // true — Date is preserved!
// Note: Functions are not cloned because they aren't serializable.

Important: While structuredClone() correctly handles most data types and circular references, it does not clone functions or prototype chains.

Why `structuredClone()` is a Game-Changer

No More Workarounds: Forget about third-party libraries or manual deep cloning methods.
Handles Complex Structures: Clones objects with circular references without crashing.
Native Performance: Leverages optimized browser internals for better performance.

Cloning Circular References

Old method using JSON.stringify() would throw an error:

const obj = {};
obj.self = obj;

JSON.parse(JSON.stringify(obj)); // Throws an error: Circular structure!

Using structuredClone():

const obj = {};
obj.self = obj;

const cloned = structuredClone(obj);
console.log(cloned.self === cloned); // true — Works flawlessly!

Final Thoughts

If you’ve struggled with deep cloning in JavaScript, it’s time to embrace structuredClone(). This native function makes cloning safer and more reliable—no more battling with JSON quirks or extra libraries!

I'll be back with something new soon!ta-ta

25+ Essential Linux Bash Commands Every Aspiring DevOps Must Know

Dhvani — Fri, 21 Feb 2025 06:39:04 +0000

I'm on a journey to become a DevOps professional, so like many others, I jumped straight into Docker—it's undeniably essential. I even learned the basics check out this guide. But later, I realized just how important Linux is, so I naturally started with Bash😅.

If you want video explanation then please refer this

1. Getting Started: The Terminal Environment
2. Basic Navigation and Directory Management
3. File and Directory Management
4. Viewing and Editing File Content
5. Searching and Filtering Text
6. Managing Permissions and System Commands
7. Additional Helpful Commands
8. Pipes and Redirection
9. Best Practices and Tips for Beginners
10. Conclusion

1. Getting Started: The Terminal Environment

Before diving into commands, remember that the terminal is your gateway to interacting directly with the operating system.

Quick Tips:

Shortcut	Action
`Ctrl + C`	Force-stop a running command
`Ctrl + Z`	Pause a process
`Tab`	Auto-complete filenames
`Ctrl + R`	Search command history
`!!`	Repeat the last command

2. Basic Navigation and Directory Management

`ls` – Listing Directory Contents

Lists files and directories within the current folder.

Basic usage:

ls

Sample Output:

  Desktop  Documents  Downloads  Music  Pictures  Public  Templates  Videos

Detailed list:

  ls -l

Sample Output:

  drwxr-xr-x  2 user user 4096 Feb 20 09:00 Desktop
  drwxr-xr-x  5 user user 4096 Feb 19 08:45 Documents
  -rw-r--r--  1 user user  123 Feb 20 08:00 file.txt

Note: We'll understand this zombie language in the output later—don't worry!

Including hidden files:

  ls -a

Sample Output:

  .  ..  .bashrc  Desktop  Documents  Downloads  Music  Pictures  Public  Templates  Videos

Explanation:

-l = "long format" (detailed information).
-a = "all", including hidden files (files starting with a dot).

`cd` – Changing Directories

Navigate between directories.

Move into a directory:

  cd Documents

Output:

  <your_email_or_username>:~/Documents

Go back to the parent directory:

  cd ..

(your prompt reflects the parent directory.)

Return to your home directory:

  cd ~

Tip: Simply typing cd without arguments does the same.

`pwd` – Print Working Directory

Displays the full path of your current directory.

Usage:

pwd

Sample Output:

  /home/username/Documents

3. File and Directory Management

`mkdir` – Making Directories

Create new folders.

Basic creation:

  mkdir new_folder

Creating nested directories:

  mkdir -p Projects/2025/January

`touch` – Creating or Updating Files

Creates an empty file or updates its modification timestamp.

Example:

  touch file.txt

`cp` – Copying Files and Directories

Copies files or directories to another location.

Copy a file:

  cp file.txt file_backup.txt

ls

Sample Output:

  file.txt  file_backup.txt  Documents  Downloads  ...

Copy a directory recursively:

  cp -r folder1 folder2

Copy Directory Command (Explicit Example):

  cp -r /path/to/source_directory /path/to/destination_directory

Explanation:

The -r flag (recursive) ensures that the entire directory—including subdirectories and files—is copied.

`mv` – Moving and Renaming Files

Moves files between directories or renames them.

Move a file to another directory:

  mv file.txt Documents/

Output:

The file is now inside the Documents directory.
- Rename a file:

  mv oldname.txt newname.txt

Output:

The file now appears as newname.txt in the directory.

`rm` – Removing Files and Directories

Deletes files or directories (use with caution—removals are irreversible by default).

Remove a file:

  rm file.txt

Remove a directory and its contents:

  rm -r folder

Force removal without prompting:

  rm -rf dangerous_folder

4. Viewing and Editing File Content

`cat` – Concatenating, Displaying, and Appending File Content

The cat command is versatile and can be used to display file contents, merge files, or even append new content to an existing file.

Display a file’s content:

  cat file.txt

Sample Output:

  This is a sample text file.
  It has multiple lines.

Merge files into one:

  cat file1.txt file2.txt > combined.txt

Output:

(No direct output; use cat combined.txt to view the merged content.)

Append text to a file interactively:

  cat >> file.txt

Usage:

After running the command, your terminal will wait for you to enter text.
Type in your additional content.
When you’re finished, press Ctrl+D (EOF) to save the appended text and return to the command prompt.

Example Interaction:

  cat >> file.txt
  This is an appended line.
  And another appended line.
  [Press Ctrl+D here]

Result:

The contents of file.txt will now include the new lines at the end:

  This is a sample text file.
  It has multiple lines.
  This is an appended line.
  And another appended line.

`less` – Viewing Files Page-by-Page

Ideal for browsing large files.

Usage:

  less longfile.txt

Behavior:
- The content of longfile.txt is displayed one screen (or line) at a time.
- Navigate using the arrow keys, space bar, Enter, or Page Up/Page Down.
- Exit by pressing q.

Note: While `less` is more feature-rich, the `more` command also allows you to view text files one page at a time.

`head` and `tail` – Viewing the Beginning or End of Files

Quickly view the first or last few lines of a file.

Display the first 10 lines:

  head file.txt

Sample Output:

  Line 1: Introduction to Linux
  Line 2: Basic Commands
  ...
  Line 10: Summary

Display the last 10 lines:

  tail file.txt

Sample Output:

  Line 90: Advanced Topics
  Line 91: Tips and Tricks
  ...
  Line 100: Conclusion

Custom number of lines:

  head -n 5 file.txt
  tail -n 5 file.txt

`clear` – Clearing the Terminal Screen

Keep your workspace uncluttered.

Usage:

  clear

Output:

(Clears the terminal, leaving you with a fresh prompt.)

5. Searching and Filtering Text

`grep` – Searching for Patterns

Find specific text within files.

Basic search for a pattern:

  grep "error" log.txt

Sample Output:

  [ERROR] 2025-02-20 09:30: An error occurred in the application.

Case-insensitive search:

  grep -i "warning" log.txt

Sample Output:

  [WARNING] 2025-02-20 09:31: This is a warning message.

Recursive search in directories:

  grep -r "pattern" /path/to/directory

Output:

(Displays matching lines from all files within the directory tree.)

`find` – Locating Files and Directories

Search for files by name or other attributes.

Find a file by name in the current directory:

  find . -name "file.txt"

Sample Output:

  ./Documents/file.txt

Search for directories starting with "config":

  find . -type d -name "config*"

Output:

(Lists directories that match the given pattern.)

6. Managing Permissions and System Commands

`chmod` – Changing File Permissions

Modify access permissions for files and directories.

Example:

  chmod 755 script.sh

Explanation & Output:

755 means:
- Owner: read, write, execute
- Group and Others: read, execute
If successful, verify using:
```
ls -l script.sh
```
Sample Verification Output:

  -rwxr-xr-x 1 user user 1024 Feb 20 09:00 script.sh

Tip: Experiment with different permission levels to learn more about access control.

`sudo` – Executing Commands with Superuser Privileges

Run commands that require administrative rights.

Example (updating package lists on a Debian-based system): (If you’re not familiar with Debian-based systems, check this out.)

  sudo apt update

Sample Output:

  Hit:1 http://archive.ubuntu.com/ubuntu focal InRelease
  Get:2 http://archive.ubuntu.com/ubuntu focal-updates InRelease [114 kB]
  ...
  Reading package lists... Done

Note: You’ll be prompted to enter your password.

`man` – Accessing Manual Pages

View detailed documentation for commands.

Example:

  man ls

Output:

Opens the manual page for ls in a paginated view.
Navigate using arrow keys and press q to exit.

`echo` – Printing Text and Redirecting Output

Display messages or write text to files.

Print a message to the terminal:

  echo "Hello, Linux!"

Sample Output:

  Hello, Linux!

Write text to a file (overwriting the file):

  echo "Hello, Linux!" > greetings.txt

Output:

(No output; verify by running cat greetings.txt.)

Append text to a file:

  echo "Welcome back!" >> greetings.txt

Output:

(No output; the text is appended to greetings.txt.)

7. Additional Helpful Commands

`history` – Viewing Command History

Review commands you’ve recently executed.

Usage:

  history

Sample Output:

  1  ls -l
  2  cd Documents
  3  cat file.txt
  ...

`alias` – Creating Command Shortcuts

Simplify long commands by creating aliases.

Example:

  alias ll='ls -alF'

Output:

(No output; the alias is now set for the current session. Add to your ~/.bashrc for persistence.)

`df` and `du` – Disk Space Usage

Monitor your disk usage.

df – Display disk free space in a human-readable format:

  df -h

Sample Output:

  Filesystem      Size  Used Avail Use% Mounted on
  /dev/sda1        50G   20G   28G  42% /
  tmpfs           7.8G     0  7.8G   0% /dev/shm

du – Show disk usage for files and directories:

  du -sh *

Sample Output:

  4.0K    file.txt
  1.2M    Documents
  500K    Downloads

8. Pipes and Redirection

Pipes and redirection are powerful features in Bash that allow you to control how data flows between commands and files, enabling you to build complex command sequences and automate tasks efficiently.

Pipes (`|`)

Purpose:

A pipe (|) takes the output (stdout) of one command and sends it directly as input (stdin) to another command.
Example 1: Paginating Output

  ls -l | less

Explanation:

ls -l produces a detailed list of files.
less displays this output one page at a time.
- Example 2: Filtering Data

  dmesg | grep "error"

Explanation:

dmesg outputs system messages.
grep "error" filters for lines containing "error".

Redirection

Redirection lets you change where the output of a command goes or where the command reads its input.

Standard Output Redirection (`>`)

Purpose: Redirects command output to a file, overwriting the file if it exists.
Example:

  echo "Hello, Linux!" > greetings.txt

Explanation:

Writes "Hello, Linux!" to greetings.txt.

Appending Output (`>>`)

Purpose: Appends command output to the end of a file instead of overwriting it.
Example:

  echo "Welcome back!" >> greetings.txt

Explanation:

Adds "Welcome back!" to the end of greetings.txt.

Standard Input Redirection (`<`)

Purpose: Directs a command to take input from a file.
Example:

  sort < unsorted.txt

Explanation:

sort reads from unsorted.txt and outputs sorted results.

Combining Pipes and Redirection

You can mix pipes and redirection for advanced tasks. For example:

Save Filtered Output to a File:

  dmesg | grep "error" > errors.txt

Explanation:

Filters dmesg output for "error" and saves it to errors.txt.

9. Best Practices and Tips for Beginners

Double-check before deleting: Always review what you’re deleting, especially when using recursive options like rm -rf.
Use man or --help: If in doubt, check the manual or use command --help for guidance.
Keep your system updated: Regularly run commands like sudo apt update (on Debian-based systems) to maintain software currency.
Experiment safely: Use a test directory or virtual machine to try out commands without risking important files.

10. Conclusion

That's all for not, this guide covers the essentials of the Linux Bash terminal—from navigation and file management to searching, permissions, and system maintenance. With these commands, sample outputs, and best practices at your fingertips, you're well on your way to mastering the Linux command line.a critical skill for any aspiring DevOps professional.

Happy coding and exploring!

Docker 101: A Simple & Clear Introduction

Dhvani — Thu, 20 Feb 2025 05:01:47 +0000

Just starting out with docker so thought why not make the doc and share it with everyone who is just starting out. this is my first time writing a post feedback are just welcomed so that i can improve and help you better.

Why Do We Need Docker? 🚀
What is Docker?
Why Use Docker?
Docker Image vs Docker Container
How Does Docker Work?
Basic Docker Commands
Push Your Container to Docker Hub
Push Your Container to Docker Hub
Building and Running a Docker Image
Port Mapping in Docker
Docker Compose
Final Thoughts

Why Do We Need Docker? 🚀

Imagine you built a Node.js app on your computer, and it works perfectly. But when you share it with a friend or deploy it to a server, it doesn’t work because:

Your friend doesn’t have Node.js installed.
The server has a different Node.js version.
Some dependencies are missing.
It works on your machine but not elsewhere.

This is called the "It works on my machine" problem 🛑.

What is Docker?

Docker solves this problem by packing everything your app needs (code, dependencies, runtime, OS) into a container.

A container is like a mini-computer that runs the app the same way everywhere, no matter if it’s:

✅ Your computer
✅ A friend’s computer
✅ A server
✅ The cloud

Why Use Docker?

✅ Consistency – Your app works the same everywhere.
✅ No setup needed – No more "install this, install that" nightmares.
✅ Lightweight – Unlike full virtual machines, containers use fewer resources.
✅ Fast Deployment – Just pull and run the container, and your app is ready!
✅ Easy to Share – Send one Docker image, and others can run your app instantly.

Docker Image vs Docker Container

1️⃣ Docker Image = The Recipe 📜

A Docker Image is like a recipe for making pizza.
It has all the ingredients and instructions needed to make the pizza.
But the recipe alone is not a pizza yet!

💡 In Docker terms, an image is a blueprint that tells Docker how to create a running application.

2️⃣ Docker Container = The Actual Pizza 🍕

A Docker Container is like a real, baked pizza made using the recipe.
It is an instance of the image, meaning it is running.
You can eat the pizza (use the app), modify it, or throw it away.

💡 In Docker terms, a container is a running instance of an image.

How Does Docker Work?

You write a Dockerfile (like a recipe for your app).
You build a Docker image (your app + everything it needs).
You run the image inside a container.
The app runs the same everywhere—no missing dependencies, no "works on my machine" issues.

Visual Tip: Imagine this as a cycle: Write → Build → Run → Deploy.

Basic Docker Commands

Command	Description
`docker images`	List all images on your system.
`docker ps`	List running containers.
`docker ps -a`	List all containers (running + stopped).
`docker start <container_name>`	Start a stopped container.
`docker stop <container_name>`	Stop a running container.
`docker rm <container_name>`	Remove a container.
`docker rmi <image_name>`	Remove an image.
`docker exec -it <container_name> bash`	Open a terminal inside a running container.
`docker build -t my-app .`	Build a Docker image from a `Dockerfile`.

Breakdown of Some Parts

docker exec - Runs a command inside an already running container.
-it - Combines two flags:
- -i (interactive mode) - Keeps the input open so you can interact with the container.
- -t (TTY mode) - Allocates a terminal, making it look and feel like a regular shell.
docker build - Tells Docker to build a new image.
-t my-app - Tags the image with the name my-app.
. (dot) - Specifies the current directory as the build context.

Push Your Container to Docker Hub

Login to Docker Hub:

   docker login

Build your image:

   docker build -t <docker_hub_username>/<image_name> .

Push the image:

   docker push <docker_hub_username>/<image_name>

Now anyone can pull and use your image:

docker pull <docker_hub_username>/<image_name>

Building and Running a Docker Image

Dockerfile Example 1

FROM ubuntu

RUN apt-get update
RUN apt-get install -y curl
RUN curl -sL https://deb.nodesource.com/setup_18.x | bash -
RUN apt-get upgrade -y
RUN apt-get install -y nodejs


COPY package*.json ./
COPY main.js ./
RUN npm install

ENTRYPOINT [ "node", "main.js" ]

Explanation

FROM ubuntu → Uses Ubuntu as the base image.
RUN commands → Updates the system, installs curl & Node.js.
COPY commands → Copies package.json and main.js into the container.
RUN npm install → Installs dependencies.
ENTRYPOINT → Runs node main.js when the container starts.

Example 2: Improved Version Using the Node Base Image

FROM node

COPY package*.json ./
COPY main.js ./
RUN npm install

ENTRYPOINT [ "node", "main.js" ]

Explanation

FROM node → Uses the official Node image, which comes pre-installed with Node.js.
COPY commands → Copy package.json (or package-lock.json) and main.js into the container.
RUN npm install → Installs your Node.js dependencies.
ENTRYPOINT → Sets the container to run node main.js on startup.

Benefits of the Improved Version:

Simpler and More Efficient: Eliminates multiple RUN commands and avoids manual installation of Node.js.
Optimized Image Size: The official Node image is optimized for running Node.js applications, resulting in a smaller and more efficient container.
Faster Build Times: Fewer layers and commands mean the image builds more quickly.

Build and Run Commands

docker build -t my-app .   # Build the image
docker run -d -p 3000:3000 my-app  # Run the container

Port Mapping in Docker

When you run a Docker container, you may need to expose certain ports to your machine. Use the -p flag:

docker run -p 8080:80 my-container

Breakdown:

8080:80 → Maps port 80 inside the container to 8080 on your machine.
You can access the app at http://localhost:8080.

Docker Compose

Why Do We Need Docker Compose?

Docker Compose allows you to run multiple containers together with a single command. Instead of running many docker run commands, you define all services in a docker-compose.yml file.

Example: Running a Node.js App with MongoDB

version: "3"
services:
  app:
    build: .
    ports:
      - "3000:3000"
    depends_on:
      - database

  database:
    image: mongo
    ports:
      - "27017:27017"

How It Works

Services: Defines two services: app (Node.js) and database (MongoDB).
Build & Dependencies: The app service builds from the Dockerfile and depends on database, ensuring MongoDB starts first.

Running with Docker Compose

Start all services in the background:

   docker-compose up -d

Stop and remove all services:

   docker-compose down

Common Docker Compose Commands

docker-compose up -d → Start all services in the background.
docker-compose down → Stop and remove all containers.
docker-compose ps → List running services.
docker-compose logs → View logs of all services.

Final Thoughts

🚀 Docker makes development and deployment easier, faster, and more consistent.

💡 Key Takeaways:

Docker Image = Recipe 📜 (Blueprint for an app)
Docker Container = Pizza 🍕 (A running instance of the app)
Docker Compose helps run multiple services together

Additional Tips

Experiment: Don’t be afraid to experiment with small projects. The best way to learn is by doing!
Troubleshooting: If you run into issues, check Docker’s official documentation and community forums.
Practice Commands: Regularly use the basic commands to build muscle memory.
Version Control: Combine Docker with Git to manage your application versions effectively.

Docker 102 Coming Soon

I post different articles on different platforms so must check them out...you won't regret.

Medium
Daily Dev

DEV Community: Dhvani

We Own you a lot vercel

A Love Letter to Vercel!

Mahdi Jazini ・ Sep 2

JavaScript’s New structuredClone() Function – Say Goodbye to Deep Cloning Headaches!

What is structuredClone()?

Old vs. New Deep Cloning

The Old Way (Using JSON.stringify())

The New Way (Using structuredClone())

Why structuredClone() is a Game-Changer

Cloning Circular References

Final Thoughts

25+ Essential Linux Bash Commands Every Aspiring DevOps Must Know

Table of Contents

1. Getting Started: The Terminal Environment

2. Basic Navigation and Directory Management

ls – Listing Directory Contents

cd – Changing Directories

pwd – Print Working Directory

3. File and Directory Management

mkdir – Making Directories

touch – Creating or Updating Files

cp – Copying Files and Directories

mv – Moving and Renaming Files

rm – Removing Files and Directories

4. Viewing and Editing File Content

cat – Concatenating, Displaying, and Appending File Content

less – Viewing Files Page-by-Page

Note: While less is more feature-rich, the more command also allows you to view text files one page at a time.

head and tail – Viewing the Beginning or End of Files

clear – Clearing the Terminal Screen

5. Searching and Filtering Text

grep – Searching for Patterns

find – Locating Files and Directories

6. Managing Permissions and System Commands

chmod – Changing File Permissions

sudo – Executing Commands with Superuser Privileges

man – Accessing Manual Pages

echo – Printing Text and Redirecting Output

7. Additional Helpful Commands

history – Viewing Command History

alias – Creating Command Shortcuts

df and du – Disk Space Usage

8. Pipes and Redirection

Pipes (|)

Redirection

Standard Output Redirection (>)

Appending Output (>>)

Standard Input Redirection (<)

Combining Pipes and Redirection

9. Best Practices and Tips for Beginners

10. Conclusion

Docker 101: A Simple & Clear Introduction

Table of Contents

Why Do We Need Docker? 🚀

What is Docker?

Why Use Docker?

Docker Image vs Docker Container

1️⃣ Docker Image = The Recipe 📜

2️⃣ Docker Container = The Actual Pizza 🍕

How Does Docker Work?

Basic Docker Commands

Breakdown of Some Parts

Push Your Container to Docker Hub

Building and Running a Docker Image

Dockerfile Example 1

Explanation

Example 2: Improved Version Using the Node Base Image

Explanation

Build and Run Commands

Port Mapping in Docker

Breakdown:

Docker Compose

Why Do We Need Docker Compose?

Example: Running a Node.js App with MongoDB

How It Works

Running with Docker Compose

Common Docker Compose Commands

Final Thoughts

Additional Tips

What is `structuredClone()`?

The Old Way (Using `JSON.stringify()`)

The New Way (Using `structuredClone()`)

Why `structuredClone()` is a Game-Changer

`ls` – Listing Directory Contents

`cd` – Changing Directories

`pwd` – Print Working Directory

`mkdir` – Making Directories

`touch` – Creating or Updating Files

`cp` – Copying Files and Directories

`mv` – Moving and Renaming Files

`rm` – Removing Files and Directories

`cat` – Concatenating, Displaying, and Appending File Content

`less` – Viewing Files Page-by-Page

Note: While `less` is more feature-rich, the `more` command also allows you to view text files one page at a time.

`head` and `tail` – Viewing the Beginning or End of Files

`clear` – Clearing the Terminal Screen

`grep` – Searching for Patterns

`find` – Locating Files and Directories

`chmod` – Changing File Permissions

`sudo` – Executing Commands with Superuser Privileges

`man` – Accessing Manual Pages

`echo` – Printing Text and Redirecting Output

`history` – Viewing Command History

`alias` – Creating Command Shortcuts

`df` and `du` – Disk Space Usage

Pipes (`|`)

Standard Output Redirection (`>`)

Appending Output (`>>`)

Standard Input Redirection (`<`)