It's that deeply unsettling feeling when you look in the mirror and ask, "Who am I, really?"

This crisis isn't a failure; it's a critical signal. It’s the moment when the person you believe you are, the values you hold, and the actions you take stop aligning. Let's break down this internal earthquake.

The Blueprint: Your "Self-Image" and the Ego

To understand an identity crisis, we first need to understand identity itself. One of the best frameworks for this comes from Dr. Maxwell Maltz, a plastic surgeon who, in the 1950s, wrote a groundbreaking book called "Psycho-Cybernetics."

Maltz noticed something fascinating: when he performed plastic surgery on a patient (like fixing a scar), the patient's life didn't always change. Their "new face" didn't make them more confident or successful. Why?

Because they hadn't updated their internal self-image.

• The "Cybernetic" Mechanism: Maltz described the human mind as a "servo-mechanism," like the guidance system in a torpedo or the AC in your house.

• The AC: A AC doesn't know if it's hot or cold. It only knows the goal it was set to (e.g., 27 degrees). It then sends signals, to make the external reality match its internal goal.

• The Self-Image as Ego: Your "ego" or "self-image" is your AC’s setting. It's the blueprint of the "sort of person" you believe yourself to be.

If your self-image is set to "I am an anxious person who fails at public speaking," your mind will automatically steer you toward that reality. It will make you feel sick, forget your words, and focus on the one person yawning in the crowd. You "achieve" your blueprint.

An identity crisis begins when this blueprint is violently challenged. Your internal "setting" no longer matches the reality you're experiencing, and the whole system short-circuits.

When the Foundation Cracks: How Changing Morals Shake Our Identity

A massive part of our self-image blueprint is built on our morals and values. These are the load-bearing walls of our identity.

• "I am an honest person."

• "I am a loyal friend."

• "I am someone who believes in justice/family/faith/logic."

We use these moral statements to define "good" (what's like me) and "bad" (what's not like me). But what happens when these morals, which we thought were solid as concrete, begin to change?

This can be triggered by:

• New Experiences: Moving to a new country and realizing your "absolute" moral code isn't shared by billions of other good, happy people.

• Education: Learning about history or science that challenges a deeply held belief you were raised with.

• Trauma or Loss: An event that makes you question your entire belief system about fairness and the world.

When your morals shift, the "old self" (who you were) comes into direct conflict with the "new self" (who you are becoming).

If your identity was "I am a person who always follows the rules," but you find yourself believing a specific rule is unjust, you are now in a crisis. Am I a hypocrite? Am I a bad person? Or was the rule wrong all along? This internal schism is terrifying because the very compass you used to navigate the world is spinning wildly.

The Action-Identity Loop: "I Did It, But Was It 'Me'?"

This brings us to the third, and perhaps most common, trigger for an identity crisis: the conflict between our actions and our beliefs.

This is the central theme of cognitive dissonance. We have a powerful, innate need for our actions and our self-image to be consistent. When they are not, we feel a psychic pain.

This conflict goes both ways:

1. Doing Something "Worse" Than We Are: You believe, "I am a kind and patient person." But one day, under extreme stress, you yell at your child or betray a friend. The action is done. It's real. It now exists in the world, in total opposition to your self-image. The crisis is the question: "Was my 'kind person' identity a lie all along? Or was that action just a fluke?" To resolve the crisis, you must change something: either your self-image ("Maybe I'm not as kind as I thought") or your future actions ("I will never do that again").

2. Doing Something "Better" Than We Are: This is the flip side. Your self-image is, "I am shy and not a leader." But at work, your team is failing, and you instinctively step up, organize everyone, and save the project. Your action (effective leadership) completely contradicts your blueprint ("I am not a leader"). This, too is a crisis, a positive one! Your brain is forced to ask, "Wait... if I just did that, can my old belief about myself possibly be true?"

An identity crisis is the moment of friction when your actions prove your old blueprint is wrong.

Re-Drawing the Blueprint

An identity crisis feels like you're being erased. But you're not. You are being rewritten.

Maxwell Maltz’s "Psycho-Cybernetics" isn't just a diagnosis; it's a manual. He argued that since the self-image is just a blueprint, it can be re-drawn. An identity crisis isn't a breakdown; it's a breakthrough. It's the painful, necessary process of shedding an old, outdated "self-image" that no longer fits your reality.

It's the moment you stop letting an old program run your life and consciously decide to change the setting on the thermostat.

Disclaimer: This blog post is for informational purposes. If you are experiencing severe distress from an identity crisis, please consider speaking with a mental health professional.

Recently I saw lots of tweets and post about closures in JavaScript and I thought about posting about my understanding of the Closures.

According to MDN closure is "A closure is the combination of a function bundled together (enclosed) with references to its surrounding state (the lexical environment). In other words, a closure gives you access to an outer function’s scope from an inner function. In JavaScript, closures are created every time a function is created, at function creation time."

So now you understand what closure is let's move on to next part, just kidding ;) to make it clear lets see an example, but before that I assume you are familiar with concepts such functions are first class citizen, call stack and scopes/execution context (if not please leave comment, I'll post blogs about functions, call stack and scopes/execution context).

function outer(){
    let closureVariable = 5;
    let nonClosureVariable = 7;
    return function inner(){
        return 5 + closureVariable;
    }
}

let inner = outer();
debugger;
inner();

In the example above you see that I have declared a function outer with two variables closureVariable and nonClousreVariable and returned a function inner which is accessing the closureVariable. You can also see that I have a debugger just before executing inner function.

When I run the code in chrome console, as you can see in the image, though the call stack is in inner function's execution context and outer function is kicked off from the call stack you can still access the closureVariablebut nonClosureVariable is not available, JavaScript knows what variable is needed for the execution of inner function and keep those variables in memory till the exection of inner function this is clousure. In simple words

The ability of JS function to keep the variables from outer scope in memory till it's execution.

I hope you can understand what closure is now let's move on to why we need closures.

Why we need closures? Or Where can we use closure?

There are many uses for closures, let us see 2 uses with examples.

• Encapsulation
• Function Composition

Encapsulation with closure:

Let's see an example of encapsulation with closure, let us build a function which keeps track of seconds passed.

// Encapsulation 
const calculateTime = () =>{
    let seconds= 0;
    const toAdd = 0.5
    let addSeconds= () => seconds+= toAdd // Arrow function implicit return
    setInterval(addSeconds,500); // Adding 0.5 second every 500 milliseconds 
    return ()=> seconds; // Arrow function implicit return
}

let timeStart = calculateTime();
// Assume function is a long running function that takes 5 seconds to execute.
setTimeout(()=>console.log(timeStart()),5000);

In the example above assume we're building a function to calculate time taken for execution of a function in different browser or computers.

Here you can see the calculateTime function returns the seconds inside a anonymous function and we've successfully encapsulated all the implementation details and we're just returning the seconds variable but the function has access to other variables such as toAdd and setInterval but from outside the function we can only access the seconds variable.

Note: I'm using arrow function just to show arrow function supports closure, we can use normal function also

Compose with closure:

Lets see an example of composing function with closure

function addWith(num1){
    return num2=> num1 + num2 // Arrow function with implicit return
}

const addWithFive = addWith(5);// Closure function remembering 5
const addWithTen = addWith(10);// Closure function remembering 10
const addWithEight= addWith(8);// Closure function remembering 8
console.log(addWithFive(7));
console.log(addWithTen (7));
console.log(addWithTen (7));

In the example above we're composing 3 new functions addWithFive,addWithTen and addWithEight with help of addWith function. This is possible because of the closure as the functions can keep track of the num1 we're able to use the composition.

Conclusion

The examples I gave above are silly but I hope you can see the power of closures now. In short

• Closure let's the inner function keep track of variable outside of it's scope.
• Especially useful for encapsulation and composing function from other functions.
• Keeps track of value even after the outer function is out of the call stack.

If you enjoyed the article please share it with others, feel free to hit me up on twitter

This is my first blog post so please leave your valuable comments. If you find any topic in this post difficult to understand let me know I'll write about it.