Oh, That's Why.

About Oh, That's Why.

JavaScript fundamentals explained through story and analogy. One concept. Fully understood. Every episode. Oh, That’s Why. , is hosted by Alex Vega.

Publisher

Gize Bonilla

Category

technology

Language

en

Explicit

No

First episode

23 Mar 2026

Latest episode

14 Jul 2026

Latest episodes

17 episodes in the feed.

1. 

   14 Jul 2026

   EP17 — Classes — Syntax Sugar Over Prototypes

   People love to say JavaScript classes are "just syntactic sugar over prototypes." It's mostly true — but the word "just" is hiding something. In this Season 2 finale, Alex Vega explains what the class keyword actually compiles to — constructor functions and prototype chains — and where the sugar story breaks down: real private fields, which the prototype system genuinely cannot reproduce. Everything from the season converges here. You can find the Medium article here (https://medium.com/@gize.bonilla/8831fe6901d7). Oh, That's Why. — JavaScript, finally making sense. #JavaScript, #Web Development, #Programming, #Software Engineering, #Learning to Code

2. 

   7 Jul 2026

   EP16 — The 'this' Keyword — Part 2

   Part 1 explained what decides 'this'. Part 2 is about taking control of it. Alex Vega breaks down call, apply, and bind — the three methods that set 'this' explicitly — and arrow functions, which have no 'this' of their own and inherit it from the surrounding scope. By the end, the callback bug from Part 1 is solved two different ways, and the React event handler pattern finally makes sense. You can find the Medium article here (https://medium.com/@gize.bonilla/fdb9fc7554b2) . Oh, That's Why. — JavaScript, finally making sense. #JavaScript, #Web Development, #Programming, #Software Engineering, #Learning to Code

3. 

   29 Jun 2026

   EP15 — The 'this' Keyword — Part 1

   The same function can give a completely different value of 'this' depending on nothing more than how you called it. Not where you wrote it — how you called it. In this episode, Alex Vega explains the four binding rules that determine 'this' — default, implicit, explicit, and new — and the strict priority order between them, through the analogy of the word "here." Plus the most common 'this' bug in all of JavaScript: losing it in a callback. Oh, That's Why. — JavaScript, finally making sense. You can find the Medium article here (https://medium.com/@gize.bonilla/1e2fff3363f9). #JavaScript, #Web Development, #Programming, #Software Engineering, #Learning to Code.

4. 

   22 Jun 2026

   EP14 — Prototypes & The Prototype Chain

   Every array you create comes with .map(), .filter(), .reduce() — methods you never wrote. Where do they come from? In this episode, Alex Vega explains the prototype chain — the hidden mechanism behind property lookup in JavaScript — through the linked filing cabinet analogy. By the end, you understand why every array has those methods, how Object.create works, and why instanceof behaves the way it does. You can find the Medium article here (https://medium.com/@gize.bonilla/0c6810da15a5). Oh, That's Why. — JavaScript, finally making sense. #JavaScript, #Web Development, #Programming, #Software Engineering, #Learning to Code

5. 

   15 Jun 2026

   EP13 — Objects — How They Really Work

   An object is just key-value pairs. So why does a property sometimes refuse to update with no error? Why is a key missing from your loop even though it's right there in the object? In this episode, Alex Vega explains property descriptors — writable, enumerable, configurable — through a museum exhibit analogy, and covers Object.freeze, Object.seal, and the modern shorthand syntax that can quietly interact with all of it. Oh, That's Why. — JavaScript, finally making sense. You can find the Medium article here (https://medium.com/@gize.bonilla/576e36a901f0). #JavaScript, #Web Development, #Programming, #Software Engineering, #Learning to Code

6. 

   8 Jun 2026

   EP12 — Truthy & Falsy Values

   Your condition fails on zero. An empty string passes when it should not. An empty array is truthy when you expected false. In this episode, Alex Vega explains the six falsy values, why those six and not others, and the three logical operator patterns — OR defaults, AND guards, and nullish coalescing — that depend on this every day. Oh, That's Why. — JavaScript, finally making sense. You can find the Medium article here (https://medium.com/@gize.bonilla/243662e24b3d). #JavaScript, #Web Development, #Programming, #Software Engineering, #Learning to Code.

7. 

   1 Jun 2026

   EP11 — == vs === (Loose vs Strict Equality)

   Someone told you to always use ===. You followed the advice without knowing why. In this episode, Alex Vega explains what triple equals and double equals actually do — through the strict versus lenient judge analogy — and introduces the one case where double equals is the right choice: the null check pattern. You can find the Medium article here (https://medium.com/@gize.bonilla/1f7ba94d375a). Oh, That's Why. — JavaScript, finally making sense. #JavaScript, #Web Development, #Programming, #Software Engineering, #Learning to Cod

8. 

   25 May 2026

   EP10 — Type Coercion — The Basics

   "5" + 3 = "53". "5" - 3 = 2. JavaScript gets mocked for results like these. But the behavior follows documented, deterministic rules. In this episode, Alex Vega explains the three internal conversion rules JavaScript uses — ToString, ToNumber, and ToPrimitive — through the silent translator analogy. By the end, every coercion result makes sense. Oh, That's Why. — JavaScript, finally making sense. You can find the Medium article here (https://medium.com/@gize.bonilla/4141ff6590d8). #JavaScript, #Web Development, #Programming, #Software Engineering, #Learning to Code

9. 

   18 May 2026

   EP09 — Primitives vs Reference Types

   You pass an object into a function. The function changes one property. You never returned anything. The original changed anyway. In the Season 2 opener, Alex Vega explains why through the Post-it and home address analogy — the most fundamental distinction in how JavaScript stores data. Accidental mutation, confusing const behavior, and broken equality checks all make complete sense by the end. You can find the Medium article here (https://medium.com/@gize.bonilla/8c5b38cac7bf). Oh, That's Why. — JavaScript, finally making sense. #JavaScript, #Web Development, #Programming, #Software Engineering, #Learning to Code

10. 

    11 May 2026

    EP08 — Garbage Collection & Memory Leaks

    Your application gets slower over time. Memory creeps up. No error, no crash — just quiet accumulation. In this Season 1 finale, Alex Vega explains how JavaScript's garbage collector works, why memory leaks happen, and the four most common patterns that cause them — through the night cleaning crew analogy. Eight episodes. One complete picture of how JavaScript runs. You can find the Medium article here (https://medium.com/@gize.bonilla/7223678642c1). Oh, That's Why. — JavaScript, finally making sense. #JavaScript #Web Development #Programming #Software Engineering #Learning to Code

11. 

    4 May 2026

    EP07 — The Stack vs The Heap

    You assign an object to a new variable. Change a property on the copy. The original changes too. Try the same with a number — it doesn't. In this episode, Alex Vega explains why through the whiteboard and filing cabinet analogy — where primitives and objects actually live in memory, why objects are passed by reference, and why const objects can still be mutated. If you have ever been confused by object behavior in JavaScript, this is the episode. Oh, That's Why. — JavaScript, finally making sense. You can find the Medium article here (https://medium.com/@gize.bonilla/a1c02b85bc35) #JavaScript #Web Development #Programming #Software Engineering, #Learning to Code

12. 

    27 Apr 2026

    EP06 — Closures

    A function runs and returns. Its variables should be gone. And then another function uses one of them anyway. This is the episode the series was building toward. Alex Vega explains closures through the demolished room analogy — what they are, why they work, and why every callback, event handler, and React hook you have ever written is a closure. Six episodes in. The payoff. Oh, That's Why. — JavaScript, finally making sense. You can find the Medium article here (https://medium.com/@gize.bonilla/35f4192fc25d).

13. 

    20 Apr 2026

    EP05 — Scope — Global, Function & Block

    You have written a variable. And from somewhere else in your code, JavaScript acts like it does not exist. In this episode, Alex Vega explains why — through a building analogy that makes global scope, function scope, and block scope feel completely natural. She also explains the classic for loop bug that catches almost every JavaScript developer, and exactly why switching from var to let fixes it. Five episodes in. Everything connects. You can find the Medium article here (https://medium.com/@gize.bonilla/846e426ed423).

14. 

    13 Apr 2026

    EP04 — Hoisting — var, let & const

    You can call a JavaScript function before you have written it. Try the same with a const variable and you get an error. Same file, same idea, completely different result. In this episode, Alex Vega explains exactly why — through the chef analogy that makes var, let, const, and the Temporal Dead Zone feel like a coherent system rather than a list of rules to memorize. Four episodes in, and everything connects. You can find the Medium Article here (https://medium.com/@gize.bonilla/0055b9c92a24).

15. 

    6 Apr 2026

    EP03 — The Call Stack

    You have seen it in error messages: "Maximum call stack size exceeded." But do you know what the call stack actually is? In this episode, Alex Vega explains how JavaScript keeps track of where it is as your code runs — through a simple analogy that makes the whole thing click. By the end, you will know how to read a stack trace, why stack overflows happen, and why JavaScript can only do one thing at a time. Oh, That's Why. — JavaScript, finally making sense. Here is the medium article https://medium.com/@gize.bonilla/0674b29aeb1a (https://medium.com/@gize.bonilla/0674b29aeb1a) References http://latentflip.com/loupe (http://latentflip.com/loupe)

16. 

    30 Mar 2026

    E02 — Every Piece of JavaScript Runs Inside a Room

    Every time JavaScript runs a function, it builds something first. A contained environment, with its own variables, its own rules, its own sense of identity. Most developers run functions hundreds of times a day without knowing this is happening. It is happening every single time. Here is the medium article https://medium.com/@gize.bonilla/0e8275391f58

17. 

    23 Mar 2026

    EP01 — What Actually Happens When JS Runs?

    Before a single line of your code executes — what does the JavaScript engine actually do? Most developers think JavaScript just reads top to bottom. But there are two distinct phases that happen every time you hit run — and not knowing this is behind some of the most confusing bugs you'll ever encounter. In this episode, Alex Vega breaks it down through story and analogy. No code. Just the concept, made completely clear. Read the companion article on Medium — link below. Oh, That's Why. — JavaScript, finally making sense. You can find the article in this link - https://medium.com/@gize.bonilla/what-actually-happens-when-javascript-runs-your-code-84d3f5a25f32

Reach and audience

Public platform figures. Ratings count people who left a rating, not total listeners.

Apple Podcasts (US)

5.0 / 5

1 ratings

Spotify

5.0 / 5

1 ratings

Contact Oh, That's Why.

Guest appearances

Does not typically book guests

Based on episode analysis; this does not confirm that the show is currently accepting guests.