Forem: Kunal

You dont know about javascript : Synchronous vs Asynchronous

Kunal — Sat, 18 Apr 2026 11:48:28 +0000

First i strongly recommend you to read my following blog 👇

Kunal

Mar 15

Node.js Internals: Read This Before Your Next Backend Interview

#node #javascript #interview #backend

Comments

7 min read

It covers all the basic terminologies with beautiful explanation which i am using in this blog.

Lately when i studied about the architecture of Node.js and how beautifully it handles JavaScript internally i got amazed.

And there i got to know about the behavior of Synchronous & Asynchronous JavaScript

In this blog we will cover :-

What synchronous code means
What asynchronous code means
Why JavaScript needs asynchronous behavior

JavaScript is Synchronous

By default JavaScript is synchronous single threaded language.

Means code executes from top to bottom , left to right sequentially and wait until one code gets finished.


function f1() {
  // Some code
}
function f2() {
  f1();
}
function f3() {
  f2();
}
f3();

Underthehood it will create a stack (Data-Structure in JavaScript) also known as call Stack which keeps the record of function.

If the function call another function then engine adds the second function to the stack and start executing it until it finishes and then takes it out from the stack.

credits :- https://www.freecodecamp.org/news/synchronous-vs-asynchronous-in-javascript/

Hope you understand it now how JavaScript handles synchronous code

Asynchronous JavaScript

An Asynchronous code runs in background without stopping your main code.

Unlike synchronous code it doesn't block your main thread So your code can execute without waiting another code to finish



setTimeout(() => console.log("Like and share") , 1000)
console.log("Already liked this blog !!!")

In the above example what we do is simply make a Asynchronous function that will execute after 1sec it will not block the block main thread to execute my another console log

But why do we need asynchronous behavior lets see

Why JavaScript needs asynchronous behavior

JavaScript needs asynchronous behavior as it is single threaded it can do only one thing at a time

If everything were synchronous:

Handling database took soo much time that you can't imagine
Also API calls , file read , timers would block the main thread

If you want to know more about asynchronous behavior check this blog 👇

Kunal

Apr 15

Callbacks in JavaScript

#javascript #tutorial #beginners #programming

Comments

3 min read

I have covered all the examples there using asynchronous callbacks

Thanks for reading ! if enjoyed this blog , you can read more on this 👇

Kunal Follow

My tokens expired idk how to write bio. 😪🫠

Polyfills 101: Impress your interviewer

Kunal — Sat, 18 Apr 2026 08:52:21 +0000

Sometimes I wonder if I were still my old 2010 Windows 7 PC with UC Browser in big 2026 would modern websites even work on it?

Some visitors are still using Internet Explorer or Safari till date and we cant write modern code and expect it to work for them.

So in this blog we will cover :-

What string methods are
Why developers write polyfills
Common interview string problems
Importance of understanding built-in behavior

String methods

Before hopping into the Polyfills we have to know what and where we use this modern javascript by lookin into some string methods and making our own string methods by using polyfills.

In JavaScript strings are the sequence of character and JavaScript provides a set of methods to manipulate and work with string.

I will **introduce only 2 main string method **here and rest you can do with your own

toUpperCase()

If you want to convert a string to uppercase, Then you can use toUpperCase() method.


const str = "like this blog"

console.log("Uppercase :-" , str.toUpperCase())

Using polyfills


String.prototype.toOwnUpperCase = function () {
  let result = "";

  for (let i = 0; i < this.length; i++) {
    let code = this.charCodeAt(i);

    // a-z → A-Z
    if (code >= 97 && code <= 122) {
      code = code - 32;
    }

    result += String.fromCharCode(code); // number to char 
  }

  return result;
};

console.log("hello".toOwnUpperCase()) // HELLO

trim()

If you want to trim the starting and ending empty space from the string , then you can use time()


const str = "    Like this blog.    ";
const trimmedStr = str.trim();
console.log(trimmedStr); // Output: This is a string.

Using polyfills


String.prototype.myOwnTrim = function () {
  let start = 0;
  let end = this.length - 1;

  while (start <= end && this[start] === " ") start++;
  while (end >= start && this[end] === " ") end--;

  let result = "";
  for (let i = start; i <= end; i++) {
    result += this[i];
  }

  return result;
};

console.log("    Like this blog.    ".myOwnTrim()) //Like this blog.

Hope you have a rough idea what are polyfills and how we can write our own
but why does developer use polyfills let see.

Why developers write polyfills

Developer write polyfills as some of your website visitors use old internet explorer or UC browser and we don't use modern JavaScript for them because old browser doesn't understand modern JavaScript

Faced with the reality that you cant write modern code and expect it to work for all users, You have exactly two choice

Only use language features available in all the browser you support
Write modern code and do something to make it work in older browser

Yes obvious you choose option 2 if you choose option 1 i am sorry you need to take some rest.

I hope you have now understand what are polyfills and why developers use
polyfills. Now you are interview ready lets see some common question asked in interview

Common interview string problems

I have covered 2 most important example before and covering 2 more now that actually asked by the interviewer.

.includes()

The .includes() method return true if a string contain a specific string.

let see first how we write this in modern javascript and then we make our own


let text = "Like this blog";
let result = text.includes("blog");

console.log(result) // true

Using polyfills


String.prototype.myIncludes = function (word, search = 0) {
    if (search === "") return true;
  for (let i = 0; i < this.length - word.length; i++) {
    let match = true;

    for (let j = 0; j < word.length; j++) {
      if (this[i + j] !== word[j]) {
        match = false;
        break;
      }
    }

    if (match) return true;
  }
  return false
};


console.log("abc".myIncludes("d")); //false

.startsWith() / .endsWith()

The .startsWith() / .endsWith() method returns true if a string ends/starts with a specific string


let text = "Hello world";
let result = text.endsWith("world");

console.log(result) // true

Using polyfills


String.prototype.myStartsWith = function (search, position = 0) {
  for (let i = 0; i < search.length; i++) {
    if (this[position + i] !== search[i]) return false;
  }
  return true;
};

console.log("abc".startsWith("d"))// false

Importance of understanding built-in behavior

When you working with JavaScript string methods its not enough to know what they do you should also understand how they behave internally

Build in methods often have small edge cases that can be easily missed.

For example :


"     Like this blog    ".trim()

It might feel unexpected but .trim() always removes starting and ending space from the string if you don't know this behavior your polyfill might be incorrect.

Thanks for reading ! if enjoyed this blog , you can read more on this 👇

Kunal Follow

My tokens expired idk how to write bio. 😪🫠

Callbacks in JavaScript

Kunal — Wed, 15 Apr 2026 12:21:43 +0000

When you writing JavaScript you come across the term callback but you may feel confused. Many newcomers to JavaScript find callbacks hard to understand too.

So In this blog we will cover :

What a callback function is
Passing functions as arguments
Why callbacks are used in programming
Callback usage in common scenarios
Basic problem of callback nesting

Callback function

A callback is a function that takes another function as an argument to be execute later

They are so common in JavaScript that you probably used callback by yourself without knowing they are callbacks

Lets see how it looks :


const button = document.querySelector('button')
button.addEventListener('click', function () {

  console.log("clicked")
})

Here , in the code we told JavaScript to listen for the click event on the button. If the button is clicked JavaScript will fired the click function

Now i am sure that you understand the term callback function and how they are used. But why ? Why do we need these callback function.

Why callbacks are used in programming

Callbacks are used in two different ways in programming one is synchronous and asynchronous functions

Synchronous Functions

If your code executes from top to bottom , left to right sequentially and wait until one code to finish you code is synchronous

Lets look at an example to make it easier to understand :


const addOne =n => n+1

addOne(1)
addOne(2)
addOne(3)
addOne(4)
addOne(5)

Callbacks are used in synchronous functions when you want a part of the code to be easily swapped with something else.

Asynchronous functions

An asynchronous function is a task that runs in background without stopping your main code

Lets look at an example to make it easier to understand :


setTimeout(() => console.log("Like and share") , 1000)
console.log("Already liked this blog !!!")

So in the above example what we do is simply make a Asynchronous function that will execute after 1sec it will not block the block main thread to execute my another console log

Callback usage in common scenarios

Callbacks are very useful feature in JavaScript that has ample amount of scenarios i will cover 3 here apart from the example which i cover before

API / Data fetching

The most common usage of callbacks are fetching data from the APIs


fetchData((data) => {
  console.log(data);
});

File handling (Node.js)

File handling is an important operation in Node.js that allows performing CRUD operations on files


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

Database operations

In Node.js database operations use callbacks to run code one after another

db.query("SELECT * FROM users", (err, result) => {
  console.log(result);
});

These are some of the example of callbacks that used in a programmer everyday life.

Basic problem of callback

Do you ever heard of the term "Callback Hell" it is a phenomenon where multiple callbacks are nested after each other
It happen when you do an asynchronous activity that's dependent on previous asynchronous activity

This make the code harder to read

Let look into the example :


loginUser("kunal", (user) => {
  getProfile(user.id, (profile) => {
    getPosts(profile.id, (posts) => {
      getComments(posts[0].id, (comments) => {
        console.log("Final Data:", comments);
      });
    });
  });
});

pretty hard right ??

One solution to overcome callback hell is to break the callback function into smaller code or Your JavaScript promises and async / await

If you want to know i have a blog , read 👇

Kunal

Mar 1

JavaScript Promises Explained: A Startup Analogy for Beginners

#discuss #javascript #webdev #node

Comments

4 min read

Thanks for reading ! if enjoyed this blog , you can read more on this 👇

Kunal Follow

My tokens expired idk how to write bio. 😪🫠

Template Literals > Your Old Code

Kunal — Fri, 10 Apr 2026 17:30:30 +0000

Few day ago i noticed my friend still using the same old code for string concatenation i mean it good but it gets messy and hard to read when the code gets bigger

In this blog we will cover :

Traditional string concatenation
Template literal syntax
Multi-line strings
Use cases in modern JavaScript

Traditional string concatenation

Before we get into t*emplate literals* lets see the old traditional way

In this you have to use + symbol when you want to concatenate the strings

const userName = "kunal"
const balance = 100

const str1 = 'Hi ' + userName + ',' + ' your balance is ' + balance + '.'

console.log(str1)

Output of the above code

Hi kunal , your balance is 100.

Note how using regular string involves adding many + symbols also you have to add white spaces too at right place.

This can get difficult and hard to read over time when your code get lengthy

with template literals you can do this easily. let see

Template literal

Template literals are the ES6 feature in JavaScript that lets you to concatenate the string by just using backticks


const userName = "kunal"
const balance = 100

const str2 = `Hi ${userName}, your balance is ${balance}.`
console.log(str2)

Output of the above code

Hi kunal , your balance is 100

With template literals there is no need to add any plus signs and extra white spaces.
You just write everything together as a single string in backticks using the ${} syntax

Multi-line strings

Another way template literals make it easier to work with stings when we are dealing with multi-line strings

In traditional string :


const regularString = 
'Hello there! \n' +
'Please like the blog \n' +
'And share it'

Output of the above code

Hello there! 
Please like the blog
And share it

We have to use the combination of + sign and \n to denote new line.

In template literals :


const templateLiteral = 
`Hello there!
Please like the blog
And share it`

Output of the above code

Hello there! 
Please like the blog
And share it

Template literals preserve line breaks and formatting exactly as written.

By using backticks, you don’t need + or \n the string is handled automatically in a clean and readable way.

Use cases in modern JavaScript

So far, you've learned what template literals are and how they compare with traditional strings method. Now, let's look at some practical example.


function formatMessage (strings , ...values){
  const concatinateStrings = ''  

  for(let i = 0  ; i < values.length ; i++ ){
      concatinateStrings = strings[i] + values[i]
   }

  finalString += strings[strings.length - 1]
  return finalString.trim()

}


const user = 'Kunal'
const task = 'JavaScript blog'
const time = '2 hours'

const message = formatMessage`
  ${user} completed the ${task}
  in ${time}.
`

console.log(message)

Output of the above code

Kunal completed the JavaScript blog
in 2 hours.

In this example, the formatMessage function receives a template literal with four expressions:


${user}

${task}

${time}

The values array will contain the evaluated values of these expressions.

You also learned about an advanced feature of template literals: tagged template literals.
These are functions that take in an array of string blocks and expressions.

Thanks for reading ! if enjoyed this blog , you can read more on this 👇

Kunal Follow

My tokens expired idk how to write bio. 😪🫠

Master Array Flattening in JS

Kunal — Tue, 07 Apr 2026 18:12:13 +0000

While writing a blog on array methods i got to know about one method that deal with nested array which is array.flat().

If you also want to read that blog read this 👇

Kunal

Mar 3

If You Don’t Know These Array Methods, We Need to Talk.

#discuss #javascript #node #computerscience

Comments

3 min read

Before ES6, flattening arrays wasn’t straightforward and often required complex logic. Thankfully, modern JavaScript provides much simpler and cleaner ways to handle it.

Topics to Cover

What nested arrays are
Why flattening arrays is useful
Different approaches to flatten arrays

Nested arrays

Nested array are the arrays that contain other array as their elements.

Instead of holding value like string and object, a nested array store one or more array inside it.


const deepArr = [1, [2, [3, [4]]]];

Why flattening arrays is useful

When working with nested arrays that contain multiple levels of data, it can quickly become difficult to read, manage, and process the values effectively.

To simplify this, we use array flattening.

Flattening an array means converting a nested (multi-level) array into a single-level array. This makes the data easier to understand, iterate over, and work with in your code.


const nestedArr = [1, 2, [3, 4], [5, 6]];
                ↓
Output: [1, 2, 3, 4, 5, 6]

Different approaches to flatten arrays

1. Using while loop with a recursive helper function

This method uses a loop to go through each item and put it into a new array.

If it finds another array inside, it goes inside that array and does the same thing again. It keeps doing this until there are no more arrays inside.

In the end, everything gets added into one simple flat array.


const flatten = (nested) => {
  const flat = [];
  const handleFlat = (array) => {
    let counter = 0
    while (counter < array.length) {
      const val = array[counter];
      if (Array.isArray(val)) {
        handleFlat(val);
      } else {
        flat.push(val)
      }
      counter++;
    }
  }
  handleFlat(nested);
  return flat;
}


console.log(flatten(a)); // [1, 2, 3, 4, 5, 6, 7];

2. Using Reduce and Concat Method

This method is kind of like the first one, but it only goes one level deep.

It uses concat() to add things into a new array.
If it sees a normal value, it just adds it.
If it sees an array, it takes out its items and adds them instead.


const arr = [1, 2, [3, 4]];
// To flat single level array

arr.reduce((acc, val) => acc.concat(val), []);
// [1, 2, 3, 4]

3. Using Array.flat()

This function is actually the reason I decided to write this article.
JavaScript already knew this problem exists, so it gave us a built-in method for it.
By default, it only flattens the array one level. But you can give it a number to tell it how many levels you want to flatten.
And if you don’t want to think about levels at all, just pass Infinity it will flatten everything completely.


const arr1 = [1, 2, [3, 4]];
arr1.flat(); 
// [1, 2, 3, 4]

const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat();
// [1, 2, 3, 4, [5, 6]]

const arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat(2);
// [1, 2, 3, 4, 5, 6]

const arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat(Infinity);
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]


/* Flatten Array Holes */
const arr5 = [1, 2, , 4, 5];
arr5.flat();
// [1, 2, 4, 5]

Blog refrence :- https://medium.com/swlh/how-to-flatten-an-array-in-javascript-6b3fef075655

Thanks for reading ! if enjoyed this blog , you can read more on this 👇

Kunal Follow

My tokens expired idk how to write bio. 😪🫠

Spread vs Rest Operators in JavaScript

Kunal — Sat, 04 Apr 2026 09:20:58 +0000

Lately i have been writing a lot of backend code and kept getting confuse when to use spread operator and when to use rest

While searching the solution i realized many developers have same problem.

So in this blog i will break it down simply when to use each and common mistakes to avoid.

Topics to Cover

What rest operator does
What spread operator does
Differences between spread and rest
When to Use the Rest and Spread Operator

The Rest and Spread operator are two different operators but both uses three dots (...) so they can be confusing.

Why are they using three dots in JavaScript if they are not same lets see individually

Rest Operator

Think of rest exactly like it name
It means give me the rest of the values that are left


const user = {
  id: 1,
  name: "Kunal",
  email: "kunal@gmail.com",
  role: "admin",
  password: "secret"
};

// REST → extract password, collect remaining
const { password, ...safeUser } = user;

console.log(safeUser);

The output of the above code


// Password is extracted 
{ id: 1, name: "Kunal", email: "kunal@gmail.com", role: "admin" }

A rest operator is a type of parameter that gets all of the remaining parameters of a function call via an Array as you can see on the above code.

It is very helpful during array and object destructing.

You also notice something when we want to destruct something from user we put the rest operator on left side but its not same as spread.


// LEFT(extracted field and rest)        RIGHT (data in which value is                      
                                                      extracted)
const { password, ...safeUser }     =    user;

Spread Operator

Think of spread operator also like its name
It means opens everything inside this and put it here


const user = {
  id: 1,
  name: "Kunal",
  email: "kunal@gmail.com",
  role: "admin",
  password: "secret"
};

// SPREAD → merge / update object
const updatedUser = {
   ...user ,
   role : "user"
}

console.log(updatedUser)

Output of the above code


{ 
id: 1, 
name: "Kunal", 
email: "kunal@gmail.com", 
role: "user" , 
password : "secret" 
}

The spread operator is mostly used if you want to duplicate the content of an array or combine multiple object/array together

For instance if we have a object of user and we want to update or add the fields instead of manually looping we use the spread operator to do in a cleaner way like we did in the above code.

Spread is used on the right side to expand the data you already have. So You can add or update the existing Array/Object.


const updatedUser = {...user , role : "user" }

Differences between Spread and Rest Operator

Feature	Spread Operator	Rest Operator
Purpose	Expands values	Collects remaining values
Use position	Right side (usage)	Left side (destructuring/params)
Output	Individual values	Array or object
Use case	Copy, merge, pass values	Gather remaining values
Behavior	Opens data	Packs remaining data

When to Use the Rest and Spread Operator

Rest Operator :- Use rest when you want to collect the remaining values into an array or object.

Spread Operator :- Use spread when you want to copy, add, or update values from an existing array or object.

Thanks for reading ! if enjoyed this blog , you can read more on this 👇

Kunal Follow

My tokens expired idk how to write bio. 😪🫠

JavaScript Modules 101: import & export Without Confusion

Kunal — Mon, 23 Mar 2026 07:02:54 +0000

As JavaScript project grows managing code become more important than just writing it.
Modules provide a simple way to organize, reuse and maintain code efficiently.

In this blog we will cover :

Why modules are needed
Exporting functions or values
Importing modules
Default vs named exports
Benefits of modular code

Modules

Before modules JavaScript don't have a proper way to organize code. Everything lived in global scope which often caused conflicts and messy code.

Developers used tricks like global variables or IFFE to manage this.


// Global variable (problem: can be overwritten)

var count = 0;
function increment() {
  count++;
}


// IIFE (used to avoid global pollution)

(function(){
var count = 0 

function increment(){
 count++
console.log(count())

increment()
})()

But these were just workarounds, not a real solution.

Here comes the modules

A module is simply a separate piece of code with its own scope. It helps to keep the code organized , reusable and avoid conflicts that used to happen with global variable.

JavaScript supports various modules system. Here we only focus on the two most important types

Types of modules

ES6 Modules

ES6 modules (ECMA Script 6) it is a native module in this you can group and only share what's needed using import and export keywords.

Exporting a Module

To create a module you define the code you want to expose using the export keyword.
You can export individually or entire module object


 export const PI = 3.14 
 export function add(a , b){
        return a + b
 }

You can also export multiple things as a group:


const MULTIPLY = 'multiply';
const SUBTRACT = 'subtract';

export { MULTIPLY, SUBTRACT };

Importing a Module

To use the exported functionalities in another file, you use the import keyword. Here’s how you can import both named and default exports:

import { PI, add } from './math.js';

// Default export
import myFunction from './myFunction.js';

CommonJS Modules

Before ES6 modules, JavaScript (especially in Node.js) used CommonJS to manage code between files. Instead of import and export, it used require to bring code in and module.exports to send code out.

Exporting with CommonJS

const PI = 3.14;
function add(a, b) {
    return a + b;
}

module.exports = { PI, add };

Importing with CommonJS

const math = require('./math.js');
console.log(math.add(2, 3)); // Outputs: 5

Default Modules

Modern JavaScript lets you load files only when you actually need them using dynamic imports.

Instead of loading everything at once, you can load parts later making your app faster and lighter, especially in big projects.

// math.js (module)
export default function add(a, b) {
  return a + b;
}

// app.js (using it)
import add from './math.js';

console.log(add(2, 3)); // 5

Default vs named exports

Feature	Named Export	Default Export
Number of exports	Multiple allowed	Only one per file
Import syntax	`import { add } from './file'`	`import add from './file'`
Naming	Must match exact name	Can use any name
Curly braces	Required `{}`	Not required
Use case	Export multiple utilities/functions	Export one main functionality

Benefits of modular code

Better Organization

Modules keep your code clean and structured, so it’s easier to read and manage as your project grows.

Reusability

You can reuse modules anywhere in your app (or even in other projects), saving time and effort.

No Naming Conflicts

Each module has its own scope, so same variable names won’t clash with each other.

Easy Testing

Smaller modules are easier to test individually, which makes your code more reliable.

Thanks for reading ! if enjoyed this blog , you can read more on this 👇

Kunal Follow

My tokens expired idk how to write bio. 😪🫠

Map & Set: The Underrated Heroes of JavaScript

Kunal — Fri, 20 Mar 2026 06:38:34 +0000

While writing the blog on Array method, I have came across some topics that are new to me and Map and Set are one of them.

If you’d like to explore them too 👇

Kunal

Mar 3

If You Don’t Know These Array Methods, We Need to Talk.

#discuss #javascript #node #computerscience

Comments

3 min read

So in this blog we will cover :

Topics to Cover

Before Map & Set (The Old Way)
What Map is
Difference between Map and Object
What Set is
Difference between Set and Array
When to use Map and Set

Before Map & Set

Before learning Set and Map , I tried doing things in the old ways using array and objects.

For Map we do

const data = {};

data["name"] = "Kunal";
data["age"] = 21;

console.log(data["name"]); // Kunal

For Set we do


const arr = [1,2,2,3,3,5]
const unique = []

for (let i = 0; i < arr.length; i++) {
   if(!unique.includes(arr[i])){
    unique.push(arr[i])
   }
}
console.log(unique); // [1,2,3,5]

It worked but it required more code and wasn't clean or efficient.
That's when i come across Set and Map.

Map

The Map object stores data in a key/value pair structure just like an object. The main difference between a regular object and a Map are:

A Map can have any type of data as key Value
A Map maintains the order of the data

How to create a Map object

To create a Map object you can call the Map() constructor as follows :


const newMap = new Map()

Like objects, Map is not just data, it comes with powerful built-in methods and properties.

Map Object Methods and Properties

A Map object has the following methods and properties :

// Detect dark theme var iframe = document.getElementById('tweet-2034520230337380859-64'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2034520230337380859&theme=dark" }

Don’t just read try each method and property yourself.
Here, I’m only covering some important ones of the Map object.

To insert data into the Map object you can use set() method.

const myMap = new Map()

myMap.set(1 , "like this blog")
myMap.set(2 , "hello world")

console.log(myMap)

The output of the above code

Map(2) { 1 => 'like this blog', 2 => 'hello world' }

To retrieve a value from the Map object you can use the get() method

console.log(myMap.get(1))

You have to pass the key as its argument

To see if a certain key exist in a Map object we can use has() method


myMap.has(1) // true

Now Lets see the main difference between Map and the object

Difference between Map and Object

Feature	Object 🧱	Map 🗺️
Key Type	String / Symbol only	Any type (object, number, etc.)
Order	Not strictly guaranteed*	Maintains insertion order
Size	No direct property	`size` property
Iteration	Not directly iterable	Directly iterable
Use Case	Simple/static data	Dynamic & frequent updates

Set

The Set object allows you to store a collection of element just like an array. The difference between a Set and array are :

A Set require all elements to be unique
A Set has fewer methods for data manipulation

How to create a Set object

To create a new Set object you need yo call a Set() constructor as follows :

const mySet = new Set()

Like array, Set is not just data, it comes with powerful built-in methods and properties.

Set Object Methods and Properties

// Detect dark theme var iframe = document.getElementById('tweet-2034537438010544198-734'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2034537438010544198&theme=dark" }

Like Map here i only cover some important methods and property rest you can do it your own.

To add an element to the Set object, you can use the add() method:


const mySet = new Set()

mySet.add(1)
mySet.add(2)
mySet.add(3)

console.log(mySet) // Set(3) { 1, 2, 3 }

To check if the Set has a specific value, use the has() method:

mySet.has('Jack'); // true

mySet.has('Michael'); // false

To check the number of Items in Set we use size() method:

console.log(mySet.size) // 3

Let see the Difference between Array and Set

Difference between Set and Array

Feature	Array 📚	Set 🔢
Duplicates	Allowed	Not allowed (unique only)
Order	Maintains order	Maintains insertion order
Access	By index (`arr[0]`)	No index access
Use Case	List of items	Unique collection
Methods Focus	`push()`, `pop()`	`add()`, `has()`

When to use `Map`

You need key → value relationship
Keys are not just strings (can be objects, numbers)
You want fast lookup by key

Example: userId → userData

When to use `Set`

You only care about unique values
You want to remove duplicates
You just need to check existence

Example: unique tags, unique IDs

Thanks for reading ! if enjoyed this blog , you can read more on this 👇

Kunal Follow

My tokens expired idk how to write bio. 😪🫠

Node.js Internals: Read This Before Your Next Backend Interview

Kunal — Sun, 15 Mar 2026 12:20:29 +0000

I was reading the Node.js official documentation to understand how Node.js actually works internally.
But honestly some parts felt a bit hard to me

So i thought why not to rewrite what i learn in simple words that will help you as well. So in this blog we will cover the following topics.

Topics to Cover

What is Node.js
V8 Engine and libuv
Node.js Architecture Overview
How Node.js Executes a Program (node index.js)
Thread Pool in Node.js
Event Loop and Its Phases
Understanding Event Loop with Examples
Worker Thread
Conclusion

Don't worry this blog will cover each and every topic from the Node.js official documentation.

What is Node.js

Originally JavaScript is meant to be run on the browser like Google chrome but in 2009 a developer name Ryan Dahl had a different idea.

He extract the Google V8 engine from the browser an combined it with a powerful library called libuv. Using C++ and JavaScript he build a runtime that could execute JavaScript outside the browser.

Later Node.js was created which provide a runtime environment that lets you run JavaScript outside the browser means you can run it on sever (backend).

Without Node.js:

JavaScript → Browser

With Node.js:

JavaScript → Server

Node.js is made up of 2 major component which provide this runtime environment

V8 Engine + libuv + C++ = Node.js

V8 Engine :- V8 engine is a Google Chrome engine that convert JavaScript code into machine language so the computer can execute it quickly
Libuv :- It is a library that helps Node.js handle asynchronous tasks.

It manages things like:

file reading
network requests
timers
event loop
thread pool

Done worry we'll explain this in further later in this topic.

Node.js architecture diagram

Before we understand how Node.js runs our code, let's first look at the high-level architecture diagram.

Node.js Execution

Let’s suppose we have a JavaScript file named index.js.

If we want to run this file using Node.js we simply open the terminal and run the following command:

When we run the command node index.js, Node.js creates a process.

This process runs on a single thread also called the main thread, which is responsible for executing our JavaScript code. Without this JavaScript did not run.

The main thread first initializes the Node.js environment for the program. After that it starts executing the top-level code inside the index.js file

Top level code :-  It simply means the code that runs immediately when 
                   the file is executed, not inside any function or callback.

example :- console.log("hello world") 
           const fs = require("fs");

While executing that top-level code, Node.js also performs a few important tasks such as :

It loads any modules using require()
Registers event callbacks (such as timers or I/O callbacks)
Prepares internal resources needed to run the application

Node.js also creates a thread pool (managed by libuv). This thread pool is used to handle CPU-intensive or blocking tasks, such as:

cryptography
hashing
file system operations
DNS lookups

Even though JavaScript is single-threaded, Node.js uses a thread pool to handle heavy tasks in the background. By default, this thread pool has 4 threads, but you can increase or decrease the number of threads depending on how heavy your workload is.

Finally, the main thread starts the event loop, which continuously checks for tasks and handles asynchronous operations by offloading heavy work to the thread pool when necessary.

Now lets see the internals of Event loop and its phases

Event Loop Starts

After the top-level code finishes executing, the main thread starts the Event Loop.

The event loop is responsible for continuously checking if there are any tasks waiting to be executed. It allows Node.js to handle asynchronous operations without blocking the main thread.

If a task requires heavy work (like file reading, cryptography, or DNS), the event loop offloads that task to the thread pool managed by libuv.

Once the task is finished, its callback is placed back in the queue so it can be executed by the main thread.

Event Loop Phases

Once the event loop starts, it keeps running in a cycle and checks different phases to see if there are any tasks to execute.

These phases are as follows :

Expired Timer Callbacks
Runs the callbacks of setTimeout() and setInterval() when their time is finished.
I/O Polling
Checks if any I/O task (like file reading or network request) has finished and runs its callback.
setImmediate Callbacks
Runs callbacks scheduled using setImmediate().
Close Callbacks
Runs callbacks when something is closed, like a socket or connection.

If there are still pending tasks, the event loop continues running.
If there are no timers, no callbacks, and no pending I/O, Node.js exits the event loop and the program finishes execution.

Now that we understand the phases of the event loop, let's look at a simple example to see how these phases work in practice.

Examples

Before looking at the example, first understand the basic flow.

Top-level code executes first
Event Loop starts
- Timers phase → runs expired setTimeout / setInterval callbacks
- I/O polling phase → checks completed I/O operations
- setImmediate phase → runs setImmediate() callbacks
- Close callbacks phase → runs close-related callbacks
If tasks are still pending → loop runs again
If no tasks remain → Node.js exits

Example 1


console.log("Start");
setTimeout(() => { console.log("Timer callback"); }, 0);
setImmediate(() => { console.log("Immediate callback"); }); 
console.log("End");

Output of above code

Start
End
Timer callback
Immediate callback

Whay this happens

console.log("Start") runs first because it is top-level code.
setTimeout() registers a timer callback.
setImmediate() registers an immediate callback.
console.log("End") runs because it is also top-level code.
Now the Event Loop starts.
The event loop first checks timers → runs "Timer callback".
Then it goes to setImmediate phase → runs "Immediate callback".


## Note

You may sometimes see setImmediate() run before setTimeout().

This happens because both callbacks are scheduled for different phases
of the event loop. Depending on how quickly the event loop starts 
the immediate callback can run first..

So the output can be:

Start
End
Immediate callback
Timer callback

Example 2

const fs = require('node:fs');

console.log("Start");
setTimeout(() => {
  console.log("Timer callback");
}, 0);
setImmediate(() => {
  console.log("Immediate callback");
});


fs.readFile("sample.txt", () => {
  setTimeout(() => {
    console.log('timeout');
  }, 0);
  setImmediate(() => {
    console.log('immediate');
  });
});

console.log("End");

Output of above code

Start
End
Timer callback
Immediate callback
immediate
timeout

Why this happens

console.log("Start") runs first because it is top-level code.
setTimeout() registers a timer callback.
setImmediate() registers an immediate callback.
fs.readFile() starts an I/O operation in the background.
console.log("End") runs because it is also top-level code.

So far we have seen how the event loop handles different callbacks, but what happens if there is a CPU-intensive task?

What if there is a CPU-intensive task?

In Node.js, heavy tasks do not run inside the event loop because that would block the main thread.

Instead, these tasks are sent to the thread pool (managed by libuv). The thread pool uses worker threads to perform the heavy work in the background.

Lets take some CPU intensive works and see the behaviour of threads and how we can increase the size of threadpool.

Example 1


const crypto = require("node:crypto");
const fs = require("node:fs");

const start = Date.now();

process.env.UV_THREADPOOL_SIZE = 4

fs.readFile("sample.txt", "utf-8", () => {
  console.log("I/O Polling Finished");

  crypto.pbkdf2("password1", "salt1", 100000, 1024, "sha512", () => {
    console.log(`${Date.now() - start}ms`, "Password 1 Done");
  });

  crypto.pbkdf2("password2", "salt1", 100000, 1024, "sha512", () => {
    console.log(`${Date.now() - start}ms`, "Password 2 Done");
  });

  crypto.pbkdf2("password3", "salt1", 100000, 1024, "sha512", () => {
    console.log(`${Date.now() - start}ms`, "Password 3 Done");
  });

  crypto.pbkdf2("password4", "salt1", 100000, 1024, "sha512", () => {
    console.log(`${Date.now() - start}ms`, "Password 4 Done");
  });

});

Output of the above code

I/O Polling Finished
1115ms Password 3 Done
1132ms Password 1 Done
1142ms Password 2 Done
1157ms Password 4 Done

From the above code, we saw that the hashing tasks finished almost at the same time. This happens because the thread pool has 4 threads, so it can run 4 tasks at the same time.

I/O Polling Finished
1030ms Password 3 Done
1038ms Password 1 Done
1071ms Password 4 Done
1082ms Password 2 Done
2005ms Password 5 Done
2009ms Password 6 Done

But when we increase the number of tasks while the number of threads is still 4, some tasks have to wait.
The 5th and 6th tasks cannot start right away because all threads are busy.
So they wait until a thread becomes free, and that’s why they finish later.

Note: By default Node.js uses 4 threads in the thread pool, but you can increase or decrease it using UV_THREADPOOL_SIZE, depending on your CPU cores and workload.

Conclusion

In this blog, we understood how Node.js works internally. We started with what Node.js is, then looked at the V8 engine and libuv, and saw how Node.js executes a program when we run node index.js.

We also learned how the event loop works, its phases, and how Node.js handles asynchronous operations without blocking the main thread.

Finally, we saw how CPU-intensive tasks are handled using the thread pool, allowing Node.js to stay fast and responsive.

Understanding these concepts gives you a clear mental model of how Node.js works behind the scenes.

Thanks for reading ! if enjoyed this blog , you can read more on this 👇

Kunal Follow

My tokens expired idk how to write bio. 😪🫠

Understanding JavaScript Variables Before Blaming React

Kunal — Fri, 13 Mar 2026 18:15:27 +0000

JavaScript looks easy at first until you realize everything depend on variable and Data types. If you skip these fundamentals your code quickly turns into the guessing game and you end up console.log everything.

Topics to Cover

What variables are and why they are needed
How to declare variables using var, let, and const
Primitive data types (string, number, boolean, null, undefined)
Basic difference between var, let, and const
What is scope (very beginner-friendly explanation)

Variables

When a child is born they are given a name and throughout their life they will be referred by that name unless the name gets changed.

In JavaScript values are assigned by a name and anytime we need that value we simply mention the name to which it was assigned.

Before declaring or assigning a variable the first step is learning how to name it correctly.

👉 How to Name Variables

Just like human we always put much thoughts to ensure the name has a meaning to it. We do it same for JavaScript.

for example pneumonoultramicroscopicsilicovolcanoconiosis is a valid name but it too long.

Let your variable be simple and context full. For example clickButton , addNumbers , sumOfNumbers

It should be self explanatory.

Now lets see how to handle a variable

👉 How to declare and assign a variable

To declare the variable you can use one of these keywords: let , const or var

let count = 1

We can assign a value to a variable by using the assignment (=) operator. This mean that we provided an value for the variable when it was created.

Some names are already used by JavaScript to mean something these names cannot be used by developers.they are called reserved words check this 👇

// Detect dark theme var iframe = document.getElementById('tweet-2032528428164063380-210'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2032528428164063380&theme=dark" }

👉 How to Call a Variable

Once a variable has been created and assigned a value we often need to access or display that value in our program.

In JavaScript one common way to do this by using console.log() which prints it.

console.log(count + 2)

In next section we will learn about different data types and how to work on them

Data Types

In JavaScript , Datatypes defines what kind of value you can hold inside a variable.
Think of data types like different types of containers in real life :

A water bottle holds water
A wallet holds money
A folder holds document

The data types in JavaScript are categorized into two primary groups namely :

Primitive : Number, String, Boolean, Undefined, Null, BigInt, Symbol
Reference : Object, Array, Function

Let's consider primitive data types.

Primitive Data Types

1. String :- Text inside quotes

eg:- let name = "Like this blog"

2. Boolean :- Only two values

eg:- True , False

3. BigInt :- For very very large numbers.

eg:- let bigNumber = 12345678901234567890n;

4. Number :- Any normal number.

eg:- let marks = 95;
     let price = 99.99;

5. Undefined :- When a variable and no value is given

eg:- let x;

6. Symbol :- Creates a unique value.

eg:- let id = Symbol("id");

7. Null :- Means intentionally empty.

eg:- let data = null;

8. Object :- Stores multiple values together

eg:-  let user = {
  name: "Kunal",
  age: 21
};

Note :- In JavaScript datatype of Array is object.

Difference between var, let, and const

Feature	`var`	`let`	`const`
Scope	`var` works inside a function.	`let` works inside a block `{ }`.	`const` works inside a block `{ }`.
Redeclaration	You can declare the same variable again.	You cannot declare the same variable again.	You cannot declare the same variable again.
Change value	The value can be changed later.	The value can be changed later.	The value cannot be changed later.
Initialization	You can declare it without giving a value.	You can declare it without giving a value.	You must give a value when declaring it.
Modern usage	Mostly avoided in modern JavaScript.	Commonly used when values change.	Commonly used for constant values.

Now that we’ve seen the differences between var, let, and const, let’s understand scope.
Scope simply means where a variable is accessible in your code.

Scope

Scope defines the area of the code where a variable can be used or accessed.

var has function scope, which means it can only be accessed inside the function where it is declared.

function example() {
  var message = "Hello";

  console.log(message); // Works here
}

example();

console.log(message); // Error: message is not defined

let has block scope, so it can only be accessed inside the block { } where it is declared.

{
  let age = 25;
  console.log(age); // Works here
}

console.log(age); // Error: age is not defined

const also has block scope, meaning it can only be used inside the block { } where it is defined.

{
  const PI = 3.14;
  console.log(PI); // Works here
}

console.log(PI); // Error: PI is not defined

Thanks for reading ! if enjoyed this blog , you can read more on this 👇

Kunal Follow

My tokens expired idk how to write bio. 😪🫠

Function Declaration vs Expression: The Rich Kid vs The Intern

Kunal — Thu, 12 Mar 2026 12:03:48 +0000

While writing blog on Arrow Functions , I keep seeing two terms everywhere Function Declaration and Function Expression. That made me pause and ask What are these and why they do matter ? In this blog we will cover all of this.

Blog on Arrow Function 👇

Kunal

Mar 5

Why JavaScript Developers Are Obsessed With Arrow Functions

#discuss #javascript #beginners #computerscience

Comments

3 min read

Topics to Cover

What functions are and why we need them
Function declaration syntax
Function expression syntax
Key differences between declaration and expression
When to use each type

Functions

Functions are fundamental building block in JavaScript , These are the reusable block of code designed to perform specific tasks.

A function consist of :

Parameter : Parameters are the variables defined in the function definition.

function add(a , b) -> a , b are the parameters

Arguments : Arguments are the actual value that are passed when calling the function

add(5,10) -> 5 , 10 are the arguments

Why we need Functions ?

They promote code reusability
Make your programs cleaner and easier to manage
They are easy to maintain
They are modular

But there are several methods in which we can define our functions

Function Declaration : The Rich Kid

Function declaration is like a rich kid they have the power before doing anything.
In JavaScript this privilege is called Hoisting means you can call a function declaration before its actual definition in the code.

Another important things is that function declarations are always named.

add(5 , 10) //calling the function before it define

function add(a , b){
  return a + b
 }

They are the normal function with a power of Hoisting.Thats it!

Function Expression : The Intern

Function Expression is like a intern that cannot start working until HR assigns them a job.
Similarly , a function expression cannot run until the variable get the function assigned.

const greet = function add( a , b ) {
  return a + b
}

greet(5 , 10)

Function expression are anonymous because they don’t have their own name instead, they are assigned to a variable

Many developers used function declarations for a long time but function expression gradually taking over. Lets now see the key diffrence between them what to use when

Key differences between declaration and expression

Feature	Function Declaration	Function Expression
Definition	Defined using the `function` keyword directly	Function is assigned to a variable
Hoisting	Fully hoisted (can be called before defined)	Not fully hoisted (cannot call before assign)
Name	Always has a function name	Often anonymous (no function name)
Usage	Traditional way of writing functions	Used when assigning functions to variables
Example idea	function add(a,b) { ... }	const add = function(a,b) { ... }

When to use each type

Function Declaration : Use this when you want a reusable function that can be called anywhere in the code even before it is define

Function Expression : Use this when you want to assign a function to a variable or pass it as a callback ( like in array , events etc.)

Thanks for reading ! if enjoyed this blog , you can read more on this 👇

Kunal Follow

My tokens expired idk how to write bio. 😪🫠

Stop Writing Bad JavaScript! Master if, else, and switch in 5 Minutes

Kunal — Sun, 08 Mar 2026 10:56:34 +0000

In our daily lives we make several decisions from deciding what to wear to deciding what to eat. In coding we have the same we call it Conditional Statements which is if , else and switch . In this Blog we will discuss about these Conditional statements.

Topics to Cover

What control flow means in programming
The if statement
The if-else statement
The else if ladder
The switch statement
When to use switch vs if-else

Control flow

In programming , the computer does not randomly runs the code. It follows a flow deciding what to do next based on the condition.

Think of a traffic signal

If the light is green - Go
If the light is yellow - Slow down
If the light is red - Stop!

Based on the condition you take the decision.

So , Control flow simply mean the order in which a program runs instruction and make decision.

The if statement

The if statement is used to run some code only when the condition is true

If statement consist of :

In programming we write like this :

const age = 20

if( age >= 18){
console.log("You can vote")
}

It is run only when the condition is true

We can also use multiple if statement

const age = 18

if(age === 0) { console.log("You are just born!")}
if(age >= 0 && age < 18) { console.log("You are not eligible to vote")}
if(age >= 18) { console.log("You can vote")}

Note:- The JavaScript engine checks every if statement one by one.
If a condition is true, its code runs.
Because of this, multiple if statements can run multiple if conditions which are true.

The if-else statement

Sometimes we want the program to do only one thing if the condition is true it runs the code otherwise it runs another thing if it is false.

This is where the if , else statement is used.

Think of ordering the food:

If the restaurant is open -> You can order the food
else -> You cook the food at home

In programming we write like this :

let isRestaurantOpen = true

if(isRestaurantOpen === true){
  console.log("You can order the food")
}else{
  console.log("You cook the food at home")
}

Only one action will happen depending on the condition.

The else if ladder

Sometimes we need to check the multiple condition not just two
In this case we use else if ladder

In programming we write like this :

const marks = 82 

if (marks >= 90) {
  console.log("Grade A");
} else if (marks >= 75) {
  console.log("Grade B");
} else if (marks >= 50) {
  console.log("Grade C");
} else {
  console.log("Fail");
}

Once a condition becomes true the rest condition are not checked

The switch statement

Sometimes we need to check only one variable against many possible values.
In this , we use the switch statement

It makes the code cleaner and easier to read then writing many else if condition

Lets think of you have your own restaurant in this :

If a user choose 1 -> Pizza
If a user choose 2 -> Burger
If a user choose 3 -> Pasta

You can also do this with else if ladder but we have better and easier alternate

In programming we can do this like :

const number = 1;

switch (number) {
  case 1:
    console.log("You ordered Pizza");
    break;

  case 2:
    console.log("You ordered Burger");
    break;

  case 3:
    console.log("You ordered Pasta");
    break;

  default:
    console.log("Please enter a valid number");
}

Note : You have to add break to stop the condition after it matches with the result .
If you don't add the break statement the program will continue running to the next cases

Try running these examples on your computer to better understand how if-else and switch work.

When to use switch vs if-else

Point	Use if-else	Use switch
1	Used when checking ranges like age > 18 or marks > 50	Used when checking one variable against many fixed values
2	Used when conditions need multiple checks together	Used when comparing one value with different cases
3	Better when there are few conditions	Better when there are many options
4	Code can become long and harder to read with many conditions	Code stays cleaner and more organized
5	Example: age check, marks grading, temperature check	Example: day of week, menu selection, user role

Thanks for reading ! if enjoyed this blog , you can read more on this 👇

Kunal Follow

My tokens expired idk how to write bio. 😪🫠

Forem: Kunal

You dont know about javascript : Synchronous vs Asynchronous

Node.js Internals: Read This Before Your Next Backend Interview

JavaScript is Synchronous

Asynchronous JavaScript

Why JavaScript needs asynchronous behavior

Callbacks in JavaScript

Kunal Follow

Polyfills 101: Impress your interviewer

String methods

Why developers write polyfills

Common interview string problems

Importance of understanding built-in behavior

Kunal Follow

Callbacks in JavaScript

Callback function

Why callbacks are used in programming

Callback usage in common scenarios

Basic problem of callback

JavaScript Promises Explained: A Startup Analogy for Beginners

Kunal Follow

Template Literals > Your Old Code

Traditional string concatenation

Template literal

Multi-line strings

Use cases in modern JavaScript

Kunal Follow

Master Array Flattening in JS

If You Don’t Know These Array Methods, We Need to Talk.

Nested arrays

Why flattening arrays is useful

Different approaches to flatten arrays

Kunal Follow

Spread vs Rest Operators in JavaScript

Rest Operator

Spread Operator

Differences between Spread and Rest Operator

When to Use the Rest and Spread Operator

Kunal Follow

JavaScript Modules 101: import & export Without Confusion

Modules

Types of modules

Default Modules

Default vs named exports

Benefits of modular code

Kunal Follow

Map & Set: The Underrated Heroes of JavaScript

If You Don’t Know These Array Methods, We Need to Talk.

Before Map & Set

Map

Difference between Map and Object

Set

Difference between Set and Array

When to use Map

When to use Set

Kunal Follow

Node.js Internals: Read This Before Your Next Backend Interview

What is Node.js

Node.js architecture diagram

Node.js Execution

Event Loop Starts

Examples

What if there is a CPU-intensive task?

Conclusion

Kunal Follow

Understanding JavaScript Variables Before Blaming React

Variables

Data Types

Difference between var, let, and const

Scope

Kunal Follow

Function Declaration vs Expression: The Rich Kid vs The Intern

Why JavaScript Developers Are Obsessed With Arrow Functions

Functions

Function Declaration : The Rich Kid

Function Expression : The Intern

Key differences between declaration and expression

When to use each type

Kunal Follow

Stop Writing Bad JavaScript! Master if, else, and switch in 5 Minutes

When to use `Map`

When to use `Set`