💡
Languages & Fundamentals
The concepts under every language, explained plainly
Languages & Fundamentals
Null, Undefined and Empty: Three Different Kinds of Absence
Treating "no value", "not set" and "set to nothing" as the same thing is behind a surprising share of data bugs. What each one means, and how to choose deliberately.
9 min read
Languages & Fundamentals
Timezones: Why the Date Is Wrong for Half Your Users
An off-by-one day is the most common timezone bug and the least understood. The mechanism, the exact line where a date becomes wrong, and the rule that prevents it.
9 min read
Languages & Fundamentals
Character Encoding: Why Names Break and One Emoji Counts as Two
Mojibake, a length that disagrees with itself, and a truncation that corrupts the last character. All three come from the same confusion between bytes, code points and what a reader sees.
9 min read
Languages & Fundamentals
Why 0.1 + 0.2 Is Not 0.3, and What to Use for Money
Every language with IEEE 754 floats gets this "wrong", and it is not a bug. Here is the mechanism, the exact point where money calculations start drifting, and the three fixes worth knowing.
9 min read
Languages & Fundamentals
From Callbacks to Promises to Async/Await: How JavaScript's Async Syntax Evolved
The underlying mechanism behind JavaScript's asynchronous code has not changed in twenty years. What changed three times is the syntax wrapped around it — and each change solved a real, specific problem with the syntax before it.
9 min read
Languages & Fundamentals
Functional Programming Concepts Worth Adopting Without Switching Languages
You do not need Haskell to benefit from functional programming's core ideas. Pure functions, immutability and composition are adoptable piecemeal in any mainstream language, and each one earns its keep independently.
9 min read
Languages & Fundamentals
Never Store Money in a Floating-Point Number
Computers can’t represent many decimal fractions exactly, which is why 0.1 plus 0.2 famously isn’t 0.3 — and why money needs special handling.
9 min read
Languages & Fundamentals
Why Naming Things Is Genuinely Hard (and Worth the Effort)
A good name is compressed understanding. That’s why naming is difficult, and why sloppy names quietly slow every future reader down.
9 min read
Languages & Fundamentals
Off-by-One Errors: The Tiny Mistake That Never Fully Goes Away
One of the oldest bugs in programming survives because it lives at boundaries — the edges of loops, arrays and ranges that our intuition handles poorly.
9 min read
Languages & Fundamentals
Async/Await, Demystified: Waiting Without Freezing
Asynchronous code confuses people because it reads top to bottom but doesn’t run that way. One mental model clears most of the fog.
9 min read
Languages & Fundamentals
Error Handling: The Part Beginners Skip and Seniors Obsess Over
The happy path is the easy 80%. Robust software is mostly about what you do when things go wrong — and where you decide to handle it.
9 min read
Languages & Fundamentals
Database Indexes: The Mental Model That Makes Queries Fast
Why is the query slow? Nine times out of ten the answer is an index — missing, unusable, or ignored. The phone-book model that explains indexing without a DBA in the room.
9 min read
Languages & Fundamentals
Mutable vs Immutable: The Distinction Behind a Surprising Number of Bugs
Whether data can change in place quietly shapes how your program behaves. Misunderstanding it is behind a whole class of “but I didn’t touch that” bugs.
9 min read
Languages & Fundamentals
Recursion, Finally Clicking: A Function That Trusts Itself
Recursion feels like magic until one idea lands: assume the smaller problem is already solved, and only handle the step in front of you.
9 min read
Languages & Fundamentals
Why 0.1 + 0.2 Isn't 0.3: Floating-Point Numbers, Explained
The most famous "bug" that isn't a bug. How computers store decimals in binary, why tiny errors creep in, and the right way to handle money and comparisons.
9 min read
Languages & Fundamentals
Mutable vs Immutable: The Distinction Behind a Whole Class of Bugs
Change in place or make a copy? The answer shapes shared state, surprise side effects, and why your list changed when you never touched it. A practical guide.
9 min read
Languages & Fundamentals
Recursion and the Call Stack: Why Your Function Blew Up
Recursion is elegant until it overflows the stack. A concrete mental model of what happens frame by frame, when recursion beats loops, and how to keep it from crashing.
9 min read
Languages & Fundamentals
Hash Maps, From the Ground Up: The Data Structure You Use Every Day
Dictionaries, objects, maps — the same idea under a dozen names. How hashing turns a key into a slot, why lookups are near-instant, and the failure modes that bite in production.
9 min read
Languages & Fundamentals
Naming Things Well: A Practical Guide to the Hardest Problem
Code is read ten times more than it is written, and names are most of what gets read. Concrete rules for names that make bugs visible and reviews fast.
9 min read
Languages & Fundamentals
Big-O Notation in Plain English (No Maths Degree Required)
Big-O is just a way to describe how slow your code gets as the data grows. A practical guide to reading it, why it matters, and the handful of classes you meet in real work.
9 min read
Languages & Fundamentals
Value vs Reference: The Bug Behind Half Your Surprises
Why changing one variable mysteriously changes another. Understanding how languages copy values versus share references explains a huge share of confusing bugs.
9 min read