Blog
Articles on file formats, data formats, encoding, and the tools that work with them — how they actually work, the gotchas that trip people up, and when to reach for which.
Why Your CSV Opens as Mojibake in Excel
The file isn't corrupted. Excel guessed the wrong encoding, and a CSV carries no field that could have told it the right one.
Why Money Math Breaks in Floating Point
0.1 + 0.2 isn't 0.3 because binary can't write one tenth. The same limitation puts a stray cent in payroll totals and amortization schedules.
Why Trimming a Video Re-Encodes the Whole Thing
Video frames mostly store differences from other frames, so cutting anywhere but a keyframe means the codec has to rebuild everything after the cut.
Sample Rate and Bit Depth, Without the Myths
Sample rate sets the highest frequency you can record; bit depth sets the noise floor. Neither one works the way "higher is smoother" suggests.
The Same Korean Text, Two Different Byte Sequences
Unicode can spell 한 as one code point or three. Both are correct, they look identical, and string comparison treats them as different text.
How a Scratched QR Code Still Scans
QR codes carry redundant data computed with Reed–Solomon coding, which is why a torn corner or a logo pasted in the middle usually doesn't stop them.
The Gamma Trap: Why Averaging Colors Goes Wrong
Pixel values aren't proportional to light. Doing arithmetic on them directly is why blended edges look dark and resized images lose their brightness.
Why JPEG Artifacts Look the Way They Do
Blocking, ringing, and color smearing aren't random damage. Each one is a direct fingerprint of a specific step in how JPEG throws information away.
How Image Resizing Actually Works
Resizing is resampling — inventing pixels that were never measured. The algorithm you pick decides whether the result looks soft, crunchy, or aliased.
Why SQL Formatting Matters More Than You Think
SQL layout conventions like one-column-per-line and leading commas aren't aesthetic — they make queries diffable, reviewable, and structurally readable.
Grayscale Is Not Just Removing Color
Converting an image to grayscale means choosing how much each color channel counts — and the standard weights are wildly unequal because human vision is.
How to Combine Photos Without Distorting Them
Merging two photos forces decisions about aspect ratio, resolution, and layout — and the wrong default (stretching) is the one mistake viewers always notice.
How Text Diffs Actually Work
A diff tool doesn't watch you edit — it computes the smallest set of deletions and insertions that turns one text into the other, which explains a lot.
Why Markdown Won
Markdown beat richer markup formats by optimizing for one thing — being readable as plain text before any rendering — and that explains its gaps too.
What MP3 Actually Throws Away (and When WAV Still Matters)
WAV stores every sample of the raw signal; MP3 and AAC permanently discard the parts a psychoacoustic model predicts you can't hear.
The Five UTM Parameters, and How They Go Wrong
UTM tags are plain query parameters that analytics tools group into reports — so every typo, casing difference, and misplaced link shows up forever.
How Instagram Grid Posts Actually Work
A grid mural is one wide image cut into equal slices and uploaded in reverse order — the hard parts are the crop math and the profile grid's aspect ratio.
Pyeong — Korea's Area Unit, Explained
One pyeong is 3.3058 m² — a six-cheok square sharing its lineage with the Japanese tsubo — and Korean listings measure a different area than contracts.
What Makes a Texture Actually Seamless
A texture tiles cleanly when its opposite edges are continuous and its features don't betray the repeat — and both of those are testable, fixable properties.
What Actually Makes 8-Bit Sound "8-Bit"
The chiptune sound isn't about 8-bit samples — it's the fingerprint of sound chips that could only produce a few fixed waveforms, and the workarounds.
Why Games Still Use Sprite Sheets
Sprite sheets exist because of how GPUs batch work, not to save disk space — texture switches break batching, and the fixes all follow from that.
How In-Browser Screen Recording Actually Works
Two browser APIs — getDisplayMedia for capture and MediaRecorder for encoding — turn a web page into a screen recorder with no install and no upload.
Writing Survey Questions That Get Honest Answers
A survey question is a measuring instrument, and it can be miscalibrated — wording, question order, and scale design each introduce predictable biases.
Image Dimensions vs. File Size: Why Uploads Get Rejected
An upload rejected as "too large" is almost always checking pixel dimensions, not kilobytes — fixing the wrong one leaves the error in place.
Why a Password-Protected PDF Isn't as Secure as You Think
A PDF can carry two different passwords — one that encrypts the file, and one that's just a permission flag most tools strip without asking.
Why Counting Characters Is Harder Than It Looks
A "character" means three things — code point, UTF-16 code unit, or grapheme cluster — which is why Twitter, SMS, and databases each count differently.
How Palette Extraction Turns Millions of Pixels Into Six
A photo holds thousands of distinct colors, so pulling a palette means recursively splitting color space with median-cut, not counting the commonest pixel.
The Five Favicon Sizes That Actually Matter in 2026
Browsers, iOS, and Android each read a favicon from a different file at a different size — five sizes cover all of them, and the longer checklists don't.
The Hidden Off-By-One in Counting Days Between Dates
Subtracting two dates looks like arithmetic, but DST transitions, shifting offsets, and inclusive-versus-exclusive endpoints can each change the answer.
BMI Is a Population Statistic, Not a Diagnosis
BMI was built two centuries ago to describe average body proportions across populations, not to assess one individual's health — hence its blind spots.
How Loan Amortization Works, and Why Interest Front-Loads
Every fixed-rate loan payment is the same size, but the split between principal and interest shifts completely over the life of the loan. Here's the math.
How URL Shorteners Work, and What They Can See About You
A short link is a database lookup and a redirect — the interesting part is what a shortener can track along the way, and how much of that actually happens.
Why the Same Regex Behaves Differently in Every Language
Regular expressions aren't one standard — they're a family of incompatible dialects, and the differences surface when you copy a pattern between languages.
Why the Same SQL Looks Different in Every Database
SQL is a standard in name only — every vendor extends and bends it differently, which is why a query that runs in one database needs edits in another.
SVG vs PNG: Why One Has a Resolution and the Other Doesn't
PNG stores a fixed grid of pixels; SVG stores instructions for drawing shapes — that's the whole reason one blurs when scaled up and the other never does.
Unix Timestamps Explained: What Actually Happens in 2038
A Unix timestamp is just a count of seconds — simple, until you hit the exact number where a 32-bit counter runs out of room.
UUID v4 vs v7: Why Databases Are Moving to Time-Ordered IDs
Random UUIDs solve uniqueness perfectly and index performance badly — v7 keeps the uniqueness guarantee while fixing the part that was hurting databases.
What a JWT Actually Proves (and What It Doesn't)
A JWT's signature proves the token wasn't tampered with since it was issued — it says nothing about whether the claims inside were true when signed.
Why GIFs Look Worse Than the Video They Came From
GIF is a 30-year-old image format capped at 256 colors per frame — every "GIF looks bad" complaint traces back to that one hard limit.
Base64 Isn't Encryption: What It's Actually For
Base64 turns binary data into text-safe characters so it survives systems built for text — it hides nothing and adds no security.
The 5 JSON Errors That Break Most Parsers
JSON looks like JavaScript but follows a stricter grammar — these are the five mistakes that account for almost every "unexpected token" error.
The CSV Edge Cases That Break Naive CSV-to-JSON Converters
CSV has no single formal spec — commas inside quoted fields, embedded newlines, and inconsistent encodings each break a simple split(",") parser differently.
Why iPhone Photos (HEIC) Won't Open Everywhere
HEIC compresses better than JPEG using a newer, patent-encumbered codec — which is exactly why so much software still can't open it.
How Age Is Actually Calculated, and Where Bugs Hide
Age isn't just this year minus birth year — borrow-a-day-from-the-month logic, leap years, and Korea's separate age system each break naive math.
How a Password Generator Actually Picks Random Characters
The security of a generated password depends entirely on where its randomness comes from — and Math.random() is the wrong answer.
How Much Data Can a QR Code Actually Hold?
A QR code's capacity depends on its version, its error correction level, and the kind of data you encode — and the three trade off against each other.
3 Ways to Remove a Photo Background, and When Each Fails
Chroma key, edge detection, and ML segmentation solve background removal differently — and each one breaks on a different kind of photo.
What's Actually Hiding in Your Photo's EXIF Data
Every photo a camera or phone takes carries metadata beyond the pixels — including, by default, the exact GPS coordinates where it was taken.
Why Won't My PDF Get Any Smaller?
Most of a PDF's size lives in three places — images, fonts, and structure — and each one has a hard floor that no compressor can push past.