1// ✅ JIT-friendly — consistent types
2function addNumbers(a, b) {
3  return a + b; // always numbers → JIT compiles fast numeric add
4}
5
6for (let i = 0; i < 1000000; i++) {
7  addNumbers(i, i + 1); // V8 detects 'hot', compiles to machine code
8}
9console.log(addNumbers(5, 3)); // 8 — runs as native machine code
10
11
12// ❌ JIT-unfriendly — inconsistent types (deoptimizes)
13function mixedAdd(a, b) {
14  return a + b; // sometimes number+number, sometimes string+number
15}
16
17for (let i = 0; i < 500; i++) {
18  mixedAdd(i, i + 1);    // V8 assumes: number + number
19}
20mixedAdd('hello', 5);    // DEOPT! — assumption broken, falls back to bytecode
21// V8 now treats the function as polymorphic — slower

1// STACK — primitives stored by value
2let x = 10;        // x stored on stack
3let y = x;         // y gets a COPY of x's value
4y = 20;
5console.log(x);    // 10 — x is unchanged
6console.log(y);    // 20 — independent copy
7
8// HEAP — objects stored by reference
9let obj1 = { name: 'Alice' };  // object on heap, obj1 holds reference
10let obj2 = obj1;               // obj2 copies the REFERENCE, not the object
11obj2.name = 'Bob';
12console.log(obj1.name); // 'Bob' — same object!
13console.log(obj2.name); // 'Bob'
14
15// CALL STACK — function frames
16function outer() {
17  let a = 1;          // pushed onto stack
18  function inner() {
19    let b = 2;        // pushed onto stack
20    return a + b;     // reads a from outer frame
21  }                   // inner frame popped off stack
22  return inner();
23}                     // outer frame popped off stack
24
25console.log(outer()); // 3

1// ✅ Object becomes unreachable → eligible for GC
2function createData() {
3  let bigArray = new Array(1000).fill('data'); // allocated on heap
4  return bigArray[0]; // only returning first element
5  // bigArray itself has no external reference after function returns
6  // → GC will collect it
7}
8console.log(createData()); // 'data'
9
10
11// ❌ Memory Leak — event listener never removed
12const button = document.createElement('button');
13const largeData = new Array(10000).fill('important');
14
15function handleClick() {
16  // This closure captures 'largeData'
17  console.log(largeData[0]);
18}
19
20button.addEventListener('click', handleClick);
21// If button is removed from DOM but handleClick is never removed,
22// largeData stays in memory forever
23
24// ✅ Fix: always remove listeners you no longer need
25// button.removeEventListener('click', handleClick);
26
27console.log('Reachability demonstrated');

1// ✅ Fast — same shape, V8 uses one hidden class for all
2class Point {
3  constructor(x, y) {
4    this.x = x;  // always in same order
5    this.y = y;
6  }
7}
8const p1 = new Point(1, 2);
9const p2 = new Point(3, 4);
10const p3 = new Point(5, 6);
11// All share the same hidden class → fast property access
12
13
14// ❌ Slow — different shapes, V8 creates multiple hidden classes
15const a = {};
16a.x = 1;      // hidden class A: { x }
17a.y = 2;      // hidden class B: { x, y }
18
19const b = {};
20b.y = 2;      // hidden class C: { y }
21b.x = 1;      // hidden class D: { y, x } ← different order!
22// a and b have DIFFERENT hidden classes even with same properties
23// → V8 cannot optimize property access the same way
24
25console.log(p1.x + p2.y); // 1 + 4 = 5 (fast path)
26console.log(a.x + b.x);   // 1 + 1 = 2 (slower path)

1console.log('1 — Start');             // Runs immediately (synchronous)
2
3setTimeout(() => {
4  console.log('3 — setTimeout');       // Runs LAST — macrotask queue
5}, 0);
6
7Promise.resolve().then(() => {
8  console.log('2 — Promise.then');     // Runs BEFORE setTimeout — microtask queue
9});
10
11console.log('1 — End');               // Runs immediately (synchronous)
12
13// Output order:
14// 1 — Start
15// 1 — End
16// 2 — Promise.then   ← microtask queue (runs before next macrotask)
17// 3 — setTimeout     ← macrotask queue
18
19// WHY? The event loop empties the microtask queue (Promises)
20// completely before moving to the next macrotask (setTimeout)