Feel Fear After Doing Something Difficult

khushal jangid — Tue, 23 Jun 2026 16:19:49 +0000

Why Do We Feel Fear After Doing Something Difficult?

Feeling afraid after completing a difficult task is a common response of the human brain. There are several reasons behind it.

1. The Brain Is Afraid of Uncertainty 🧠

When we do something new or challenging, like:

Building a React project for the first time
Solving a difficult DSA problem
Giving an interview

the brain starts thinking:

"What will happen next? Will I succeed?"

The human brain tries to predict the future. When something is unknown, it creates a feeling of fear because the outcome is uncertain.

2. Stress Release After Completing a Challenge

During a difficult task, our body enters a focused mode.

For example:

You study DSA for 3 hours and finally solve a problem.

During that time:

Your mind is fully focused
Your body handles pressure
Your brain stays alert

After finishing, the stress reduces and the brain starts processing:

"Will I remember this?"
"Will I be able to solve similar problems?"
"What if I fail later?"

This can create fear or anxiety.

3. Fear Is Often a Sign of Growth

Whenever we move outside our comfort zone, we enter a learning phase.

Comfort Zone
      |
      ↓
Learning Zone
      |
      ↓
Fear Zone
      |
      ↓
Growth

Doing something challenging means you are entering a new area where your brain has less experience.

That unfamiliarity creates fear.

4. The Brain Creates Future Scenarios

The brain does not only focus on the present. It also imagines future situations.

Example:

You learn Express.js today.

Your brain may think:

"What if an interviewer asks this?"
"What if I forget the concept?"
"Am I learning correctly?"

The brain creates possible future situations to prepare you.

The Important Point

Fear does not always mean you are not capable.

Many times, fear means the task is important and your brain is taking it seriously.

With practice, your brain collects evidence:

"I can handle this."

Then the fear gradually decreases.

Examples:

First LeetCode problem → Fear
After solving many problems → Patterns become familiar
First React project → Confusion
After building multiple projects → Architecture becomes clearer

Growth often happens when we continue even while feeling uncertain.

Mutating state | Immutating state

khushal jangid — Tue, 23 Jun 2026 05:19:51 +0000

Your confusion is coming from mixing JavaScript objects + mutation + React-style immutability concepts. Let’s clear it step by step.

🧠 1. First fix your code (syntax)

You wrote:

let state ={
count:0;
}

Correct:

let state = {
count: 0
};
🔥 2. What is happening in your code (MUTATION)
Code:
let state = {
count: 0
};

state.count = 1;

console.log(state);
👉 Meaning:

You directly changed the object.

This is called mutation.

Memory idea:

state → { count: 0 }

After mutation:

state → { count: 1 }

So object is SAME, only value inside changed.

🧠 3. Your function (mutation again)
function increment() {
state.count = state.count + 1;
}
What happens:
Before:
state = { count: 1 }
After calling increment():
state = { count: 2 }

Again:
👉 SAME object, just modified inside

This is called:

🔴 Mutation (changing original state)

❓ Why console shows undefined sometimes?

If you do:

console.log(increment());

Function returns nothing → so output is:

undefined

Because you did not return anything.

🚀 4. IMMUTABLE version (VERY IMPORTANT CONCEPT)

You wrote:

{ count: state.count + 1 }

This is NOT mutation.

This creates a NEW object.

🧠 Mutation vs Immutability
🔴 Mutation (old object modified)
state.count = state.count + 1;
same object
memory same
risky in React/Redux
🟢 Immutability (new object created)
state = { count: state.count + 1 };

Now:

Before:

state → { count: 1 }

After:

state → { count: 2 } (NEW object)

👉 Old object is NOT changed

🎯 5. Why immutability is important (React mindset)

React depends on:

“Did object reference change?”

So:

Mutation ❌
state.count++;

React may NOT detect change properly

Immutability ✅
setState({ count: state.count + 1 });

React sees:

new object
re-render happens
🧠 Simple analogy
Mutation:

You repaint same house 🏠

Immutability:

You build new house 🏡

🔥 6. Final clean understanding
Concept Meaning
Mutation change same object
Immutability create new object
state.count++ mutation
{count: state.count+1} new object
⚡ One-line memory trick

Mutation = “same object, change inside”
Immutability = “new object, old unchanged”

If you want, I can explain this with
React useState example + interview trick + real DOM re-render story (very important for interviews).

explain this for writing blog

Here’s a clean blog-style explanation you can directly use or adapt.

🧠 Mutation vs Immutability in JavaScript (Simple Explanation)

When working with JavaScript objects, especially in frameworks like React, you will often hear two important terms:

Mutation and Immutability

These concepts decide how data changes in your application and how efficiently your UI updates.

Let’s understand them in a very simple way.

📦 1. What is an Object in JavaScript?

In JavaScript, objects are stored in memory like this:

let state = {
count: 0
};

Here, state is not the actual data. It is a reference pointing to the object in memory.

🔴 2. Mutation (Changing the Same Object)

Mutation means modifying the original object directly.

Example:
let state = {
count: 0
};

state.count = 1;

console.log(state);
What is happening?
We are changing the value inside the same object
No new object is created
Memory reference stays the same
Visualization:

Before:

state → { count: 0 }

After mutation:

state → { count: 1 }

👉 Same object, just updated inside

⚠️ Problem with mutation

Mutation can create issues in frameworks like React because:

The reference does NOT change
React may not detect updates properly
UI updates can become unpredictable
🟢 3. Immutability (Creating a New Object)

Immutability means not changing the original object, but creating a new one with updated values.

Example:
let state = {
count: 0
};

state = {
count: state.count + 1
};

console.log(state);
What is happening?
A new object is created
Old object remains unchanged
Reference changes
Visualization:

Before:

state → { count: 0 }

After immutability:

old state → { count: 0 }
new state → { count: 1 }

👉 Completely new object is created

⚖️ 4. Mutation vs Immutability (Key Difference)
Feature Mutation Immutability
Object change Same object New object
Memory Same reference New reference
Safety Risky in large apps Safe and predictable
React behavior May not re-render Always triggers update
🚀 5. Why React Prefers Immutability

React depends on detecting changes using reference comparison:

If object reference changes → React re-renders UI

So this works well:

setState({ count: state.count + 1 });

But this can fail:

state.count++;

Because React may not detect the change properly.

🧠 6. Simple Real-Life Analogy
Mutation:

You edit the same notebook page ✏️
Everything changes in place.

Immutability:

You write a new page 📄
Old page stays unchanged.

🎯 7. Final Summary
Mutation = change the same object
Immutability = create a new object
React prefers immutability for predictable updates
Good developers avoid mutation in state handling
🔥 One-line takeaway

“Mutation changes data in place, immutability creates a new version of data without touching the original.”

DEV Community: khushal jangid

Feel Fear After Doing Something Difficult

Why Do We Feel Fear After Doing Something Difficult?

1. The Brain Is Afraid of Uncertainty 🧠

2. Stress Release After Completing a Challenge

3. Fear Is Often a Sign of Growth

4. The Brain Creates Future Scenarios

The Important Point

Mutating state | Immutating state