I'm learning JavaScript in my web development course, and today we went UNDER the hood — where does JavaScript actually KEEP your variables?

Two neighborhoods in your RAM

Your computer's memory (RAM — sir even wrote "4 GB Ram" on the board) has two neighborhoods, and JavaScript uses both:

The Stack is like your work desk. Small, organized, fast. This is where JavaScript keeps the simple stuff — primitives. Numbers, strings, booleans. The actual VALUE sits right there on the desk.

The Heap is like a warehouse. Big, spacious, a bit messy. This is where the complicated stuff lives — objects, arrays, functions. But here's the twist: your variable doesn't hold the object. It holds the ADDRESS of the object. Like a slip of paper that says "go to warehouse shelf 6382."

The internet's best analogy for this (and I'm stealing it): it's like a house address. The house is the actual object sitting in the heap. The address written on paper is the reference your variable holds. And if two people have the SAME address written down? They both walk into the same house.

Remember that. It's about to matter a lot.

Copy by value: the photocopy

Let's start with the well-behaved case. Real code from my practice file:

let a = 10;
let b = a;
b = 30;
console.log(b);  // 30
console.log(a);  // 10

let b = a — you'd think b and a are now linked, right? Nope. With primitives, JavaScript makes a PHOTOCOPY. b gets its own independent copy of 10. Then b becomes 30, and a just sits there at 10, completely unbothered.

One more word from class: primitives are IMMUTABLE. Fancy word, simple meaning — the value itself can't be changed, only replaced. When you write a = 20, JavaScript doesn't edit the 10. It throws it away and puts 20 in its place. Like replacing a sugar cube, not reshaping it. (Sir literally drew sugar cubes on the board. I have the notebook to prove it.)

Copy by reference: the shared Google Doc

Now the same idea, but with an object. Same practice file:

let obj1 = {
    id: 20,
    name: "rohit"
};

let obj2 = obj1;
obj2.id = 30;

console.log(obj1);  // { id: 30, name: "rohit" }
console.log(obj2);  // { id: 30, name: "rohit" }

Read that output again. I changed obj2. But obj1 ALSO changed. I did NOT touch obj1!

That's the exact face I made.

Here's what happened, watch it unfold:

let obj2 = obj1 did NOT copy the object. It copied the ADDRESS. Now obj1 and obj2 both hold "@6382" — two slips of paper with the same warehouse address. There's still only ONE object in the heap.

So obj2.id = 30 walks into that one shared object and changes it. Then when you ask obj1 what's in there — surprise, it's 30 too. Because it's the same object!

The internet's perfect analogy: it's a shared Google Doc link. A photocopy (primitives) — you scribble on your copy, the original is fine. A shared doc link (objects) — you edit the doc, EVERYONE with the link sees the change. obj1 and obj2 both have the link.

Why should you care?

Because this bug has ended careers. Okay, slight exaggeration. But barely.

Imagine you're building a shopping cart. You copy the cart to make a "backup"... then the user removes an item from the real cart... and your backup loses it too. Because it was never a backup. It was the same cart with two names.

This is THE classic beginner bug. Now you know it exists before it bites you. You're welcome.

The fix? There are ways to make a REAL copy (spread operator and friends are coming on a future day). For today, just remember the rule:

Primitives → copied by value. Objects → copied by reference.

Or even shorter, straight from my notebook: "Primitive = copy milta hai. Non-primitive = reference milta hai."

Tomorrow: wherever day 6 takes us. The deeper we go, the more interesting it gets. See you there.

I'm learning through my web development course, and today sir looked at us and said "== vs ===." Just like that. Like it was nothing. It was not nothing.

The loose friend and the strict bouncer

JavaScript has TWO ways to ask "are these equal?" And they do not agree.

10 == "10"    // true
10 === "10"   // false

Same values. Different answers. Why?

Because == — the loose friend — looks at the number 10 and the string "10" and goes "eh, close enough." It quietly converts the string into a number first, THEN compares. Bends the rules to make things work.

=== — the strict bouncer — checks your ID first. Number? String? Different species? "Not equal. Next." No conversion. No compromises. No mercy.

The internet's simplest rule, and I'm stealing it: use ===. Always. Unless you have a very specific reason not to. == is that friend who tries too hard — and in code, trying too hard creates bugs at 3 AM.

Patrick discovering that 0 == "0" is true. We've all been Patrick. (via josefczech.cz)

The null circus

Okay. Remember null and undefined from day 2? The twins? Today they put on a whole circus. Real outputs from my practice file — I'm not making any of this up:

null == undefined    // true
null === undefined   // false

Equal... but not identical. Like celebrity lookalikes. The loose friend says "same thing!" The strict bouncer says "different species, get out."

But wait, it gets worse:

null == 0    // false
null > 0     // false
null >= 0    // true?!

Read that again slowly. null is NOT equal to 0. null is NOT greater than 0. But null IS greater-than-or-equal to 0.

Pick a lane, null.

The explanation (because I needed one too): >= secretly converts null to 0 first, so it becomes 0 >= 0 — true. But == has a special rule: null only loosely equals undefined, nothing else. So null == 0 stays false. It's not random. It's just... rules written by different people who never met each other.

And undefined? undefined looked at all of this and said "nah, I'm out":

undefined == 0   // false
undefined < 0    // false
undefined > 0    // false
undefined <= 0   // false
undefined >= 0   // false

ALL false. undefined simply refuses to participate in mathematics. Honestly? Respect.

NaN: the identity crisis

NaN == NaN   // false

NaN isn't even equal to ITSELF. Imagine looking in the mirror and the mirror goes "nah, that's not you." That's NaN's entire life. The ultimate identity crisis.

Oh, and one more — chains betray you:

123 == "123" == 123   // false?!

JavaScript reads left to right: 123 == "123" becomes true (loose friend converts). Then true == 123 becomes false (true becomes 1, and 1 is not 123). The chain breaks at the last link. I hate it here.

The decision makers

After all that chaos, logical operators felt like a cold drink of water. These are the symbols that make DECISIONS:

age < 18 && money > 200   // BOTH must be true
age > 10 || money > 200   // ONE true is enough
!(age > 10)               // the contrarian — flips it

&& is a door with two locks — you need both keys. || is a door where either key works. And ! just disagrees with everything. We all know someone like !.

You'll use these everywhere. Every "if this AND that" in every app ever — that's && doing its job.

Bonus: binary wizardry

And then, at the end of class, sir casually dropped bitwise operators on us. These work on the actual 1s and 0s:

4 & 5    // 4
11 | 14  // 15
5 ^ 7    // 2

But the cool ones are the shifters:

5 << 3    // 40

Take 5, which is 101 in binary. Shove all the bits 3 places left: 101000. That's 40. Shifting left = multiplying by 2, three times. And 20 >> 2 = 5 — shove right = divide.

My notes literally have the binary written out: 101 becomes 101000. Chef's kiss. I felt like a hacker again.

Sir left us homework: figure out what undefined != null gives. I'm not telling you. Go try it in your console — that's the whole point of this series. We learn by breaking things.

Tomorrow: wherever day 5 takes us. See you there.

I'm learning through my web development course, and today sir basically said "remember those simple boxes? Forget simple." And introduced the complicated family.

Boxes that hold... everything?

So far every variable held ONE thing. One number. One string. Done.

Then sir wrote this:

let arr = [10, 20, 50, "ali", "mohit"];

Numbers AND names. In the same box. Together. My first thought was "wait, that's allowed??" Turns out yes. It's called an Array — just a list, in order. Like a train. Every bogie has a number, bogies stay in order.

Except — and this is where I laughed out loud — programmers count from zero. The FIRST bogie is bogie number 0. I don't know who decided this. I just work here.

Then sir did this:

console.log(typeof arr);   // "object"

I stared at my screen. An array... is an object? Sir just smiled. "Arrays are objects wearing a trench coat." Okay sir. Okay.

Then came Objects (capital O, different thing). Instead of numbered bogies, every value gets a name tag:

let obj = { user_name: "Ali", account_number: 31242314213, balance: 420 };

This one actually made sense to me immediately. It's like a form. Name: Ali. Account number: that. Balance: 420. You want the balance? Ask for it by name. No counting bogies.

And Functions — I'll be real with you, we only touched these. A function is a recipe you write once and reuse. Like instead of explaining how to make chai every single time, you write it down once and just say "make chai." We'll go deep later. Today was already a lot.

The part where JavaScript lies to you

Okay so. Yesterday we learned values have "species." Today I learned JavaScript secretly converts one species into another when you're not looking. It's called type conversion. Or coercion, which is just a fancy word for converting.

Sometimes you ask for it:

Number("100")   // 100. Fair. The text "100" becomes the number 100.

And sometimes JavaScript just... decides:

Number("100xs")   // NaN

NaN means "Not a Number." It's what JavaScript gives you when it tries to do math and fails. It's basically JavaScript throwing its hands up going "I don't know, man."

Look at this list. Really look at it.

Number(null) gives 0. So "nothing" equals zero. Fine.

Number(undefined) gives NaN. So "not defined" breaks math entirely.

And my personal favorite — Boolean(" ") is true. That's a single SPACE. Invisible. Nothing you can see. And JavaScript goes "yep, that's truthy." Meanwhile my motivation on Monday mornings? Falsy.

I found the clearest explanation of all this on Reddit and dev.to, and it clicked for me instantly, so here it is: the + sign has two personalities. If there's a string anywhere near it, + becomes GLUE. It just sticks things together:

"2" + "2"   // "22" — glue, not math

But - only knows math. Which gives us the legendary:

"2" + "2" - "2"   // 20

Go left to right. "2"+"2" becomes "22" (glue). Then "22"-"2" — JavaScript panics, converts both to numbers — 22-2 — 20.

This exact thing is a famous meme on r/ProgrammerHumor. Thousands of people have stared at it the way I did. Welcome to the club.

The ++ thing that broke me

Last topic. Operators — + - * /, the symbols that do things. Mostly normal. BODMAS came back from school (brackets first, I actually used it):

(((6*(3+18))/6)-9)   // 12

And % gives you the remainder. 20 % 3 is 2. Twenty rotis, three people, two left over. Nobody cares about % until the day they really, really need it.

But then. Then came ++.

let sum = 20;
let total = sum++;

What do you think total is? 21, right? Because sum++ means "add one"?

Nope. total is 20.

Because sum++ takes a photo FIRST and increments LATER. It grabs 20, hands it to total, and THEN sum becomes 21. Like that friend who says "I'll do it later" and means it.

But:

let sum = 20;
let total = ++sum;

NOW total is 21. Because ++sum increments FIRST, then hands it over. Same two characters. Different side. Different answer.

I genuinely sat staring at this for ten minutes. Ten. Minutes.

Anyway. Once I recovered:

i++ and i += 1 do the same thing. One of them just wears a tuxedo. (via lesjoiesducode.fr)

So that's day 3. Arrays, objects, JavaScript lying about types, and the ++ that gaslit me.

Tomorrow is == vs === and I'm honestly a little scared. See you there.

What's actually allowed inside those boxes?

In JavaScript, values come in different "species" called data types. There are 7 in total. Today we met 6 of them — the family called primitives. (Primitive = the simple, basic ones. The complicated family comes tomorrow. Don't worry, you'll love them.)

Think of it like this: you wouldn't put petrol in a water bottle, right? Different contents, different containers. Same idea — different kinds of values, different rules.

1. Number — the chill one

In some languages, you have to announce "this is an integer, this is a decimal" like you're filling out a government form. JavaScript doesn't care. One type covers everything:

let account_balance = 30;

10, -30, 10.8, 19.68 — all just "number". Integers, negatives, decimals — JavaScript shrugs and says "number hai, number." No int-vs-float drama. Beautiful.

2. String — text in quotes

let str = "double quotes";
let comment = 'single quotes';

Double quotes or single quotes — your choice, both work the same. (Remember yesterday's beads-on-a-string? Same thing.)

Quick question for you: what do you think happens if you forget the quotes and write let name = Ali;? Hold that thought — try it in your console later and watch JavaScript get confused. That's how you learn: break things on purpose.

3. Boolean — the light switch

True or false. On or off. Yes or no. That's it — the simplest data type in existence.

And this is where my teacher's sense of humor showed up. My actual practice variable from class:

let Papa_ko_block_kara_hai = false;
console.log(typeof Papa_ko_block_kara_hai); // boolean

Translation for non-Urdu speakers: "Have I blocked Papa?" = false. (No Papa was blocked in the making of this lesson.)

Now that word typeof — it's JavaScript's way of asking "what species is this thing?" Like a doctor checking your blood group. typeof false gives you "boolean". Try it yourself: open your console, type typeof 42, typeof "hello", typeof true. Go on, I'll wait.

4 & 5. undefined vs null — the twins everyone mixes up

Okay, deep breath. This is where beginners' brains melt. Two different ways of saying "nothing". Sounds the same? It's not. At all.

let account;        // declared, never assigned → undefined
let bal = null;     // deliberately set to "nothing" → null

Here's my analogy: undefined is the lunchbox you BOUGHT but never put food in. Empty by accident — you just... forgot. null is the plate you deliberately served EMPTY. You chose nothing. On purpose. Maybe you're fasting. Maybe it's a diet. The point is: it was a decision.

So: undefined = "I never got around to it." null = "I thought about it and chose nothing."

And now — the most famous bug in JavaScript history:

console.log(typeof null); // "object"

Wait, WHAT?! null is not an object. It's nothing! But JavaScript says "object" — because of a bug from 1995, in the very first version, that was never fixed. Why not? Because fixing it would break half the websites on the internet. So JavaScript looked at its own mistake and said "this is fine." Now it's "standard behavior."

This meme explains null better than I ever could. (via pleated-jeans.com)

6. BigInt — for numbers that ate too much

Normal JavaScript numbers have a speed limit:

console.log(Number.MAX_SAFE_INTEGER); // 9007199254740991

That's 9 quadrillion. Sounds like plenty — until you're counting something enormous and your numbers start glitching past the limit.

Enter BigInt — the heavy-duty truck of numbers. How do you make one? Stick an 'n' at the end:

let a = 4343147836124791823749832n;

That little 'n' is a VIP badge: "this number is too big for the normal lane." Without it, JavaScript would round it and quietly give you the wrong answer. With it? Perfect precision, no matter how huge.

Our Day 2 report card

Six species down:

• number — 30, -5, 10.8, all one happy family
• string — text in quotes, your pick of quotes
• boolean — true/false, the light switch
• undefined — empty by accident
• null — empty on purpose (and NOT an object, no matter what typeof claims)
• bigint — huge numbers with the 'n' VIP badge

Concepts living in my head rent-free: 14 and counting.

Tomorrow: the OTHER family — non-primitives. Arrays, objects, functions. That's where JavaScript stops being polite and starts getting real. See you there.

I'm Mudassar. I study physiotherapy — yes, the body-movement science — and last week I decided to also learn how to build websites. I'm learning web development these days, and I'm writing down everything I learn in the simplest words I know.

Quick question before we start: have you ever written a line of code? If your answer is "no"... perfect. You're exactly where I was yesterday. We're doing this together.

Okay, but what IS JavaScript?

Imagine giving instructions to a very literal-minded friend. "Pick up that cup" — and he picks it up. A programming language is just that: a way of giving instructions to a computer.

Now picture a house. (Stay with me here.)

• HTML = the bricks and walls. The structure.

• CSS = the paint and furniture. The looks.

• JavaScript = the electricity and the doors. The stuff that makes things WORK.

See that calculator on a shopping website? Buttons, numbers appearing, total changing — that's JavaScript doing push-ups behind the scenes. Without it, the buttons would just sit there. Pretty, but useless. Like a doorbell with no wiring.

So tell me — does that make sense? HTML = what it is. CSS = how it looks. JavaScript = what it does. Got it? Good. This one idea will carry you through months of learning.

My first conversation with a computer

Deep breath. Here's the first line of code I ever typed in my life:

console.log("hello world");

I pressed run. The computer answered: hello world.

I know, it's just text on a screen. But YOU try talking to a machine for the first time and not feeling like a hacker.

Now — I remember staring at this line thinking "what are these magic words?" So let me translate, like you're five:

• console — every browser has a secret diary hidden inside it. That's the console.

• log — literally means "write it down."

• Together: "Dear diary, please write down: hello world."

And those " " marks? They tell JavaScript: "hey, this is TEXT." Programmers call text a string. Why? Because it's a string of characters — like beads on a string. Now you know your first programmer word. Use it at dinner parties.

This is literally what happens. One line of code, and suddenly you're spamming "hello world" to everyone you know. (Comic via ProgrammerHumor.io)

WAIT — YOUR TURN. Don't just read this. Open your browser right now, press Ctrl+Shift+J (a little panel pops up — that's the diary!), type console.log("I am learning JavaScript") and press Enter.

Did your message appear? Then congratulations — you just wrote JavaScript. We're programmers now. Both of us.

Boxes with names (or: where do I keep stuff?)

Where do you keep your money so you don't lose it? A wallet, right? In, out, whenever you need it.

Code works the same way. A variable is just a named box where you keep a value for later. ("Variable" = something that can vary, change. See? Even the jargon makes sense when someone bothers to explain it.)

let num = 10.5;
console.log(num);

Read it out loud with me, like a sentence: "Make a new box. Name it num. Put 10.5 inside."

• let = "I'm making a new box."

• num = the name on the label.

• = = "put this inside." NOT "equals" like in maths! This confuses every beginner, so let's kill it right now: in code, = means assign.

• 10.5 = what's inside.

Then console.log(num) peeks inside and shows 10.5. Simple, right?

Three kinds of boxes (the fun part)

JavaScript gives you three kinds of boxes — and my teacher gave us the perfect way to remember them:

1. let — the whiteboard

let ar = "Ali";
ar = "mohit";
console.log(ar);  // shows "mohit"

Write "Ali" on a whiteboard. Changed your mind? Erase it, write "mohit". The latest value wins — that's why the output is mohit. Use let for things that update, like a game score or items in a shopping cart.

2. const — carved in stone

const ids = 20;
console.log(ids);
// ids = 30;   ← try this and JavaScript YELLS at you

const = constant = locked forever. When would you want that? Your CNIC number. Your date of birth. Things that should NEVER change while the program runs. Lock them with const and sleep peacefully.

3. var — the old Nokia

var x = 10;
x = 20;
console.log(x);

Before let and const, everyone used var. Sir's exact words — I'm quoting — "var old tarike, don't use it." It still works, like an old Nokia still makes calls. But would you buy one in 2026? Exactly. You'll trip over var in old YouTube tutorials — now instead of panicking, you'll go "ah, the old way." You're welcome.

Our Day 1 report card

Let's see what WE learned (you did the try-it-yourself part, right? RIGHT?):

• You can talk to the browser (console.log — our new best friend)

• You can store things in named boxes (let)

• You know which boxes lock forever (const)

• You know the old box to avoid (var)

Lines of code I'd written before today: 0. Today: 8. Growth: infinite.

So — how did it feel? Be honest. Not as scary as you expected, right?

Tomorrow we meet the data types — the different species of values: numbers, text, yes/no answers... and a couple of weird ones that'll make you laugh.

Stick around. We're just getting started.