Digital Garden

I Wrote a Tool to Tame 15 Years of Photos — Here's How It Works

Tue, 05 May 2026 00:00:00 GMT

I recently stared down a folder containing 5,700 photos spanning over fifteen years — iPhone snapshots, DSLR exports, random screenshots, duplicates from cloud sync conflicts, and images forwarded through half a dozen messaging apps. Some were 24-megapixel RAW conversions. Some were 640x480 relics from 2009. Many were duplicates, or near-duplicates, taken in burst mode or re-saved at slightly different quality levels. Some existed three times over: once from the original camera roll, once from a WhatsApp forward, and once from an iCloud sync that silently created a copy with a different filename.

I didn't want to spend a weekend manually sorting through them. I wanted a pipeline that could:

Deduplicate images — not by filename or byte-for-byte comparison, but perceptually. A JPEG and a slightly-cropped HEIC of the same sunset should collapse into one.
Normalize everything to a single format — modern, efficient, and lossless-capable.
Downscale to a sane max resolution — I don't need 6000x4000 pixels for photos I'm archiving, not printing.
Classify scenes — automatically tag what's in each photo (landscape, food, document, etc.) without uploading anything to a cloud API.
Rename consistently — machine-sortable filenames derived from EXIF timestamps, resolution, and scene label.

So I built batch-image-processor, a single-file Python CLI backed by a 20-line Swift helper. No database, no config file, no daemon. Just a two-pass pipeline that reads a folder and writes a clean, deduplicated, tagged archive.

Here's how it works under the hood.

The Stack

Layer	Library / Tool	Role
Image I/O	Pillow 12.2+	Open, resize, transpose, save images
HEIC support	pillow-heif 1.3+	Register HEIF/HEIC codec with Pillow via `register_heif_opener()`
Perceptual hashing	imagehash 4.3+	Generate pHash fingerprints for deduplication
Scene classification	Apple Vision framework via `VNClassifyImageRequest`	On-device neural image classification (macOS only)
Runtime	Python 3.14+, managed by uv	Fast dependency resolution and execution

No GPU required. No cloud calls. Everything runs locally on a Mac.

A Word on Pillow

If you've done any image work in Python, you've used Pillow — but you might not know its origin story. The original library was called PIL (Python Imaging Library), created by Fredrik Lundh in 1995. PIL was the image library for Python for over a decade, but development stalled after 2009 with the 1.1.7 release. It never gained Python 3 support, and it was never uploaded to PyPI — you had to install it from a tarball.

In 2010, Alex Clark forked PIL as Pillow, initially just to get it onto PyPI and add Python 3 compatibility. Over time, Pillow evolved far beyond the original: it added support for new formats, improved performance, and became the officially recommended replacement. Today, pip install Pillow is one of the most-downloaded packages on PyPI, with over 100 million downloads per month. When you import PIL in modern Python, you're actually importing Pillow — it installs itself under the PIL namespace for backwards compatibility.

For this project, Pillow handles the core image pipeline: opening files in any supported format, reading EXIF metadata, applying orientation transforms, resizing with high-quality resampling filters, and saving to HEIF (via the pillow-heif plugin). It's the Swiss Army knife that makes everything else possible.

Pass 1: Hash and Deduplicate

The first pass never fully loads any image into memory at display resolution. Instead, for each file, it:

Opens the image and applies EXIF transpose via ImageOps.exif_transpose().
Generates a 512x512 thumbnail (not a resize — Image.thumbnail() preserves aspect ratio and is much faster than a full decode followed by resize()).
Computes a perceptual hash (pHash) using imagehash.phash().

HASH_THUMBNAIL_SIZE = (512, 512)

def hash_image(path: Path) -> imagehash.ImageHash:
    with Image.open(path) as img:
        img = ImageOps.exif_transpose(img)
        img.thumbnail(HASH_THUMBNAIL_SIZE)
        return imagehash.phash(img)

The with block ensures the image file handle is closed immediately after hashing — important when you're iterating over thousands of files and don't want to leak file descriptors.

The EXIF Orientation Problem

Step 1 deserves more explanation, because it addresses one of the most persistent headaches in image processing. When you hold your phone sideways and take a photo, the camera sensor doesn't rotate — it always captures in the same physical orientation. Instead, the phone writes an EXIF orientation tag (tag 0x0112) into the file's metadata, telling viewers "rotate this 90 degrees clockwise before displaying." The image data on disk is still landscape; the rotation is just a hint.

This creates a problem for perceptual hashing. If the same photo exists as two files — one with the raw sensor orientation plus an EXIF tag, and one where a tool has already physically rotated the pixels and stripped the tag — their pixel data is completely different. One is a landscape buffer, the other is portrait. Without EXIF transpose, they'd produce unrelated hashes and never be recognized as duplicates.

ImageOps.exif_transpose() solves this by reading the orientation tag and physically rotating/flipping the pixel data to match, then removing the tag. After this call, the pixel buffer is always in "display" orientation regardless of how the file was originally saved. This is essential for correct hashing, and it's a step that a surprising number of image tools skip.

There are eight possible EXIF orientation values (identity, plus rotations and mirror flips), and exif_transpose handles all of them. The most common in practice are 1 (normal), 3 (rotated 180), 6 (rotated 90 CW), and 8 (rotated 90 CCW) — corresponding to how you hold the phone.

Why pHash?

imagehash supports several algorithms, each with different tradeoffs:

ahash (average hash) — Resizes the image to 8x8, converts to grayscale, and sets each bit based on whether the pixel is above or below the mean. Simple and fast, but sensitive to brightness changes and gamma corrections. A photo edited with slightly different exposure will produce a noticeably different hash.
dhash (difference hash) — Similar to ahash, but instead of comparing pixels to the mean, it compares each pixel to its neighbor. This captures gradients rather than absolute brightness, making it more robust to exposure changes. But it struggles with crops, because shifting the image shifts all the gradient relationships.
phash (perceptual hash) — Applies a Discrete Cosine Transform (DCT) to the image, then keeps only the low-frequency components. This is the one I chose.
whash (wavelet hash) — Uses a Discrete Wavelet Transform (DWT) instead of DCT. Theoretically captures both frequency and spatial information, but in practice performs similarly to pHash for photographic content while being more sensitive to certain types of noise.

I went with pHash because it's the most robust for photographic deduplication. Here's why.

How the Discrete Cosine Transform Makes Hashing Work

The DCT is the same mathematical transform that JPEG uses internally. It converts a spatial-domain signal (pixel values) into a frequency-domain representation (how much of each "frequency" is present in the image). Low-frequency components correspond to smooth gradients and broad shapes — the overall structure of the image. High-frequency components correspond to fine detail, sharp edges, and noise.

The key insight behind pHash is that two versions of the same photo share the same low-frequency structure, even if the high-frequency details differ. A JPEG saved at quality 50 has lost fine detail compared to the same image at quality 95, but the broad shapes — the arrangement of sky, trees, and faces — are identical. Re-encoding, resizing, slight cropping, color space conversion — all of these primarily affect high frequencies while leaving the low-frequency structure intact.

Here's what pHash does step by step:

Resize the image to 32x32 pixels (this is done internally by imagehash, separate from the 512x512 thumbnail I create for Pillow)
Convert to grayscale
Apply a 2D DCT to the 32x32 pixel matrix
Keep only the top-left 8x8 block of DCT coefficients — these are the lowest frequencies
Compute the median of these 64 values
Set each bit to 1 if the coefficient is above the median, 0 if below

The result is a 64-bit integer. Each bit encodes whether a particular low-frequency pattern is present in the image above or below average. Two images that look the same to a human will produce hashes that differ by only a few bits.

The Hamming distance between two hashes is simply the number of bits that differ — computed efficiently with an XOR followed by a popcount. A distance of 0 means the hashes are identical. A distance of 64 would mean every single bit is different (essentially, the inverse image).

Choosing the Right Threshold

I use a distance threshold of 10 (out of 64 bits), which I arrived at through trial and error on my own photo collection. The tradeoff is straightforward:

Too low (e.g., 3-5): Misses duplicates that have been re-compressed or slightly cropped. You'll still have near-dupes in the output.
Too high (e.g., 15-20): Starts merging photos that are merely similar — two different sunset shots, or two group photos where one person moved. You lose distinct photos.
The sweet spot (8-12): Catches re-saves, format conversions, burst-mode shots, and messaging-app copies, while keeping genuinely different photos separate.

At threshold 10, in practice this catches:

The same photo saved as both .jpg and .heic
Burst-mode shots of the same scene (as long as nothing moved much between frames)
Re-saves at different JPEG quality levels
Screenshots of the same screen at different times (if the content hasn't changed much)
Photos forwarded through messaging apps (which often re-encode and downscale)

When duplicates are found, the pipeline keeps the highest-resolution version. This is a simple max() over width * height — if you took the same photo and one copy is 4032x3024 and another is 1920x1080 from a messaging app, the original survives.

Grouping Strategy

The deduplication uses a straightforward first-match-wins grouping approach:

def deduplicate(entries: list[tuple[Path, imagehash.ImageHash, int]]) -> list[Path]:
    groups: list[tuple[imagehash.ImageHash, list[tuple[Path, int]]]] = []

    for path, h, pixels in entries:
        placed = False
        for ref_h, group in groups:
            if h - ref_h <= HASH_DISTANCE_THRESHOLD:
                group.append((path, pixels))
                placed = True
                break
        if not placed:
            groups.append((h, [(path, pixels)]))

    # Keep the highest-resolution image from each group
    return [max(group, key=lambda item: item[1])[0] for _, group in groups]

For each image, it iterates over existing groups and checks the Hamming distance against the group's reference hash. The subtraction operator h - ref_h on ImageHash objects returns the Hamming distance — the number of bits that differ between two hashes. If it's within the threshold of 10, the image joins that group. If no group matches, it becomes the seed of a new one.

This is O(n * g) where g is the number of groups, which is perfectly adequate for personal photo archives. For my 5,700 images, the grouping phase completed in under a minute. For collections in the hundreds of thousands, you'd want a VP-tree or BK-tree for nearest-neighbor lookup — but at this scale, the brute-force approach is simpler and fast enough.

Scene Classification: On-Device Neural Networks via Apple Vision

This is the part that made me unreasonably happy.

macOS ships with the Vision framework (import Vision in Swift), Apple's high-level computer vision API. Introduced at WWDC 2017 alongside iOS 11, Vision was initially focused on face detection, barcode reading, and text recognition. Over subsequent releases, Apple steadily expanded it: image alignment in 2018, animal detection in 2019, hand and body pose estimation in 2020, and — crucially for this project — image classification via VNClassifyImageRequest.

VNClassifyImageRequest taps into a Core ML model that ships with macOS itself. You don't download a model file, you don't specify a model path, and you don't need an internet connection. The model is embedded in the operating system and updated with macOS releases. It's the same classifier that powers the "Categories" view in Apple Photos, the ability for Spotlight to search "photos of food" or "photos of mountains," and the Memories feature that groups your beach vacation shots together.

The taxonomy is surprisingly granular. Rather than broad labels like "nature" or "people," it returns identifiers like "landscape_mountain", "landscape_beach", "food_bread", "animal_cat", "animal_dog", "document", "screenshot", "selfie", and hundreds more. Each result comes with a confidence score between 0 and 1, and the framework returns all matching labels — not just the top one — so you could implement multi-label tagging if needed.

The Swift Bridge

Since Vision is a native Apple framework, there's no direct Python API. The solution is a tiny compiled Swift binary that accepts image paths as command-line arguments and writes results to stdout:

import Vision
import Foundation

for path in CommandLine.arguments.dropFirst() {
    let url = URL(fileURLWithPath: path)
    let handler = VNImageRequestHandler(url: url, options: [:])
    let request = VNClassifyImageRequest()
    do {
        try handler.perform([request])
        let top = request.results?
            .sorted { $0.confidence > $1.confidence }
            .first
        print("\(path)\t\(top?.identifier ?? "unknown")")
    } catch {
        print("\(path)\tunknown")
    }
}

Twenty lines. The entire classifier. The Python side calls this binary with all image paths at once (batch mode), parses the tab-separated stdout, and maps each file to its top label:

def classify_scenes(paths: list[Path]) -> dict[str, str]:
    result = {}
    if not CLASSIFIER_PATH.exists():
        for p in paths:
            result[str(p)] = "unknown"
        return result
    proc = subprocess.run(
        [str(CLASSIFIER_PATH)] + [str(p) for p in paths],
        capture_output=True, text=True, timeout=120,
    )
    for line in proc.stdout.strip().splitlines():
        path_str, label = line.split("\t", 1)
        result[path_str] = label
    return result

If the classify binary isn't compiled or you're running on Linux, it degrades gracefully — every image gets tagged "unknown" and the pipeline continues without scene labels.

Why Not Use a Python ML Model Instead?

You might wonder why I didn't just use a Python-native classifier like a pre-trained ResNet or EfficientNet via PyTorch or TensorFlow. A few reasons:

Zero dependency weight. PyTorch alone is ~2 GB. TensorFlow is similar. Adding a deep learning framework to classify photos in a lightweight CLI tool felt absurd when macOS ships with a classifier built in.
No model management. Pre-trained models need to be downloaded, versioned, and loaded into memory. The Vision framework's model is managed by the OS — it's always there, always up to date.
Apple-optimized inference. The Vision framework runs on the Apple Neural Engine (ANE) on Apple Silicon Macs, which is purpose-built for ML inference. A Python-based model would run on CPU (or require additional Metal/MPS setup for GPU), and would likely be slower for single-image classification despite the overhead of spawning a subprocess.
The taxonomy matches the use case. Vision's labels are designed for consumer photos — the exact domain I'm working in. A generic ImageNet classifier would give me "golden retriever" when I want "animal_dog", or "volcano" when I want "landscape_mountain". Apple's labels are practical, not academic.

The tradeoff is that this feature is macOS-only. If you need cross-platform scene classification, you'd swap in a Python model. But on a Mac, this is free performance with zero setup.

Pass 2: Downscale, Convert, and Save

The second pass loads each surviving (non-duplicate) image one at a time, processes it, and writes it out. This is the most I/O-intensive phase — each image is fully decoded, transformed, re-encoded as HEIC, and written to disk.

Step 1: Full Load and EXIF Transpose

The image is loaded at full resolution, then ImageOps.exif_transpose() physically rotates the pixel data to match the EXIF orientation tag. This is applied again here (it was also applied during hashing) because the hash pass only worked with thumbnails — now we need the full-resolution pixels in the correct orientation before saving.

Step 2: Downscale with Lanczos Resampling

If either dimension exceeds 1920 pixels, the image is scaled down proportionally:

MAX_DIMENSION = 1920

def downscale_if_needed(img: Image.Image) -> Image.Image:
    w, h = img.size
    if w <= MAX_DIMENSION and h <= MAX_DIMENSION:
        return img
    scale = MAX_DIMENSION / max(w, h)
    return img.resize((int(w * scale), int(h * scale)), Image.LANCZOS)

The choice of Image.LANCZOS is deliberate. Pillow offers several resampling filters, each implementing a different interpolation kernel — a mathematical function that determines how source pixels contribute to each output pixel when the image is resized:

NEAREST — Each output pixel takes the value of the single nearest source pixel. No blending, no smoothing. Fast but produces blocky, pixelated results. Only useful for pixel art or masks where you need hard edges.
BILINEAR — Linearly interpolates between the 4 nearest source pixels (2x2 grid). Smooth but slightly blurry. Good for speed-critical applications where quality is secondary.
BICUBIC — Uses a cubic polynomial to interpolate between the 16 nearest source pixels (4x4 grid). Sharper than bilinear, with a good balance of quality and speed. This is the default in many image tools.
LANCZOS — Uses a windowed sinc function (specifically, a sinc function multiplied by a Lanczos window) to interpolate using a larger neighborhood of source pixels. The sinc function is the mathematically "ideal" interpolation kernel — it perfectly reconstructs a band-limited signal from its samples (this is the Nyquist-Shannon sampling theorem). The Lanczos window truncates the infinite sinc to a practical size (3 lobes for Lanczos3, which is what Pillow uses).

The practical difference: Lanczos produces the sharpest downscales with the least aliasing. It preserves fine text, thin lines, and texture detail better than bicubic. The tradeoff is speed — Lanczos evaluates more source pixels per output pixel — but for a batch job that runs once, the quality advantage is worth it.

Why 1920 pixels? It's the horizontal resolution of 1080p — a reasonable maximum for photos that will be viewed on screens rather than printed. A 4032x3024 iPhone photo (12 megapixels) scaled to 1920x1440 goes from ~14 MB as JPEG to ~3 MB as HEIC, with negligible visible quality loss on any display smaller than a 27-inch 4K monitor.

Step 3: Convert to HEIC

The image is saved in HEIF format via pillow-heif. RGBA and palette-mode images are first converted to RGB, since HEIF's alpha channel support isn't universally handled by decoders:

def save_as_heic(img: Image.Image, output_path: Path) -> None:
    if img.mode in ("RGBA", "P"):
        img = img.convert("RGB")
    img.save(output_path, format="HEIF")

This is where the bulk of the processing time goes. HEVC encoding is computationally expensive — the encoder needs to evaluate multiple block sizes, run intra-prediction in 35 modes, and perform CABAC entropy coding. For my 2,700 surviving images, this step alone accounted for the majority of the one-hour runtime.

Step 4: Filename Generation

Each output file is named with a structured, machine-sortable scheme:

{yyyymmdd}-{hhmmss}-{WxH}-{scene}.heic

The date and time come from the EXIF DateTime tag (tag 0x0132). If EXIF data is missing (screenshots, downloaded images), it falls back to the file's mtime. Collision suffixes (-1 through -99) handle images taken in the same second.

This naming scheme means the output folder is automatically sorted chronologically with a plain ls. The embedded resolution and scene label make it trivially searchable — find all food photos, or all documents, or everything shot at full resolution.

Deep Dive: HEIC — The Format That Replaced JPEG (On Apple, At Least)

JPEG: Thirty Years of Dominance

To appreciate HEIC, you need to understand what it replaced and why it took so long.

JPEG was standardized in 1992 by the Joint Photographic Experts Group (which is what JPEG stands for — it's a committee name, not a technical acronym). It was revolutionary: the first practical lossy image compression format. JPEG made digital photography possible on hardware with kilobytes of RAM by applying an 8x8 block DCT (Discrete Cosine Transform), quantizing the coefficients (this is the lossy step — fine detail is discarded), and encoding the result with Huffman coding.

For over three decades, JPEG was the photo format. Not because nothing better was invented — better algorithms existed by the early 2000s — but because ecosystem lock-in is extraordinarily powerful. Every camera wrote JPEG. Every browser rendered JPEG. Every image editor opened JPEG. Every social media platform accepted JPEG. Replacing it meant getting hardware manufacturers, OS vendors, browser developers, and app developers to all move simultaneously. Nobody wanted to go first.

The Long Search for a Successor

The industry tried, repeatedly, to replace JPEG:

JPEG 2000 (2000) — Used wavelet transforms instead of DCT, producing dramatically better quality at low bitrates. Adopted in professional workflows (digital cinema, medical imaging, satellite imagery) but never gained consumer traction because it was computationally expensive and the patent licensing was complex. Your digital cinema projector uses JPEG 2000; your phone never will.
WebP (2010) — Google's answer, based on the VP8 video codec's intra-frame coding. It offered ~30% smaller files than JPEG and added transparency and animation support (replacing both JPEG and GIF in one format). Chrome supported it immediately, Firefox and Safari dragged their feet for years. Safari didn't add WebP support until 2020 — a full decade after the format launched. WebP achieved significant adoption on the web but never became a camera output format.
HEIC (2015) — The subject of this section. Based on HEVC (H.265), offering ~50% compression improvement over JPEG.
AVIF (2019) — Based on the AV1 video codec, developed by the Alliance for Open Media (Amazon, Google, Meta, Microsoft, Netflix, and others). AVIF matches or exceeds HEIC's compression while being royalty-free — a direct response to HEVC's patent licensing mess. Browser support arrived relatively quickly (Chrome 2020, Firefox 2021, Safari 2023). AVIF is arguably the strongest long-term contender to become the universal photo format, but adoption is still early.
JPEG XL (2021) — The "official" JPEG successor from the same standards body. Technically impressive: lossless recompression of existing JPEG files (shrink JPEGs by ~20% with zero quality loss), progressive decoding, HDR support, and competitive lossy compression. But it arrived late to a crowded field, and Google controversially removed JPEG XL support from Chrome in 2023, dealing a significant blow to web adoption. Its future remains uncertain.

Each of these formats is technically superior to JPEG. The reason JPEG persists isn't technical — it's that no single entity controls enough of the ecosystem to force a migration. Apple came closest.

Apple's Gambit

The real inflection point came in 2017, when Apple adopted HEIC as the default photo format in iOS 11 and macOS High Sierra. Overnight, every new iPhone photo was being saved as HEIC instead of JPEG. This wasn't a gentle opt-in — it was a system-wide default change affecting hundreds of millions of devices.

Apple's motivation was straightforward: HEIC files are roughly half the size of equivalent JPEGs. With over a billion active Apple devices backing up photos to iCloud, halving the storage footprint translated directly into infrastructure savings — and into users hitting their "iCloud storage full" warnings less frequently. Apple also benefited from HEIC's container features: Live Photos (a still image paired with a short video clip) fit naturally into HEIF's multi-image container model, as did depth maps from dual-camera iPhones.

The strategy worked, partially. Within Apple's ecosystem, HEIC became ubiquitous. But the rest of the industry adopted it grudgingly and slowly, in part because of the format it's built on.

Why HEIC is Technically Superior

HEIC's compression advantage comes from HEVC's more modern toolbox compared to JPEG:

Feature	JPEG	HEIC (HEVC)
Block size	Fixed 8x8	Adaptive, up to 64x64 (CTU)
Transform	DCT only	DCT + DST, multiple sizes
Prediction	None (intra only, no prediction)	35 intra-prediction modes
Entropy coding	Huffman	CABAC (context-adaptive binary arithmetic coding)
Color depth	8-bit	8-bit, 10-bit, 12-bit
Transparency	Not supported	Alpha channel support
Multiple images	Not supported	Image sequences, thumbnails, depth maps in one file

The adaptive block sizes are particularly important for photos. JPEG chops every image into rigid 8x8 blocks, which is why you see those characteristic "blockiness" artifacts at low quality settings. HEVC can use blocks ranging from 8x8 up to 64x64, choosing the optimal size per region — large blocks for smooth skies, small blocks for fine texture. This alone accounts for a significant chunk of the compression improvement.

The Patent Problem

HEIC's biggest obstacle has never been technical — it's licensing. HEVC, the codec underneath HEIC, is covered by patents held by three separate patent pools: MPEG-LA, HEVC Advance, and Velos Media. Each pool demands its own royalty payments, and the terms are different for each. For a company shipping a browser or an OS, this means negotiating with three different entities just to decode a photo format. The total cost per device is small, but the legal complexity is enormous — and the uncertainty about future licensing terms made many companies hesitant to commit.

This licensing tangle is the primary reason HEIC hasn't achieved universal adoption, and it's a direct cautionary tale about how patent encumbrance can stifle a technically superior standard. It's also the main reason the Alliance for Open Media created AV1 (and by extension, AVIF) as a royalty-free alternative — the major tech companies collectively decided that the future of media codecs shouldn't be gated by patent pools.

The Compatibility Landscape

The practical result of the patent situation is a fragmented adoption timeline:

macOS / iOS: Full native support since 2017. Every Apple app reads and writes HEIC. AirDrop, iMessage, and iCloud all preserve the format. When you share a HEIC photo to a non-Apple platform, iOS silently converts to JPEG — most users never realize their photos aren't JPEG.
Windows: Read support arrived in Windows 10 version 1803 (2018), but required a free "HEIF Image Extensions" download from the Microsoft Store. The encoding extension costs $0.99 — presumably to cover HEVC patent royalties. This one-dollar paywall is a minor annoyance but a major signal about how licensing friction trickles down to users.
Android: Read support since Android 9 (2018). Some Samsung and Google Pixel phones offer HEIC as a camera option, but JPEG remains the default on the vast majority of Android devices. The Android ecosystem's fragmentation (thousands of device models, multiple camera apps) makes a format transition harder than Apple's top-down approach.
Web browsers: This is where it hurts most. Chrome didn't add HEIC support until 2024 — seven years after Apple adopted the format. Firefox still relies on OS-level codec support rather than bundling its own decoder, meaning HEIC works on macOS Firefox but not Linux Firefox. Safari, naturally, has supported it since day one. The web's slow adoption means you can't reliably use HEIC for web images — if you're building a website, JPEG, WebP, or AVIF remain the safe choices.
Social media / messaging: Instagram, WhatsApp, and Telegram all accept HEIC uploads but transcode to JPEG internally. Twitter/X does the same. The format never reaches the viewer.

For a personal archive that stays on a Mac — which is exactly my use case — none of these compatibility issues matter. Every tool in the chain understands HEIC natively. But it's worth understanding why "just use HEIC everywhere" isn't viable advice for the broader world.

HEIC in Python

The Python ecosystem's HEIC support is handled by pillow-heif, which wraps the libheif C library. It integrates with Pillow as a plugin — one call to register_heif_opener() and Pillow transparently handles .heic files in both directions:

from pillow_heif import register_heif_opener
register_heif_opener()

# Reading: Image.open() now handles .heic transparently
img = Image.open("photo.heic")

# Writing: save as HEIF format
# RGBA/palette images must be converted to RGB first — HEIF's alpha
# support exists but isn't universally handled by all decoders
if img.mode in ("RGBA", "P"):
    img = img.convert("RGB")
img.save("output.heic", format="HEIF")

Under the hood, pillow-heif ships pre-built wheels with libheif statically linked, so there's no system dependency to install. This is a big deal — before pillow-heif matured around 2022, working with HEIC in Python meant wrestling with pyheif, which required manually compiling libheif and libde265 from source.

Deep Dive: `uv` — How a Rust Rewrite Changed Python Packaging

The Problem `uv` Solved

Python's packaging story has been, to put it diplomatically, a journey. To understand why uv was so enthusiastically adopted, you need to understand the landscape it replaced.

The early days (2000s): Python packages were installed with distutils (part of the standard library) and later setuptools, using the setup.py file as both configuration and build script. There was no dependency resolver — easy_install would download packages from PyPI and hope for the best. If two packages needed conflicting versions of the same dependency, you found out at runtime.

The pip era (2008-2020s): pip replaced easy_install as the standard installer and brought real dependency resolution. Combined with virtualenv (later python -m venv), you could isolate projects from each other. The workflow became:

python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt   # hope nothing conflicts
pip freeze > requirements.txt     # hope nothing drifts

This worked, but had fundamental limitations. requirements.txt is a flat list of pinned versions with no distinction between direct and transitive dependencies. There's no lock file. There's no way to reproduce the exact dependency tree on a different platform. pip resolves dependencies in Python, downloads packages sequentially, and doesn't cache aggressively. On a project with native dependencies like Pillow (which ships platform-specific binary wheels) and NumPy, a clean pip install can take 30+ seconds.

The "alternatives" era (2016-2023): The community built increasingly sophisticated tools on top of pip:

pipenv (2017) — Kenneth Reitz's attempt at a Pipfile/Pipfile.lock workflow, inspired by Bundler (Ruby) and npm (JavaScript). It combined virtualenv management and dependency locking into one tool. It gained momentum quickly but became notorious for slow lock times and confusing error messages. Development stalled for extended periods.
poetry (2018) — Sebastien Eustace's take, using pyproject.toml for configuration and a custom dependency resolver. Poetry was a significant step forward: proper lock files, clean CLI, and separation of direct vs. transitive dependencies. It became the de facto choice for serious Python projects. But it was still written in Python, still slow to resolve, and sometimes produced resolution conflicts that were hard to debug.
pip-tools — A simpler approach: pip-compile reads a requirements.in file and produces a fully pinned requirements.txt. Lightweight and composable, but still required manual virtualenv management and sequential installs.
pdm, hatch, flit — More alternatives, each with slightly different philosophies. The fragmentation itself became a running joke in the Python community. "How do I set up a Python project?" had a different answer depending on who you asked and what year it was.

All of these tools shared a fundamental performance ceiling: they were written in Python, running interpreted code to resolve dependency graphs and orchestrate installations. They were fast enough for small projects, but on anything with a deep dependency tree or native extensions, you'd sit and wait.

Enter Astral

The breakthrough came from outside the Python-in-Python tooling world entirely.

In 2022, Charlie Marsh released ruff, a Python linter written in Rust. Ruff wasn't just incrementally faster than existing linters like flake8 and pylint — it was 10-100x faster, fast enough to lint entire codebases in milliseconds. It proved a thesis: rewriting Python developer tools in Rust could produce not just a marginal improvement but a categorically different experience.

Marsh founded Astral to pursue this thesis commercially, raised funding, and in February 2024 released uv — a Python package installer and resolver written in Rust, designed as a drop-in replacement for pip and pip-tools.

The initial benchmarks were staggering. uv resolved and installed dependencies 10-100x faster than pip. Not on contrived benchmarks — on real-world projects with real dependency trees. Projects that took pip 30+ seconds to install completed in under a second with uv. The speedup comes from several architectural decisions:

Rust-native dependency resolution — the resolver runs in compiled, multithreaded Rust instead of interpreted Python. Dependency resolution is a constraint-satisfaction problem that involves repeated network requests and version comparisons — exactly the kind of workload where compiled code with proper concurrency thrashes an interpreted language.
Parallel downloads — packages are fetched concurrently, saturating network bandwidth instead of downloading one wheel at a time.
Global cache with hard links — uv maintains a global package cache (~/.cache/uv/) and uses hard links to "install" packages into project virtualenvs. This means the second project that uses Pillow doesn't download or copy anything — it creates hard links to the already-cached wheel in microseconds.
Pre-built wheel preference — uv strongly prefers binary wheels over source distributions, avoiding compilation where possible. For packages like NumPy that ship platform-specific wheels, this eliminates the need for a C compiler entirely.

But speed alone didn't make uv ubiquitous. What sealed it was scope creep — the good kind. Over the course of 2024, uv expanded from a pip replacement into a complete Python project manager:

uv init — scaffolds a new project with a pyproject.toml
uv add / uv remove — manages dependencies declaratively (like npm install <package>)
uv sync — installs all dependencies from the lock file, creating the venv if needed
uv run — executes a command inside the project's venv without manual activation
uv python install — installs Python interpreters themselves, eliminating the need for pyenv or asdf
uv lock — generates a cross-platform lock file (uv.lock) with deterministic resolution
uv tool — installs and runs CLI tools in isolated environments (like pipx)

By late 2024, uv had effectively replaced pip, pip-tools, virtualenv, pyenv, poetry, and pipx — six separate tools — with a single, fast, static binary. The Python community, exhausted by years of tooling fragmentation, adopted it at remarkable speed. The GitHub repo crossed 40,000 stars within its first year. Conference talks stopped debating "pip vs. poetry vs. pipenv" and started asking "have you switched to uv yet?"

The broader impact is worth noting: uv and ruff together demonstrated that Python's tooling didn't have to be slow and fragmented. The problem was never Python-the-language — it was that the tools were written in Python-the-implementation. Rust gave the ecosystem a way to keep the Python developer experience while getting compiled-language performance where it mattered most.

`uv` in This Project

My pyproject.toml declares the project metadata and dependencies in standard PEP 621 format:

[project]
name = "image-processor"
version = "0.1.0"
requires-python = ">=3.14"
dependencies = [
    "imagehash>=4.3.2",
    "numpy>=2.0",
    "pillow>=12.2.0",
    "pillow-heif>=1.3.0",
]

From here, the entire workflow is two commands:

uv sync       # resolve, lock, create venv, install — all in ~2 seconds (warm cache)
uv run python src/batch-image-processor.py input/ output/

No source .venv/bin/activate. No pip install -r requirements.txt. No wondering which Python version is on PATH. uv run finds the project's venv (creating it if necessary), ensures dependencies are in sync, and executes the command — all transparently. It's the kind of developer experience that, once you've used it, makes going back to the old workflow feel like dial-up.

More Code: The Pieces That Tie It Together

A few more snippets that show how the pipeline handles the tricky details.

EXIF Date Extraction with Fallback

Every output file is named with a timestamp, but not every input image has EXIF data. Screenshots, downloaded memes, images stripped by messaging apps — these have no embedded DateTime. The fallback is the file's modification time:

def get_exif_datetime(path: Path) -> tuple[str, str]:
    """Return (yyyymmdd, hhmmss) from EXIF DateTime, or fallback to file mtime."""
    try:
        with Image.open(path) as img:
            exif = img.getexif()
            dt_str = exif.get(0x0132)  # EXIF DateTime tag
            if dt_str:
                date_part, time_part = dt_str.split(" ")
                return date_part.replace(":", ""), time_part.replace(":", "")
    except Exception:
        pass
    mtime = datetime.fromtimestamp(path.stat().st_mtime)
    return mtime.strftime("%Y%m%d"), mtime.strftime("%H%M%S")

Tag 0x0132 is the standard EXIF DateTime field, stored as a string in the format "2019:07:14 18:23:05". The colons in the date portion get replaced to produce 20190714, and the time becomes 182305. This gives filenames that sort chronologically with a plain ls.

Collision-Safe Output Naming

When two photos share the same timestamp (burst mode, or photos taken within the same second on different cameras), the output filename would collide. The pipeline handles this by appending suffixes:

def unique_output_path(output_dir: Path, filename: str) -> Path:
    stem = Path(filename).stem
    dest = output_dir / filename
    if not dest.exists():
        return dest
    for i in range(1, 100):
        dest = output_dir / f"{stem}-{i}.heic"
        if not dest.exists():
            return dest
    return output_dir / f"{stem}-99.heic"

So a burst of sunset photos might produce 20190714-182305-1920x1080-landscape.heic, followed by 20190714-182305-1920x1080-landscape-1.heic, -2, and so on. Simple, predictable, no UUID noise.

Results

I pointed the tool at my full archive of 5,700 images and let it run on a MacBook laptop. Here's what came out the other side:

Metric	Value
Input images	5,700
Output images (after dedup)	~2,700
Duplicates removed	~3,000 (burst shots, messaging app copies, iCloud sync artifacts, re-saves)
Processing time	~1 hour on a MacBook
Scene labels applied	every surviving image tagged automatically

More than half of my archive was duplicates. That number surprised me at first, but it makes sense once you think about how photos accumulate: every burst-mode sequence contributes 5-10 near-identical frames. Every photo shared over WhatsApp or Telegram gets re-saved as a lower-resolution copy. Every iCloud sync hiccup creates a IMG_1234 (1).jpg. Over fifteen years, these copies compound silently.

The one-hour runtime on a laptop is dominated by two things: the HEIC encoding in Pass 2 (HEVC compression is CPU-intensive) and the perceptual hashing in Pass 1 (each image must be decoded and DCT-transformed). On a desktop Mac with more thermal headroom, this would be significantly faster — but for a one-time archive job, an hour is perfectly fine. I started it, made coffee, and came back to a clean folder.

The output is a single flat directory of consistently named, deduplicated, reasonably sized HEIC files:

20090315-143022-1920x1440-landscape_mountain.heic
20090315-143024-1920x1440-landscape_mountain-1.heic
20110801-092117-1280x960-food.heic
20130412-181503-1920x1080-document.heic
20170625-200841-1920x1440-animal_cat.heic
...

Fifteen years of photo chaos, reduced to a browsable, searchable, chronologically sorted archive. No manual sorting. No cloud upload. Just a Python script, a Swift one-liner, and a Saturday morning.

Building Digital Garden with Astro

Sun, 20 Apr 2025 00:00:00 GMT

I've wanted a personal space on the internet for a while. Not a social media profile, not a portfolio template — something that feels like mine. A place where I can write about things I'm learning, trails I've hiked, meals I've cooked, and the occasional parenting revelation. A digital garden, if you will.

This is the story of how Digital Garden came to be, and why I chose Astro to build it.

Why a static site?

Before picking any framework, I had to answer a more basic question: what kind of site do I actually need?

The answer was simple. I write content in Markdown. The content doesn't change between visits. There's no user authentication, no database, no shopping cart. Every visitor sees the same thing. This is a textbook case for a static site generator — take some Markdown files, run them through a build step, and output plain HTML, CSS, and a sprinkle of JavaScript.

Static sites are fast. They're cheap to host (often free). They're secure by default because there's no server to compromise. And they age well — a static HTML file from 2005 still works perfectly today.

So: static site generator it is. But which one?

The landscape

There's no shortage of options. I've looked at quite a few over the years:

Jekyll was the original GitHub Pages darling. Ruby-based, mature, battle-tested. But the Ruby ecosystem felt like friction I didn't want — managing gems, dealing with version conflicts. It also hasn't evolved much in recent years.

Hugo is blazingly fast and written in Go. Its build times are legendary. But its templating language always felt unintuitive to me. The learning curve for anything beyond basic layouts is steep, and the documentation assumes a lot of prior context.

Next.js is powerful, but it's a full React framework. For a content-driven blog with zero interactivity requirements, it felt like bringing a forklift to move a chair. The build output ships React runtime code to the browser even when you don't need it. Server components in Next.js 13+ help with this, but the complexity budget is high.

Gatsby was once the go-to React static site generator, but it's effectively in maintenance mode now. The GraphQL data layer was clever but added cognitive overhead for simple use cases.

11ty (Eleventy) is wonderful — lightweight, flexible, JavaScript-based. It was my runner-up. But I wanted something with first-class TypeScript support and a more opinionated project structure out of the box.

And then there's Astro.

What is Astro?

Astro is a web framework designed for content-driven websites. It was created by Fred K. Schott and the team behind Snowpack (an early ES modules-based build tool). The first public release came in mid-2021, and it's been on a remarkable trajectory since.

The core philosophy is simple: ship less JavaScript. By default, Astro sends zero JavaScript to the browser. Your pages are rendered entirely to static HTML at build time. When you do need interactivity — a theme toggle, a search modal — you opt in explicitly.

This is what the Astro team calls the Islands Architecture. The page is a sea of static HTML, and interactive components are isolated "islands" that hydrate independently. You can even choose when an island hydrates: on page load, when it becomes visible, when the browser is idle, or only on certain media queries.

A brief history

2021 — Astro launches publicly. The pitch: a static site builder that lets you use any UI framework (React, Vue, Svelte, Solid) but ships zero client JavaScript by default.
2022 — Astro 1.0 releases. Content Collections arrive, giving Markdown and MDX files type-safe schemas.
2023 — Astro 2.0 and 3.0 bring hybrid rendering (mix static and server-rendered pages), View Transitions for SPA-like navigation, and image optimisation built in.
2024 — Astro 4.0 and 5.0 introduce the Content Layer API (a unified way to source content from files, APIs, or CMSs) and significant performance improvements.
2025 — Astro 6.0 lands with even more refinements. This site runs on Astro 6.

What stands out is the pace of iteration without breaking changes. Each major version has felt like a natural evolution rather than a rewrite.

Why I chose Astro

A few things tipped the scale:

Content Collections are brilliant

Astro treats content as a first-class concept. I define a schema for my blog posts using Zod:

schema: ({ image }) =>
  z.object({
    title: z.string(),
    description: z.string(),
    pubDate: z.coerce.date(),
    updatedDate: z.coerce.date().optional(),
    heroImage: z.optional(image()),
    tags: z.array(z.string()).default([]),
  }),

If I forget a required field in a post's frontmatter, the build fails with a clear error. If I pass a string where a date is expected, TypeScript catches it. The content is validated, typed, and queryable — getCollection('blog') returns fully typed data I can sort, filter, and render with confidence.

File-based routing that makes sense

Every .astro file in src/pages/ becomes a route. src/pages/blog/index.astro becomes /blog/. Dynamic routes use bracket syntax: src/pages/blog/[...slug].astro generates a page for each blog post. No routing configuration file, no magic — just files in folders.

The `.astro` component format

Astro has its own component format, and it's one of my favourite things about the framework. The frontmatter fence (---) at the top is server-side JavaScript/TypeScript that runs at build time. Everything below is your template:

---
// This runs at build time — fetch data, import components, compute values
const posts = await getCollection('blog');
const sorted = posts.sort((a, b) => b.data.pubDate.valueOf() - a.data.pubDate.valueOf());
---

<!-- This is the HTML template -->
<ul>
  {sorted.map(post => (
    <li><a href={`/blog/${post.id}/`}>{post.data.title}</a></li>
  ))}
</ul>

<style>
  /* Scoped styles — only affect this component */
  ul { list-style: none; }
</style>

No useState, no useEffect, no lifecycle methods. It's just data fetching at the top and HTML at the bottom. Styles are scoped by default. It feels like writing HTML with superpowers.

Zero JavaScript by default

The theme toggle and search modal on this site need JavaScript, so those bits are explicitly interactive. Everything else — the blog listing, the post rendering, the RSS feed, the image optimisation — is pure static HTML. The result is fast page loads and excellent Lighthouse scores without any performance tuning.

How the site is structured

I settled on a folder-per-post structure for blog content:

src/content/blog/
  building-digital-mind-with-astro/
    index.md          ← the post you're reading
  first-post/
    index.md
    hero.jpg          ← colocated assets
  markdown-style-guide/
    index.md
    hero.jpg

Each post lives in its own folder. The folder name becomes the URL slug. Images and other assets sit alongside the Markdown file they belong to. No hunting through a shared images/ directory wondering which file belongs to which post.

The site generates a few things automatically at build time:

RSS feed with full post content at /rss.xml
Sitemap at /sitemap-index.xml
Search index via Pagefind, with a search modal accessible from any page
Optimised images via Sharp — responsive sizes, modern formats like WebP
Tag pages at /blog/tags/tech/, /blog/tags/writing/, etc.

Features I'm happy with

Dark mode that respects system preference and remembers your choice. The theme initialises before first paint to avoid the dreaded flash of wrong theme.

Reading time estimates calculated from word count, shown on the blog listing and individual posts.

Table of contents auto-generated from headings, collapsible so it doesn't dominate shorter posts.

Full-text search powered by Pagefind. It indexes the static HTML at build time and runs entirely client-side — no server, no external service. The search modal opens with Cmd+K.

Translation support via Google Translate for Simplified and Traditional Chinese readers. Not as good as hand-written translations, but it makes the content accessible to a much wider audience with zero ongoing effort.

Code blocks with copy buttons that appear on hover. Small touch, but useful for a tech blog.

What I'd tell someone starting today

If you're building a content-driven site — a blog, documentation, a marketing page, a digital garden — Astro is worth a serious look. The learning curve is gentle if you know HTML, CSS, and a bit of JavaScript. The documentation is excellent. The community is active and helpful.

Start with the blog template (npm create astro@latest -- --template blog), strip out what you don't need, and build up from there. Write your content in Markdown, let Astro handle the rest.

The framework gets out of your way and lets you focus on what matters: the writing.

Change Your Diet, Change Your Mind — What We Eat Shapes How We Think

Sun, 03 May 2026 00:00:00 GMT

I'm currently reading Change Your Diet, Change Your Mind by Dr. Georgia Ede, and it's one of those books that makes you look at your lunch differently. The central argument is bold but increasingly well-supported: what you eat doesn't just affect your body — it fundamentally shapes your brain chemistry, your mood, your ability to focus, and your risk of mental illness.

This isn't a diet book in the usual sense. There are no meal plans, no calorie counts, no before-and-after photos. Instead, it's a deep dive into the emerging field of nutritional psychiatry — the science of how food affects the brain — written by a psychiatrist who spent two decades watching her patients improve (or deteriorate) based on what they ate.

Who Is Dr. Georgia Ede?

Georgia Ede, MD is a psychiatrist who has spent her career at the intersection of nutrition and mental health. She graduated from the University of Vermont College of Medicine and completed her psychiatry residency at Cambridge Health Alliance, a Harvard Medical School teaching hospital. She practiced psychiatry at Harvard University Health Services for years, treating students and staff at one of the world's most demanding academic institutions.

What sets Ede apart from most psychiatrists is that she didn't stay in the medication-first lane. Early in her career, she noticed a pattern that mainstream psychiatry wasn't paying much attention to: patients who changed their diets often reported improvements in mood, anxiety, focus, and cognitive clarity — sometimes dramatic improvements that medication hadn't achieved.

This observation sent her down a research path that eventually consumed her practice. She became one of the few psychiatrists in the world to specialise in nutritional and metabolic psychiatry, studying how dietary patterns influence brain function at the cellular level. She's given grand rounds at Harvard, presented at medical conferences internationally, and runs a website called diagnosisdiet.com where she translates nutritional research for a general audience.

Change Your Diet, Change Your Mind, published in 2024, is the culmination of years of clinical observation and literature review. It's her case to the medical profession and the public that we've been neglecting the most powerful tool we have for brain health: food.

The Core Argument

The book's thesis can be distilled to a few connected ideas:

1. The Brain Is a Metabolic Organ

We tend to think of the brain as a computer — a processor of information, running on abstract "thoughts." Ede argues that this metaphor has led medicine astray. The brain is, first and foremost, a biological organ with intense metabolic demands.

The numbers are striking:

The brain is roughly 2% of your body weight but consumes about 20% of your energy at rest.
It requires a constant supply of fuel, oxygen, and micronutrients to function.
Every neurotransmitter — serotonin, dopamine, GABA, norepinephrine — is built from dietary precursors. Your brain literally cannot manufacture the chemicals that regulate your mood without the right raw materials.

If you fed a car the wrong fuel, you wouldn't be surprised when it ran poorly. Yet we routinely feed our brains a diet they weren't designed for and then wonder why rates of depression, anxiety, ADHD, and cognitive decline keep rising.

2. The Modern Diet Is Damaging Our Brains

Ede identifies several features of the modern Western diet that she argues are particularly harmful to brain function:

Refined carbohydrates and sugar. The average person today consumes vastly more sugar and refined carbohydrates than any previous generation in human history. Ede presents evidence that chronic high blood sugar and the resulting insulin resistance don't just affect the pancreas — they damage the brain. She points to research linking insulin resistance to inflammation in the brain, impaired neurotransmitter signalling, and an increased risk of Alzheimer's disease (which some researchers have started calling "Type 3 diabetes").

Seed oils and industrial fats. Vegetable oils high in omega-6 fatty acids (soybean oil, corn oil, canola oil, sunflower oil) are a relatively recent addition to the human diet, introduced at scale only in the 20th century. Ede argues that the dramatic shift in the omega-6 to omega-3 ratio in modern diets promotes chronic inflammation — including neuroinflammation — and that this inflammatory state contributes to depression, anxiety, and cognitive impairment.

Ultra-processed foods. Foods engineered in factories with long ingredient lists of emulsifiers, preservatives, artificial colours, and flavour enhancers make up the majority of calories consumed in many Western countries. Ede reviews evidence suggesting that ultra-processed food consumption correlates with higher rates of depression and anxiety, independent of the specific nutrients involved. The processing itself — the chemical additives, the destruction of food's natural structure — may be part of the problem.

Plant anti-nutrients. This is perhaps Ede's most controversial position. She argues that many plant foods contain compounds — oxalates, lectins, phytates, goitrogens, and others — that can interfere with nutrient absorption or cause inflammation in susceptible individuals. She doesn't argue that all plants are harmful for all people, but she challenges the blanket assumption that "more plants is always better" and suggests that some people's mental health issues improve when they reduce or eliminate certain plant foods.

3. Food Affects Every Brain Pathway That Matters

Ede organises the book around five key brain processes, each of which is directly influenced by diet:

Inflammation. Chronic, low-grade inflammation in the brain — neuroinflammation — is increasingly linked to depression, anxiety, bipolar disorder, and schizophrenia. Certain foods (sugar, refined carbohydrates, seed oils, ultra-processed foods) promote inflammation, while others (omega-3 fatty acids, antioxidant-rich whole foods) help resolve it.

Oxidative stress. The brain's high metabolic rate produces large amounts of reactive oxygen species (free radicals). When the body's antioxidant defences can't keep up, oxidative stress damages neurons. Ede discusses how nutrient-dense foods provide the raw materials for antioxidant enzymes (zinc, selenium, copper, manganese), while nutrient-poor processed foods leave the brain undefended.

Insulin resistance. When cells become resistant to insulin's signal — typically from chronic overconsumption of sugar and refined carbohydrates — the brain's energy supply is compromised. Neurons struggle to take in glucose efficiently, leading to what Ede describes as a "brain energy crisis." She presents research suggesting that insulin resistance is a common feature of depression, ADHD, and Alzheimer's disease.

Nutrient deficiency. Modern diets, even when they contain enough calories, are often deficient in key nutrients the brain needs: B vitamins (especially B12 and folate), iron, zinc, magnesium, vitamin D, and omega-3 fatty acids. These aren't obscure micronutrients — they're essential cofactors in neurotransmitter synthesis, myelination, and neuronal energy production. Ede argues that subclinical deficiencies (not severe enough to produce a diagnosable disease, but enough to impair optimal function) are far more common than most doctors recognise.

Gut-brain connection. The gut microbiome — the trillions of bacteria living in your intestinal tract — communicates with the brain via the vagus nerve, immune signalling, and microbial metabolites. What you eat shapes which bacteria thrive, and those bacteria in turn produce neurotransmitters, inflammatory molecules, and other compounds that directly affect brain function. Ede reviews research on how dietary changes alter the microbiome within days, and how those microbial shifts correlate with changes in mood and cognition.

The Dietary Approaches

Ede doesn't prescribe a single diet. Instead, she presents a spectrum of dietary approaches, roughly ordered from least to most restrictive, and argues that different people may need different levels of intervention depending on their metabolic health and symptoms:

Whole Foods First

The least controversial recommendation: replace ultra-processed foods with whole, minimally processed foods. This alone, Ede argues, would make a meaningful difference for most people. It reduces added sugar, eliminates industrial seed oils and chemical additives, and increases nutrient density. She notes that this is consistent with virtually every dietary tradition — Mediterranean, Japanese, traditional African and South American diets — all of which are based on whole foods and all of which are associated with lower rates of mental illness than the modern Western diet.

Low-Carbohydrate and Ketogenic Diets

For people with significant insulin resistance, metabolic syndrome, or treatment-resistant mental health conditions, Ede presents evidence for low-carbohydrate and ketogenic diets. The ketogenic diet — very low in carbohydrates, moderate in protein, high in fat — forces the body to burn fat for fuel, producing ketone bodies that the brain can use as an alternative energy source.

Ede's interest in ketogenic diets for mental health isn't fringe. The ketogenic diet has been used to treat epilepsy since the 1920s — it's one of the oldest therapeutic diets in medicine. Recent research has extended this to other brain conditions:

Clinical trials at Stanford, Harvard, and other institutions are studying ketogenic diets for bipolar disorder and schizophrenia, with early results showing significant symptom reduction in some patients.
Researchers are investigating ketogenic diets for Alzheimer's disease, based on the theory that Alzheimer's involves impaired glucose metabolism in the brain, and that ketones can bypass this metabolic block.
Small studies have shown improvements in depression and anxiety symptoms on ketogenic diets, though large-scale randomised controlled trials are still in progress.

Ede is careful to note that a ketogenic diet is a medical intervention, not a casual lifestyle choice, and that it should be undertaken with professional guidance — especially for people on psychiatric medications, since dietary changes can alter medication metabolism.

Animal-Based and Carnivore Diets

At the most restrictive end of the spectrum, Ede discusses animal-based diets — diets that emphasise or are limited to animal products (meat, fish, eggs, dairy). This is the most controversial section of the book and the one most likely to provoke strong reactions.

Her argument is not that everyone should eat this way, but that for a subset of people — particularly those with autoimmune conditions, severe food sensitivities, or mental health conditions that haven't responded to other interventions — removing plant foods eliminates potential sources of inflammation and anti-nutrients. She presents case studies and anecdotal evidence from patients who saw dramatic improvements in mood, anxiety, and cognitive function after adopting an animal-based diet.

She acknowledges that this approach lacks large-scale clinical trial evidence and that it contradicts mainstream nutritional guidance. Her position is that the absence of evidence is not evidence of absence, and that individual clinical response matters.

Key Takeaways

A few things from the book that have stuck with me:

Mental health treatment has a blind spot. The standard psychiatric approach — therapy plus medication — doesn't ask what the patient is eating. Ede argues that this is like treating a plant disease without checking the soil. For some patients, dietary change may be as effective as medication, with fewer side effects. For others, it may enhance the effectiveness of medication they're already taking.

The brain is not immune to what you eat. This sounds obvious when stated plainly, but it runs counter to how we've been trained to think. We accept that diet affects heart disease, diabetes, and obesity, but we've been slow to apply the same logic to the brain — even though the brain is the most metabolically demanding organ in the body.

Ultra-processed food is the low-hanging fruit. You don't need to go keto or carnivore to benefit from the book's insights. Simply replacing ultra-processed foods with whole foods — cooking more, reading ingredient lists, choosing fewer packaged products — is a meaningful intervention that's consistent with every nutritional tradition and has essentially no downside.

Everyone's different. One of the book's strengths is its refusal to prescribe a one-size-fits-all diet. Ede repeatedly emphasises that individual variation — in genetics, gut microbiome, metabolic health, food sensitivities — means that the optimal diet for brain health differs from person to person. What works for one person may not work for another, and self-experimentation (ideally with medical guidance) is part of the process.

Nutrition science is still young. Ede is honest about the limitations of the evidence. Much of nutritional psychiatry is based on observational studies, case reports, and small clinical trials. The large-scale randomised controlled trials that would settle many debates are expensive, difficult to run (you can't blind people to what they're eating), and often unfunded because there's no pharmaceutical product to sell at the end. This doesn't mean the evidence is worthless — it means it's incomplete, and that intellectual humility is warranted.

What I'm Taking From It

I'm not finished with the book yet, but it's already changed how I think about the connection between what I eat and how I feel. The most actionable shift for me has been paying attention to the correlation between my diet on a given day and my mental clarity, mood, and energy levels the next day. It's the kind of thing you don't notice until someone tells you to look for it — and then you can't stop noticing.

I'm not planning to go carnivore. But I am cooking more, eating fewer packaged foods, and paying closer attention to ingredient lists. If Ede's core argument is right — that the modern diet is silently undermining our brain function — then those small changes might matter more than they seem.

Whether or not you agree with every position in the book, Change Your Diet, Change Your Mind makes a compelling case that nutrition deserves a seat at the table in mental health treatment. It's a conversation the field is only beginning to have, and Ede is one of its most articulate voices.

Cloudflare WARP — The Free VPN That Isn't Really a VPN

Wed, 06 May 2026 00:00:00 GMT

I've been running Cloudflare WARP on my phone and laptop for a while now. It's free, it's fast, and it just works — I flip a switch and my traffic is encrypted through Cloudflare's network. No account required for the basic tier, no bandwidth caps, no ads. Which naturally made me wonder: what's the catch? And how does this thing actually work under the hood?

So I went down the rabbit hole. Here's what I found.

The Origin Story: It Started with 1.1.1.1

To understand WARP, you need to go back to April 1, 2018 — the day Cloudflare launched 1.1.1.1, a free public DNS resolver.

What DNS Resolvers Do

Every time you type a URL into your browser, your device needs to translate that human-readable domain name (like example.com) into an IP address (like 93.184.216.34) that computers can route to. This translation is handled by a DNS resolver — a server that looks up domain names and returns IP addresses.

By default, your DNS resolver is assigned by your ISP (Internet Service Provider). This means your ISP can see every domain you visit — not the full URL or page content, but the domain itself. They know you visited netflix.com at 10pm and webmd.com at 2am. In many countries, ISPs are legally allowed to log and sell this data. Some ISPs inject ads into DNS responses. Some redirect failed lookups to their own search pages filled with advertising.

Why Cloudflare Built 1.1.1.1

Cloudflare's pitch was simple: a DNS resolver that is:

Fast — they aimed for the fastest public resolver in the world, and largely achieved it. As of today, 1.1.1.1 consistently benchmarks as one of the top two fastest public resolvers globally (alongside Google's 8.8.8.8).
Private — Cloudflare committed to never selling user data, never using DNS query data for ad targeting, and purging all query logs within 24 hours. They hired KPMG to audit this commitment annually.
Secure — full support for DNS-over-HTTPS (DoH) and DNS-over-TLS (DoT), encrypting DNS queries so they can't be read or tampered with in transit.

The IP address 1.1.1.1 was deliberately chosen for memorability — it's the DNS equivalent of a vanity phone number. Cloudflare had to negotiate with APNIC (the Asia-Pacific internet registry) to get it, since the 1.0.0.0/8 block had historically been used for research and was plagued by junk traffic from misconfigured devices. The deal: Cloudflare would operate the resolver and share anonymized DNS research data with APNIC.

1.1.1.1 was a hit. Within months, it was handling tens of billions of DNS queries per day. But it had a fundamental limitation: it only encrypted the DNS lookup, not the rest of your traffic. Your ISP couldn't see which domains you were resolving, but they could still see the IP addresses you connected to afterward — and for many websites, the IP address alone is enough to identify the destination.

Cloudflare needed a way to protect the full connection, not just the DNS query.

Enter WARP: April 1, 2019

Exactly one year after launching 1.1.1.1, Cloudflare announced WARP — a free service that would encrypt all traffic between your device and Cloudflare's network. Not just DNS queries. Everything.

The announcement was met with immediate skepticism. A free VPN from a major tech company? With no bandwidth limits? The internet had seen this movie before — "free" VPN providers that monetized by logging traffic, injecting ads, or selling user data. The phrase "if you're not paying for the product, you're the product" was repeated in every comment thread.

Cloudflare's response was that WARP isn't a VPN in the traditional sense, and their business model doesn't depend on user data. But more on that later.

WARP launched publicly in September 2019 after a waitlist period that accumulated millions of sign-ups. It was initially available only on iOS and Android via the 1.1.1.1 app. Desktop support for macOS, Windows, and Linux followed in 2020.

How WARP Actually Works

WARP is built on WireGuard, a modern VPN protocol that deserves its own section.

WireGuard: The Protocol Underneath

WireGuard was created by Jason Donenfeld and publicly released in 2015. It was designed as a radical simplification of VPN technology. At the time, the two dominant VPN protocols were:

OpenVPN — open-source, battle-tested, but complex. The codebase is over 100,000 lines of C. Configuration involves managing certificates, choosing cipher suites, and tuning dozens of parameters. It runs in userspace, which adds overhead from context switches between kernel and userspace for every packet.
IPsec (with IKEv2) — the enterprise standard, built into most operating systems. Extremely capable but notoriously complex to configure correctly. The specification sprawls across dozens of RFCs. Security researchers have repeatedly found implementation bugs stemming from this complexity.

Donenfeld's thesis was that a VPN protocol should be simple enough to audit in an afternoon. WireGuard's entire codebase is roughly 4,000 lines of code — small enough that it was merged into the Linux kernel in March 2020 (Linux 5.6). By comparison, OpenVPN's codebase is 25x larger.

WireGuard achieves this simplicity through opinionated design choices:

Decision	WireGuard's Choice
Key exchange	Noise Protocol Framework (based on Curve25519)
Symmetric encryption	ChaCha20-Poly1305
Hashing	BLAKE2s
Key derivation	HKDF
Cipher agility	None — there's exactly one cipher suite, no negotiation

That last point — no cipher agility — is the most controversial and the most important. Traditional VPN protocols let you choose which encryption algorithms to use, which sounds flexible but creates a massive attack surface. Cipher negotiation is where many real-world VPN vulnerabilities live. WireGuard simply doesn't negotiate: both sides use the same fixed set of modern cryptographic primitives. If any of them are ever broken, the entire protocol gets a version bump, and everyone moves to the new version. No backwards compatibility, no downgrade attacks.

The performance difference is substantial. WireGuard operates in the kernel (on Linux) rather than userspace, eliminating the per-packet context switch overhead that plagues OpenVPN. Benchmarks consistently show WireGuard achieving 2-4x higher throughput than OpenVPN and establishing connections in under 100 milliseconds — fast enough that the VPN can reconnect seamlessly when you switch between WiFi and cellular.

What Cloudflare Changed

Cloudflare didn't use WireGuard as-is. They built a custom implementation called BoringTun (a play on Google's BoringSSL, their stripped-down fork of OpenSSL). BoringTun is written in Rust and runs in userspace rather than requiring kernel-level access. This was a deliberate choice:

Cross-platform deployment — kernel WireGuard only exists on Linux. BoringTun runs identically on macOS, Windows, iOS, and Android without needing kernel extensions or drivers.
App Store compatibility — Apple and Google's app stores don't allow apps that install kernel modules. A userspace implementation can ship as a normal app.
Memory safety — Rust's ownership model prevents entire classes of memory bugs (buffer overflows, use-after-free, data races) that have historically been the source of VPN vulnerabilities. For a tool that handles every packet leaving your device, this matters enormously.

BoringTun was open-sourced on GitHub in March 2019, before WARP even launched publicly.

The Data Flow

Here's what happens when WARP is enabled on your device:

Your device establishes a WireGuard tunnel to the nearest Cloudflare data center. Cloudflare operates in over 330 cities across 120+ countries, so "nearest" usually means within a few milliseconds of network latency.
All traffic from your device — not just DNS, not just browser traffic, but everything — is encrypted and sent through this tunnel to Cloudflare's edge.
At Cloudflare's edge, the traffic is decrypted and forwarded to its destination on the public internet. DNS queries go to 1.1.1.1. Web requests go to the origin server. Everything else goes where it's addressed.
Responses travel back through the same path: origin server to Cloudflare edge, encrypted through the tunnel, decrypted on your device.

This means your ISP sees only encrypted WireGuard packets flowing between your device and Cloudflare. They can't see which domains you're visiting, which pages you're loading, or what data you're sending. The traffic looks like a single encrypted stream to a Cloudflare IP address.

What WARP Is Not

This is where the "not really a VPN" distinction matters:

WARP does not hide your IP address from websites. When your traffic exits Cloudflare's network, the destination server sees an IP address in the same geographic region as your real one. Unlike a traditional VPN where you can choose to appear in another country, WARP deliberately routes you through the nearest data center. You can't use it to watch Netflix from another region or bypass geo-restrictions.
WARP does not anonymize you. Cloudflare knows your real IP address (it has to, to send responses back to you). Traditional privacy-focused VPNs like Mullvad go to extreme lengths to avoid knowing who you are — accepting cash payments, generating random account numbers, running on RAM-only servers. WARP doesn't pretend to offer this level of anonymity.
WARP is not designed to circumvent censorship. While it does encrypt your traffic (which can incidentally bypass some forms of network filtering), Cloudflare has stated that WARP is not designed as a censorship circumvention tool. In countries that actively block VPN protocols, WARP's WireGuard traffic can be identified and blocked just like any other VPN.

What WARP is designed to do:

Encrypt your traffic on untrusted networks — coffee shop WiFi, hotel networks, airport hotspots. This is genuinely valuable. On an unencrypted network, anyone with a packet sniffer can see your DNS queries and unencrypted HTTP traffic.
Prevent ISP snooping — your ISP can no longer see which domains you're visiting or sell that data to advertisers.
Improve performance in some cases — Cloudflare's network is often faster than the default path your ISP takes to reach a destination. WARP can route your traffic through Cloudflare's optimized backbone, reducing latency for connections that would otherwise take a suboptimal path across the public internet.

The Business Model: Why Is It Free?

This is the question everyone asks, and the answer is surprisingly straightforward.

Cloudflare's Real Business

Cloudflare is a publicly traded company (NYSE: NET) with revenue over $1.5 billion annually. Their business is selling cloud security and performance services to businesses: DDoS protection, CDN, Web Application Firewall, Zero Trust access, Workers (serverless compute), R2 (object storage), and more. Their customer list includes roughly 20% of all websites on the internet.

WARP fits into this business in several ways:

Network utilization. Cloudflare has already built a massive global network to serve its paying customers. The marginal cost of routing consumer WARP traffic through this network is relatively low — the infrastructure exists regardless. Consumer traffic helps justify network expansion in regions where enterprise demand alone might not warrant a new data center.
Brand awareness and trust. Every person running WARP on their phone is a potential advocate for Cloudflare. When those people make infrastructure decisions at work — choosing a CDN, a DNS provider, a security vendor — Cloudflare is already a name they trust. This is marketing that scales.
The paid tier: WARP+. For $4.99/month, WARP+ routes your traffic through Cloudflare's Argo Smart Routing network, which uses real-time network intelligence to find the fastest path between you and your destination. This is the same technology Cloudflare sells to enterprise customers for optimizing their web properties. Consumer WARP+ subscriptions are a lower-margin but high-volume revenue stream.
Zero Trust pipeline. Cloudflare's enterprise product Cloudflare Zero Trust (formerly Cloudflare for Teams) uses the same WARP client to connect employees to corporate networks. An employee who already has WARP on their personal phone is one configuration profile away from being enrolled in their company's Zero Trust deployment. The consumer app is, in effect, pre-installed enterprise software.
Network intelligence. The aggregate traffic flowing through WARP gives Cloudflare visibility into internet routing, performance, and security trends. This data (in aggregate, not individually) informs their network engineering decisions, their threat intelligence products, and their Radar platform (a public internet trends dashboard). Cloudflare has been explicit that they don't sell individual user data and don't use it for ad targeting.

The math works because WARP's cost to Cloudflare is marginal (the network already exists), while the strategic benefits — brand trust, enterprise pipeline, paid tier upsells, and network intelligence — are substantial.

The Technical Stack in Detail

Cloudflare's Network Architecture

Cloudflare's network is built on an anycast architecture. This means the same IP addresses are advertised from every Cloudflare data center in the world. When your device connects to WARP, BGP routing directs the connection to the physically closest data center.

This is different from how traditional VPN providers work. A typical VPN provider operates a fixed set of servers in specific cities. You choose "connect to London" and your traffic goes to a specific server farm in London, regardless of whether there's a closer server. If that server is overloaded, your speed drops.

With anycast, there is no server selection. Your traffic automatically goes to the nearest point of presence. If a data center goes offline, BGP reconverges and your traffic is automatically routed to the next-closest one — typically within seconds, often without dropping your connection. This is the same technique Cloudflare uses for its CDN and DDoS protection, so it's battle-tested at enormous scale.

The 1.1.1.1 App

The user-facing software is the 1.1.1.1 app, available on iOS, Android, macOS, Windows, and Linux. On mobile, it uses the OS's native VPN API (NetworkExtension on iOS, VpnService on Android) to create a system-wide tunnel. On desktop, it installs a lightweight daemon that manages the WireGuard tunnel.

The app offers three modes:

Mode	What It Does
1.1.1.1 (DNS only)	Routes only DNS queries through Cloudflare's encrypted resolver. The rest of your traffic is unaffected.
WARP	Routes all traffic through the WireGuard tunnel to Cloudflare. DNS goes to 1.1.1.1, everything else exits through Cloudflare's network near your location.
WARP+	Same as WARP, but uses Argo Smart Routing for optimized paths. Paid tier.

Switching between modes is instant — the tunnel is established or torn down in milliseconds, which is one of WireGuard's key advantages over older protocols.

DNS-over-HTTPS and DNS-over-TLS

Even in DNS-only mode (without the full WARP tunnel), the 1.1.1.1 app encrypts your DNS queries using either:

DNS-over-HTTPS (DoH) — DNS queries are wrapped in HTTPS requests to https://cloudflare-dns.com/dns-query. This looks like normal HTTPS traffic on port 443, making it difficult for network operators to selectively block DNS encryption while allowing other HTTPS traffic.
DNS-over-TLS (DoT) — DNS queries are encrypted with TLS and sent to port 853. This is more transparent (network operators can see it's encrypted DNS) but slightly more efficient than DoH since it doesn't have HTTP overhead.

Both prevent your DNS queries from being read or tampered with in transit. Traditional DNS (port 53, unencrypted) sends domain lookups in plaintext — anyone on the network path can read them.

WARP vs. Traditional VPNs

If you're already paying for a VPN service, you might wonder how WARP compares. The honest answer is that they serve different purposes.

Feature	WARP (Free)	Traditional VPN (e.g., Mullvad, ProtonVPN)
Price	Free (WARP+: $4.99/mo)	$5-12/month
IP masking	No — exits near your location	Yes — choose exit country
Geo-unblocking	No	Yes (server selection)
Anonymity	Limited — Cloudflare knows your IP	Stronger — cash payments, no logs (varies by provider)
Speed	Excellent — anycast, minimal latency	Varies — depends on server load and distance
Protocol	WireGuard (BoringTun)	WireGuard, OpenVPN, or proprietary
Censorship bypass	Not designed for it	Some are designed for it (obfuscated protocols)
ISP snooping protection	Yes	Yes
Public WiFi protection	Yes	Yes
Kill switch	Yes (on desktop)	Yes
Multi-device	Unlimited	Typically 5-10 devices

If your primary concern is privacy from your ISP and security on public networks, WARP does the job for free. If you need to appear in another country, avoid being tracked by IP address, or bypass censorship, a traditional VPN is the right tool.

I use WARP because my threat model is simple: I don't want my ISP logging my DNS queries, and I don't want coffee shop WiFi to be a security risk. WARP handles both without me thinking about it.

Setting It Up

Mobile (iOS / Android)

Install the 1.1.1.1 app from the App Store or Google Play.
Open the app. Tap the toggle. That's it.

No account creation, no email address, no payment information. The app generates a WireGuard key pair on-device, registers the public key with Cloudflare, and establishes the tunnel. The entire setup takes under 10 seconds.

Desktop (macOS / Windows / Linux)

Download the 1.1.1.1 client from Cloudflare's website.
Install and run it. A small icon appears in the menu bar / system tray.
Click the icon and toggle WARP on.

On macOS, the app installs a system extension to create the VPN tunnel. On Linux, it's a CLI tool (warp-cli) with a daemon (warp-svc):

# Linux setup
curl -fsSL https://pkg.cloudflareclient.com/pubkey.gpg | sudo gpg --dearmor -o /usr/share/keyrings/cloudflare-warp-archive-keyring.gpg
# Add repo and install...
sudo apt install cloudflare-warp

# Register and connect
warp-cli registration new
warp-cli connect

# Check status
warp-cli status

Verifying It Works

Once WARP is connected, you can verify it's working by visiting https://1.1.1.1/help in a browser. The page shows your connection status, whether you're using WARP, which Cloudflare data center you're connected to, and whether DNS-over-HTTPS is active.

You can also check your DNS resolver from the command line:

# Should return 1.1.1.1 or 1.0.0.1
nslookup -type=txt whoami.cloudflare.com

My Experience

I've been using WARP on both my phone and laptop for months. A few observations:

Speed is a non-issue. On a decent internet connection, I genuinely cannot tell that WARP is running. Latency overhead is negligible — usually 1-3ms. This is a direct benefit of Cloudflare's anycast network: the nearest data center is almost always within a few milliseconds. Some traditional VPN providers add 20-50ms of latency, which is noticeable in video calls and gaming.

Battery impact on mobile is minimal. WireGuard's efficiency shows here. Unlike OpenVPN-based apps that can visibly drain your battery, WARP runs all day on my phone without a noticeable difference. The protocol's ability to go silent when there's no traffic (WireGuard doesn't send keepalive packets unless configured to) means it essentially sleeps when your phone is idle.

It just reconnects. Moving between WiFi and cellular, waking from sleep, going through a tunnel with no signal — WARP re-establishes the connection almost instantly. This is WireGuard's "roaming" in action: the protocol is stateless enough that the tunnel survives IP address changes without a full re-handshake.

No configuration needed. I set it up once on each device and haven't touched it since. There's no server to choose, no protocol to select, no settings to tune. The app has a grand total of one switch.

The Takeaway

WARP occupies an interesting niche. It's not trying to be Mullvad or ProtonVPN. It's not for journalists in authoritarian regimes or whistleblowers needing anonymity. It's for everyone else — people who want their internet traffic encrypted by default without paying for a VPN subscription, without configuring anything, and without a noticeable performance penalty.

The fact that it's built on WireGuard (via a Rust implementation), runs on Cloudflare's anycast network, and is genuinely free with no bandwidth caps makes it a remarkably good deal. The trade-off — that Cloudflare can see your traffic at their edge, and you can't mask your geographic location — is one I'm comfortable with.

For my use case — encrypting traffic on untrusted networks and keeping my ISP out of my DNS queries — it's exactly the right tool. I flip the switch and forget about it.

Freakonomics — When Economists Start Asking the Wrong Questions

Mon, 04 May 2026 00:00:00 GMT

I picked up Freakonomics expecting a book about economics. What I got was a book about cheating, crack cocaine, baby names, and the Ku Klux Klan — held together by the idea that if you look at the right data and ask the right questions, the world reveals patterns that conventional wisdom completely misses.

Published in 2005 by economist Steven D. Levitt and journalist Stephen J. Dubner, Freakonomics: A Rogue Economist Explores the Hidden Side of Everything became one of those rare nonfiction books that crossed over from the business shelf into genuine pop culture. It spent over two years on the New York Times bestseller list, sold more than four million copies, and spawned a sequel (SuperFreakonomics), a movie, a podcast, and arguably an entire genre of "pop economics" books that followed.

The book doesn't have a unifying theme in the traditional sense. Levitt himself admits this. Instead, it has a unifying method: take a question that seems to belong to sociology, criminology, or common sense, and attack it with the tools of economics — incentives, data analysis, and a willingness to follow the numbers wherever they lead, even when the conclusion is uncomfortable.

Here are the case studies that stuck with me.

Cheating Sumo Wrestlers and Cheating Teachers

The book opens with a deceptively simple premise: people respond to incentives, and when the incentive structure is strong enough, even people we'd expect to be honourable will cheat.

Sumo: The Gentle Art of Strategic Losing

Sumo wrestling occupies an almost sacred place in Japanese culture. The sport is steeped in centuries of ritual, Shinto tradition, and a code of honour that elevates wrestlers to the status of cultural icons. Suggesting that sumo matches are rigged is, in Japan, roughly equivalent to accusing the Pope of embezzlement — technically possible, but socially unthinkable.

Levitt looked at the data anyway.

The key context: sumo wrestlers compete in tournaments of 15 bouts each. A wrestler who finishes with 8 or more wins (a winning record, called kachi-koshi) maintains or improves their ranking. A wrestler who finishes with 7 or fewer wins (make-koshi) drops in rank. Rank determines everything — income, prestige, lifestyle, the number of servants assigned to you. The difference between 7 wins and 8 wins is, in career terms, enormous.

Levitt analysed thousands of matches and focused on a specific scenario: a wrestler entering the final bout of a tournament at 7-7 (needing one more win for a winning record) facing an opponent who is already at 8-6 (whose winning record is already secured). In this situation, the 7-7 wrestler has everything to gain, and the 8-6 wrestler has relatively little at stake.

If matches were decided purely on merit, the 7-7 wrestler should win roughly 50% of the time against an equally ranked opponent. Instead, Levitt found that the 7-7 wrestler won approximately 80% of the time in these situations. That's a staggering deviation — far too large to be explained by "fighting harder when desperate."

Even more telling: the next time those same two wrestlers met, the one who had previously lost (the former 8-6 wrestler) won at a disproportionately high rate. The data pattern was consistent with a quid pro quo — "I'll let you win this one when you need it, and you'll return the favour later."

The statistical evidence was damning, but it was confirmed years later when a series of match-fixing scandals rocked Japanese sumo, leading to the expulsion of dozens of wrestlers. The culture of arranged outcomes was, as Levitt's data had suggested, systemic.

The lesson isn't that sumo wrestlers are uniquely corrupt. It's that any system where a small margin produces a large difference in outcomes creates an incentive to cheat — and that incentive scales with the stakes. The sumo ranking system's cliff edge (8 wins = success, 7 wins = failure) was essentially a machine for producing collusion.

Teachers: High-Stakes Testing Meets Human Nature

Levitt applied the same logic to Chicago public school teachers in the era of high-stakes standardised testing. Under the No Child Left Behind Act, test scores carried enormous consequences: schools with improving scores received more funding, praise, and resources. Schools with declining scores faced sanctions, staff changes, and potential closure. Teachers whose students performed well could earn bonuses; teachers whose students performed poorly risked losing their jobs.

The incentive to cheat was obvious. But how would a teacher cheat on a standardised test?

Levitt and his colleague Brian Jacob developed an algorithm to detect unusual answer patterns in student test sheets. They looked for two telltale signatures:

Blocks of identical answers — especially on harder questions near the end of the test, where you'd expect more variation. If 20 students in the same classroom all answered questions 28-32 identically (and correctly), despite getting many easier questions wrong, that pattern is suspicious. It suggests someone filled in or changed those answers after the students handed in their sheets.
Unusual score fluctuations — a classroom whose average score jumps dramatically in one year and then drops back down the next (when the students move to a different teacher) suggests the spike was artificial.

The algorithm flagged roughly 5% of classrooms as having strong evidence of teacher cheating. When the Chicago Public Schools conducted retests of flagged classrooms — bringing students back to take the same test under controlled conditions — the retest scores dropped significantly, confirming the algorithm's predictions.

Levitt's point wasn't to villainise teachers. It was to demonstrate that high-stakes incentives produce predictable behaviour, and that behaviour isn't always the behaviour the incentive was designed to encourage. The testing system was meant to motivate better teaching. For most teachers, it did. For some, it motivated fraud — because the system made the difference between a good outcome and a bad outcome sharp enough to justify the risk.

Why Do Drug Dealers Live with Their Moms?

This might be the most memorable chapter in the book, and it starts with a sociology graduate student named Sudhir Venkatesh.

In the 1990s, Venkatesh was a PhD student at the University of Chicago. For his dissertation research, he embedded himself with a crack-dealing gang on Chicago's South Side — the Black Disciples, led by a man he calls "J.T." Over several years of direct observation, Venkatesh gained extraordinary access to the gang's operations, including something almost unheard of in academic research: the gang's actual financial records.

J.T., the local gang leader, was business-minded enough to keep detailed books — revenue, expenses, wages, everything. When Venkatesh eventually shared this data with Levitt, it painted a picture that demolished the popular image of drug dealing as a path to easy riches.

The Economics of a Crack Gang

The gang's structure turned out to look remarkably like a franchise operation — or, as Levitt puts it, like McDonald's:

Role	Monthly Income	Notes
Gang leader (board of directors)	~$100,000+	Top of the pyramid. Very few people.
Local gang boss (J.T.'s level)	~$8,500	Manages a territory. Significant risk.
Three officers (lieutenants)	~$700 each	Enforcers, treasurers, runners.
Foot soldiers (~50 per crew)	~$3.30/hour	The rank-and-file street dealers.

That last number is the one that makes people do a double take. $3.30 per hour — less than the minimum wage at the time. The foot soldiers, the ones doing the actual dealing on street corners, the ones absorbing the bulk of the physical risk (a roughly 1 in 4 chance of being killed over the four-year period Venkatesh observed), were earning poverty wages.

So why did they do it? The same reason an aspiring actor waits tables in Hollywood, or a junior investment banker works 100-hour weeks for relatively modest pay: the tournament model. The drug gang operated like a tournament where the prize — becoming a gang boss with a comfortable income — went to a very small number of winners. Everyone at the bottom believed they might be the one to make it to the top. The expected value was terrible, but the dream was compelling.

And in the meantime? They lived with their moms. Because on $3.30 an hour, you can't afford rent.

The chapter reframes drug dealing from a story about easy money and moral failure into a story about rational economic actors making decisions within a constrained set of options. The foot soldiers weren't stupid. They understood the odds were bad. But for young men in neighbourhoods with few legitimate paths to status and income, the tournament structure of the gang — with its visible, aspirational winners — was a more compelling proposition than a minimum-wage job at a fast food restaurant, even when the math said otherwise.

What Caused the Crime Drop in the 1990s?

This is the chapter that generated the most controversy, and it's the one where Levitt's willingness to follow the data into uncomfortable territory is most apparent.

The Context

American violent crime had been rising relentlessly for decades. From the 1960s through the early 1990s, murder rates, assaults, and robberies climbed to levels that felt existential. In the late 1980s and early 1990s, the crack epidemic amplified the violence further. Cities like New York, Los Angeles, and Washington D.C. were widely described as war zones. Criminologists, politicians, and media commentators predicted the trend would continue or worsen. The term "superpredator" entered the lexicon — a supposed new breed of remorseless juvenile criminals who would terrorise America's cities into the next century.

And then, starting around 1992-1993, violent crime began to fall. It didn't just dip — it plummeted. By the end of the decade, murder rates in major cities had dropped 50-70%. The decline was sudden, dramatic, and sustained. It remains one of the most significant sociological shifts in modern American history.

Everyone had an explanation. Here were the popular ones:

The Conventional Explanations (That Levitt Mostly Debunks)

Innovative policing strategies. New York City's crime drop was widely attributed to the NYPD's adoption of CompStat (data-driven policing) and the "broken windows" theory under Police Commissioner Bill Bratton and Mayor Rudy Giuliani. Levitt acknowledges that increased policing and better strategies contributed, but argues they explain only a modest portion of the national decline. Cities that didn't adopt these strategies saw similar drops. The timing also doesn't fully align — crime began falling before many of these strategies were implemented.

The booming 1990s economy. A strong economy means more jobs, which means less incentive for property crime. This is intuitive, but Levitt points out that the relationship between economic growth and violent crime is weak. Property crime tracks with the economy more closely, but murder and assault — the crimes that fell most dramatically — are less responsive to job availability.

The decline of the crack epidemic. The crack market matured and stabilised by the mid-1990s. The initial wave of violence associated with establishing crack territories subsided as markets consolidated. Levitt considers this a significant factor, but not sufficient on its own to explain the magnitude of the decline.

Increased incarceration. The U.S. prison population tripled between 1975 and 2000. Levitt acknowledges that putting more criminals behind bars mechanically reduces the number of crimes committed (incapacitation effect) and may deter others (deterrence effect). He estimates this contributed roughly a third of the crime drop.

Ageing population. Crime is disproportionately committed by young men. As the baby boom generation aged out of peak crime years, the demographic base for crime shrank. This is a real factor, but the demographic shift was gradual, while the crime drop was sudden.

The Controversial Theory: Roe v. Wade

Levitt's most explosive argument is that the legalisation of abortion following the Roe v. Wade Supreme Court decision in 1973 was the single largest contributor to the crime drop of the 1990s.

The logic runs like this:

After Roe v. Wade, abortion became legal and accessible across the United States.
The women most likely to have abortions were disproportionately young, unmarried, and poor — demographics whose children were statistically more likely to grow up in environments associated with higher crime rates (poverty, single-parent households, limited access to education and resources).
The first cohort of children who would have been born but weren't reached their peak crime years (ages 18-24) in the early to mid-1990s — precisely when the crime drop began.
States that legalised abortion before Roe v. Wade (New York, California, Washington, Alaska, Hawaii) saw their crime rates begin to drop earlier than the rest of the country, consistent with the theory.
States with higher abortion rates after 1973 experienced larger crime drops in the 1990s than states with lower abortion rates.

Levitt estimates that legalised abortion accounted for roughly half of the crime reduction observed in the 1990s.

The Backlash

The theory was (and remains) deeply controversial — attacked from both left and right, for different reasons. Critics on the right objected to what they saw as a utilitarian argument for abortion. Critics on the left argued that the theory implied poor and minority children were potential criminals — a eugenics-adjacent framing.

Levitt's position was that he was making a positive claim (this is what the data shows) rather than a normative one (this is what policy should be). He wasn't arguing that abortion is good because it reduces crime. He was arguing that the data supports a causal link, and that ignoring it because the conclusion is uncomfortable is intellectually dishonest.

Other economists have challenged the statistical methodology. Some found that adjusting for different variables weakened the correlation. Others found errors in the original analysis. Levitt published responses and corrections. The academic debate continues, and the theory remains contested — but it has never been definitively refuted.

Whether you find the argument convincing or not, the chapter demonstrates the book's core method: start with the data, follow it rigorously, and report the conclusion regardless of how it lands. The willingness to publish a finding this controversial, knowing the backlash it would generate, is what separates Freakonomics from most pop-science books.

Information Asymmetry: When One Side Knows More

Threaded throughout the book is a concept that Levitt returns to repeatedly: information asymmetry — situations where one party in a transaction has significantly more information than the other, and uses that advantage to their benefit.

Real Estate Agents: Whose Side Are They On?

The most accessible example is real estate agents. When you hire an agent to sell your house, the agent's commission is a percentage of the sale price — typically around 3% per side. This seems like it aligns incentives: the agent earns more when your house sells for more. But Levitt shows that the alignment is an illusion.

Consider a house that might sell for $300,000 with a quick sale, or $310,000 if it stays on the market for another two weeks. The extra $10,000 matters a lot to the seller. But the agent's 3% commission on that extra $10,000 is only $300. For $300, the agent has to keep the listing active, show the house multiple more times, field calls, negotiate — it's not worth the effort. The agent's incentive is to close the deal quickly, even at a lower price, and move on to the next commission.

Levitt tested this by comparing what happens when agents sell their own homes versus their clients' homes. The data showed that agents keep their own houses on the market an average of 10 days longer and sell them for about 3% more than comparable client houses. When it's their own money on the line, agents are suddenly patient. When it's yours, they push for a fast close.

The information asymmetry is the mechanism that makes this possible. The agent knows the local market, knows what competing houses have sold for, knows whether the first offer is likely to be the best offer. The seller doesn't. The agent can say "this is a strong offer, I'd take it" — and the seller, lacking the information to evaluate that claim independently, usually does.

The KKK and the Power of Secrets

Levitt and Dubner tell the story of Stetson Kennedy, a journalist and activist who infiltrated the Ku Klux Klan in the 1940s. Kennedy discovered that the Klan's power rested heavily on secrecy — the mysterious rituals, the coded language, the hidden membership. The Klan's ability to terrorise depended on the information gap between insiders and everyone else.

Kennedy's weapon was information dissemination. He fed the Klan's secret rituals, code words, and handshakes to the writers of the Superman radio show, which incorporated them into a storyline where Superman battles the KKK. Suddenly, children across America were playing games using the Klan's secret passwords. The rituals that had felt menacing in darkness became laughable in daylight.

Klan recruitment dropped sharply. The mystique — the information asymmetry that made the organisation seem powerful and omniscient — was demolished by making the secrets public.

The principle generalises: information asymmetry is power, and the redistribution of information is the redistribution of power. This is why insider trading laws exist, why nutritional labels are mandatory, why governments publish data, and why the internet — the greatest information-levelling tool in human history — has disrupted every industry built on knowing more than the customer.

The Internet Disrupts Everything

Levitt was writing in 2005, but his observations about information asymmetry have only become more relevant. He noted how the internet was already eroding the information advantages that experts had traditionally held over their customers:

Car dealers could no longer rely on buyers being ignorant of invoice prices. Sites like Edmunds and TrueCar made dealer costs transparent.
Insurance companies faced customers who could compare quotes across dozens of providers in minutes.
Doctors encountered patients who had Googled their symptoms and arrived with printouts of medical journal articles.

The pattern is the same in every case: when information flows freely, the party that previously benefited from the asymmetry loses leverage. The expert doesn't disappear — you still need a doctor, a real estate agent, a mechanic — but the relationship shifts from blind trust to informed negotiation.

What the Book Gets Right (and Wrong)

Twenty years after publication, Freakonomics holds up better as a method than as a collection of settled conclusions.

What it gets right:

The emphasis on incentives as the lens through which to understand behaviour remains powerful and widely applicable.
The insistence on looking at data rather than accepting conventional wisdom is a habit worth cultivating.
The case studies on cheating (sumo, teachers) and information asymmetry (real estate agents) are well-supported and haven't been seriously challenged.
The drug dealer economics, based on Venkatesh's fieldwork, is a genuinely novel contribution to understanding underground economies.

What's been challenged:

The abortion-crime theory remains contested. Subsequent analyses have found methodological issues, and some researchers have produced results that weaken the correlation. It's a plausible hypothesis, not a settled fact.
The Stetson Kennedy story was later revealed to be partly embellished — Kennedy inflated his own role in the Klan's decline. The book's account of his exploits is more colourful than historical reality.
The book's treatment of complex social phenomena sometimes oversimplifies. Real-world outcomes rarely have a single cause, and Freakonomics occasionally presents one factor as more decisive than the evidence warrants.

Why It's Still Worth Reading

Despite the caveats, I'd recommend Freakonomics to anyone who hasn't read it. Not because every conclusion is bulletproof — some aren't — but because the approach is genuinely useful.

The book teaches you to ask: What are the incentives here? Who benefits from the current arrangement? What does the data actually show, as opposed to what everyone assumes? Is the expert giving me advice that serves my interests or theirs?

These are questions worth carrying around. They apply to everything from negotiating a salary to evaluating a news headline to understanding why a particular policy produces the opposite of its intended effect.

Levitt and Dubner's great contribution wasn't any single finding. It was demonstrating that economics — the discipline most people associate with GDP charts and interest rates — is really just a framework for understanding human behaviour. And human behaviour, it turns out, is endlessly, reliably, entertainingly strange.

Hang on the Bar for 100 Seconds

Sat, 25 Apr 2026 00:00:00 GMT

There is an exercise so simple it feels like cheating. You walk up to a pull-up bar, grab it with both hands, and hang. That's it. No reps, no sets, no complicated form cues. Just you, gravity, and a clock counting to 100.

I do this several times a week. Some days it's the only "workout" I do. And I'm convinced it's one of the most underrated exercises that exists.

How to Do It

Stand under a bar. Reach up, wrap your fingers around it, and lift your feet off the ground. Relax your shoulders. Let your body weight do the work. Hang there for 100 seconds.

That's the whole exercise.

If 100 seconds sounds easy, try it. Most people can't make it past 40 on their first attempt. Your forearms will burn. Your grip will scream. Your brain will invent every reason to let go.

Start wherever you can — 20 seconds, 30 seconds — and build up. The goal isn't perfection on day one. The goal is showing up and holding on.

Why 100 Seconds

There's nothing magic about the number 100. It's just long enough to be genuinely challenging, short enough to fit into any day, and easy enough to remember. No app needed. No calculation. Just count to 100 and let go.

It also sits in a sweet spot: long enough for your spine to decompress, long enough for your grip to be meaningfully challenged, but not so long that you're grinding through pain.

The Benefits

Spinal Decompression

We spend most of our waking hours compressing the spine — sitting, standing, carrying things. Hanging reverses that. Gravity pulls your vertebrae apart gently, creating space between the discs. People often report feeling taller after hanging consistently, and they're not imagining it. You can actually measure a small increase in height over the course of a few weeks.

For anyone with lower back pain, this alone can be life-changing. It's one of the few exercises that doesn't load the spine — it unloads it.

Grip Strength

Grip strength is one of the strongest predictors of overall health and longevity. Studies have linked it to lower cardiovascular risk, reduced all-cause mortality, and better functional independence as you age. Dead hangs are one of the purest ways to build it.

Your forearms, fingers, and hands get progressively stronger. You'll notice it everywhere — opening jars, carrying groceries, shaking hands.

Shoulder Health

Hanging opens up the shoulder joint in a way that almost nothing else does. It stretches the lats, pecs, and the muscles around the rotator cuff. Orthopedic surgeon Dr. John Kirsch has spent decades advocating for hanging as a treatment for shoulder impingement and rotator cuff issues, documented in his book Shoulder Pain? The Solution & Prevention. His argument is straightforward: hanging restores the natural space in the shoulder joint that modern life has compressed away.

If you sit at a desk all day — and you probably do — your shoulders are likely rounded forward and internally rotated. Hanging is the antidote.

Mental Toughness

Here's the part nobody talks about. Somewhere around second 60, your body starts negotiating with you. You could let go now. This is good enough. Nobody's watching. The exercise becomes less about your hands and more about your mind.

Choosing to hold on when everything says let go — that's a transferable skill. It's a tiny daily practice in not quitting.

The Cultural Thing

In many Chinese communities and across East Asia, you'll find pull-up bars installed in public parks — not for pull-ups, but specifically for hanging. Walk through any park in the morning and you'll see older adults hanging from bars, sometimes swinging gently, sometimes just dangling. It's as normal as jogging is in the West.

This isn't a fitness trend. It's a deeply rooted practice connected to traditional health philosophy. In Chinese culture, the concept of keeping the spine long and the joints open is tied to the flow of qi — vital energy. Hanging is seen as a way to maintain that flow, to counteract the compression of daily life, to stay loose and limber into old age.

The bars in these parks aren't fancy. They're simple metal pipes at various heights, weathered by years of use. Some parks have entire sections dedicated to these — rows of bars alongside parallel bars and other simple equipment. The design philosophy is the opposite of a modern gym: no memberships, no mirrors, no complexity. Just show up, grab the bar, and hang.

What strikes me about this is how democratic it is. You don't need athletic ability. You don't need youth. The 70-year-old hanging next to the 30-year-old is doing the same exercise, getting the same benefits. It's one of the few physical practices that doesn't scale with skill — it scales with consistency.

There's also a social element. People chat while they hang. They encourage each other. It becomes part of the morning routine alongside tai chi and walking. The bar isn't a piece of gym equipment — it's community infrastructure.

My Routine

I keep it dead simple. A few times a week, I grab the bar and hang for 100 seconds. Some days I do it once. Some days, if I'm feeling it, I'll do two or three rounds with rest in between. No program, no progression scheme, no tracking. Just hang.

On days when I don't feel like working out at all, I still hang. It takes less than two minutes. There's no excuse that survives contact with a two-minute commitment.

The bar I use is a doorframe pull-up bar. It cost less than dinner for two. That's the entire equipment list.

The Point

We overcomplicate fitness. We buy equipment, download apps, follow programs, optimize everything. And most of it gets abandoned within weeks because the activation energy is too high.

Hanging is the opposite. It's free, it's fast, it requires nothing, and it works. It decompresses your spine, builds your grip, opens your shoulders, and trains your mind to hold on when it wants to let go.

Grab a bar. Count to 100. That's the whole thing.

Save Gigabytes of Storage: Build a Batch Photo Resizer with iOS Shortcuts

Sun, 24 May 2026 00:00:00 GMT

Our smartphones are marvels of modern photography. With 48-megapixel sensors and sophisticated computational imaging, the photos we take are stunningly detailed. But that detail comes at a cost: storage space.

A single photo taken on a modern iPhone can easily range from 4MB to 12MB. If you are shooting in ProRAW, that number can balloon to 75MB+ per shot. Over a few years, this digital footprint swells, prompting those annoying "iCloud Storage is Full" notifications and eating up precious local disk space.

But here is a secret: you don't need 48 megapixels for every photo you keep.

For family snapshots, receipt logs, casual memories, or photos you intend to share on social media or messaging apps, a maximum resolution of 1920px on the longest edge is the absolute sweet spot. It is sharp enough to look crisp on a 1080p or 4K screen, yet it shrinks file sizes by 80% to 90%.

Instead of buying expensive iCloud upgrades or manually transferring files to a computer, you can build a native iOS Shortcut to batch resize your photos in seconds—directly on your iPhone or iPad.

Why 1920px is the "Sweet Spot"

When you resize a photo so that neither its width nor height exceeds 1920 pixels (maintaining its aspect ratio), magic happens under the hood:

Massive Space Savings: A typical 6MB iPhone photo scales down to roughly 300KB to 600KB at 1920px. That is a 10x reduction in space!
Blazing Fast Sharing: Sending 10 resized photos over a cellular connection takes a split second, compared to waiting for 60MB of raw data to upload.
Universal Compatibility: 1920px is highly optimized for web viewing, emails, and messaging apps, preventing platforms from aggressively compressing your images with ugly artifacts.

Step-by-Step: How to Build the Shortcut

You don't need to write a single line of code. We will use Apple's built-in Shortcuts app to assemble a drag-and-drop workflow.

┌────────────────────────────────────────────────────────┐
│  Shortcut Flow                                         │
├────────────────────────────────────────────────────────┤
│  1. Receive [Images] from [Share Sheet]                │
│  2. Resize [Input Images] to [1920] x [1920]           │
│  3. Convert [Resized Images] to [JPEG]                 │
│  4. Save [Converted Images] to [Photos Album]          │
└────────────────────────────────────────────────────────┘

Here is exactly how to build it:

Step 1: Initialize the Shortcut and Share Sheet Support

Open the Shortcuts app on your iPhone or iPad.
Tap the + icon in the top-right corner to create a new shortcut.
Rename your shortcut by tapping the title at the top. Let's call it "Resize to 1920".
Tap the i (info) button at the bottom (or top depending on your iOS version) and toggle on Show in Share Sheet. This is crucial—it allows you to trigger this tool directly from the Photos app.
In the main editor, you will now see: "Receive Any input from Share Sheet".
Tap Any and deselect everything except Images and Media. Tap Done.
Tap the action underneath labeled "If there is no input" and set it to Ask for Photos. This ensures that if you launch the shortcut directly from your home screen (rather than the share sheet), it will prompt you to pick images manually.

Step 2: Add the Resize Action

In the search bar at the bottom, search for "Resize Image" and add it to your workflow.
The block will automatically link to your input: "Resize Shortcut Input to width Auto-Size".
We want to be smart about how we resize. Tap Auto-Size and change it to 1920.
Tap the > arrow next to the action to expand options. Make sure the height is set to Auto-Size (or vice versa, or set both to 1920 to scale the longest edge). Shortcuts will automatically preserve the aspect ratio so your photos won't look stretched or distorted!

Step 3: Convert the Format and Optimize Quality

Search for "Convert Image" and drag it below the resize block.
It should read: "Convert Resized Image to JPEG". (You can also choose PNG or HEIF, but JPEG is the most widely compatible).
Tap the > arrow on the Convert action to customize quality:
- Quality Slider: Set it to around 80%. This provides the absolute best balance between visual clarity and file size reduction.
- Preserve Metadata: Keep this toggled ON if you want to retain the date taken, camera settings, and location. Toggle it OFF if you want to strip all metadata for privacy before sharing.

Step 4: Save or Share the Output

Now, you have options for what to do with the newly optimized images:

Option A: Save to a New Album (Recommended) Search for "Save to Photo Album" and add it. Set it to save to Recents or create a custom album called “Optimized”.
Option B: Share Directly Search for "Share" and add it. This will pop up the iOS Share Sheet with your resized photos, allowing you to instantly AirDrop, email, or message them without saving them to your library first.
Option C: Clean up the Originals If you are brave and want to reclaim space immediately, you can add a "Delete Photos" action and pass the original Shortcut Input to it. Shortcuts will prompt you with a safety confirmation before deleting anything, so you won't accidentally lose photos.

How to Use Your New Tool

Now that your shortcut is built, running it is incredibly smooth.

Method 1: From the Photos App (Share Sheet)

Open your Photos app.
Select one or more photos (you can select 50+ photos at once!).
Tap the Share button in the bottom-left corner.
Scroll down the list of actions and tap "Resize to 1920".
Let the shortcut run. A checkmark or a prompt will appear when it is done, and your optimized images will be saved or shared!

Method 2: From your Home Screen

Long-press on your home screen and add the Shortcuts Widget.
Select your "Resize to 1920" shortcut.
Tap the widget anytime. It will prompt you to select images from your gallery, process them in the background, and output the optimized versions.

The Results: A Real-World Test

To see just how effective this is, we ran a test on a standard batch of 10 travel photos shot on an iPhone 15 Pro:

Metric	Original Photos	Resized (1920px @ 80%)	Savings
Total Resolution	4032 × 3024 (12 MP)	1920 × 1440 (2.7 MP)	-77% resolution
Batch File Size	58.4 MB	4.1 MB	-93% disk space!
Visual Quality	Pin-sharp (100%)	Indistinguishable on phone/tablet	Perfect clarity

A saving of over 90% storage space means you can store 10 times as many photos in the same iCloud or local storage tier!

Wrap Up

Automation doesn't have to be complex. By leveraging the built-in power of iOS Shortcuts, you've created a custom utility that bypasses paid third-party apps, keeps your data completely local and private, and solves storage anxiety with a single tap.

Give it a try, run a batch of your older photos, and watch your available storage bounce back!

"I've Never Been to Me" — The Song That Failed, Disappeared, and Became a Hit Anyway

Fri, 24 Apr 2026 00:00:00 GMT

I heard a song recently that stopped me mid-scroll. It was playing in a coffee shop — one of those soft, vaguely familiar melodies that you've heard a thousand times without ever really listening. But this time I listened. And the lyrics hit differently than I expected.

The song was "I've Never Been to Me" by Charlene. A ballad from 1982 that sounds, on the surface, like easy-listening adult contemporary. But underneath the gentle production is one of the most raw, melancholy reflections on regret and identity in pop music — wrapped in a story of commercial failure, disappearance, and accidental resurrection that's almost as interesting as the song itself.

Who Is Charlene?

Charlene Marilynn D'Angelo was born on June 1, 1950, in Hollywood, California. She grew up surrounded by music — her father was a singer, and she began performing in church choirs and school musicals as a child. By her teens, she was singing in local clubs around Los Angeles, and by her early twenties she had caught the attention of Motown Records.

Motown signed her in the mid-1970s. This was not the Motown of the 1960s — the label's golden era of the Supremes, the Temptations, and Marvin Gaye was fading, and the company was pivoting away from its Detroit roots toward a more Los Angeles-based, pop-oriented sound. Charlene (who recorded under her first name only) was part of this transitional era.

She released a few singles that went nowhere. She was talented but not a star, and Motown's attention was elsewhere. By the late 1970s, her recording career appeared to be over. She left the music industry, moved to England, and took a job working in a sweet shop in Ilford, Essex. A Motown recording artist, selling candy in suburban London. The story could have ended there.

It didn't.

The Song's Strange Journey

First Release: 1977

"I've Never Been to Me" was originally recorded and released in 1976-1977 on Motown's subsidiary label, Prodigal Records. The song was written by Ron Miller and Ken Hirsch. Miller was a seasoned Motown songwriter — he had co-written "For Once in My Life" for Stevie Wonder and "A Place in the Sun" — so the pedigree was there.

The single was released, went nowhere, and was quietly deleted. Charlene's album Charlene came and went without commercial impact. In the music industry, this is the norm — the vast majority of singles fail, and most artists never get a second chance. Charlene accepted this, left the business, and moved on with her life.

The Resurrection: 1982

Five years later, a DJ in Tampa, Florida named Scott Shannon found a copy of the deleted single and started playing it on his radio show. Listeners responded. Other stations in Florida picked it up. The song began climbing regional charts — entirely without promotion, without a label push, without the artist even knowing it was happening.

Motown, recognising an unexpected opportunity, re-released the single nationally. By this point, Charlene was working in the sweet shop in England and had to be tracked down. Motown flew her back to the United States to promote a song she had recorded half a decade earlier and assumed would never be heard again.

The re-release was a phenomenon. "I've Never Been to Me" reached number 3 on the Billboard Hot 100 in May 1982 and hit number 1 in the UK, Australia, and several other countries. It sold over a million copies in the US alone. The song that had been deleted as a commercial failure became one of the biggest hits of 1982.

The Spoken Word Bridge

The version that became a hit was slightly different from the original 1977 recording. For the re-release, Charlene added a spoken-word bridge — a soft, intimate monologue in the middle of the song where she directly addresses the listener. This section, delivered almost in a whisper, is one of the most distinctive and emotionally charged moments in 1980s pop:

"Hey, you know what paradise is? It's a lie. A fantasy we create about people and places as we'd like them to be. But you know what truth is? It's that little baby you're holding, and it's that man you fought with this morning — the same one you're going to make love with tonight. That's truth. That's love."

The spoken bridge is what elevates the song from a standard ballad into something more personal and confrontational. It breaks the fourth wall — the singer steps out of the melody and talks directly to you, as if she's grabbed your arm in a bar and is telling you something urgent. It's a technique rarely used in pop music, and it's the reason the song lingers in memory long after the melody fades.

The addition was reportedly suggested by Motown during the re-release sessions. Whether it was Charlene's idea, the producer's idea, or a collaborative decision varies depending on who tells the story. But it transformed the song.

What the Song Is Actually About

On first listen, "I've Never Been to Me" can sound like a straightforward torch song — a woman singing about heartbreak and regret. But the lyrics tell a more specific and more interesting story.

The Surface Narrative

The narrator is a woman who has lived what most people would consider a glamorous, adventurous life. She's been to Nice, sailed the Nile, moved through Monaco and Monte Carlo, been to paradise — literally and metaphorically. She's had lovers, seen the world, lived freely and without constraint.

She's singing to another woman — a housewife, a mother — who is unhappy with her ordinary domestic life and contemplating leaving it behind for something more exciting. The narrator's message is: don't. I did all of that. I've been everywhere. And I've never been to me.

The Deeper Layer

The song's power comes from the gap between what the narrator's life looks like from the outside and what it felt like from the inside. She catalogues her experiences not as boasts but as confessions:

"I've been to paradise, but I've never been to me" — the central paradox. External experience and internal self-knowledge are not the same thing. You can travel the world and never arrive at yourself.
"I spent my life exploring the subtle whoring that costs too much to be free" — this line is startling in a pop ballad. The narrator isn't celebrating her freedom; she's recognising it as a form of transaction, a performance of liberation that carried a hidden price.
"I've been undressed by kings and I've seen some things that a woman ain't supposed to see" — again, not a boast. The tone is weary, not triumphant. She's seen the inside of a world that looked appealing from the outside and found it hollow.

The narrator isn't saying that domesticity is inherently superior to adventure, or that women should stay home. She's saying something more nuanced: that running toward experience as an escape from yourself doesn't work, because wherever you go, you're still there. The housewife she's addressing may be unhappy, but at least she has something real — a child, a partner, a life built on connection rather than flight.

Why It Resonates

The song touches a nerve that doesn't age. The tension between the life you're living and the life you imagine you could be living is universal. Social media has amplified this to an almost unbearable degree — everyone else's life looks like paradise, and yours looks like Monday morning. "I've Never Been to Me" is a reminder, delivered forty years early, that the curated highlight reel is not the whole story.

The song also captures something about regret that's unusual in pop music. Most songs about regret focus on specific mistakes — I shouldn't have left, I shouldn't have said that, I should have fought harder. Charlene's narrator regrets something more diffuse and harder to articulate: a way of living that prioritised accumulation of experience over depth of connection. It's not about one wrong turn. It's about an entire orientation toward life that, in retrospect, missed the point.

After the Hit

The success of "I've Never Been to Me" did not launch a lasting career for Charlene. This is the bittersweet coda to the story.

She released a follow-up album, Used to Be, in 1982. It didn't chart. A subsequent single, "It Ain't Easy Comin' Down," peaked at number 78 and disappeared. The music industry's machinery had churned out its moment for Charlene and moved on.

She continued to perform and record sporadically over the following decades, but never replicated the success. In interviews, she's been philosophical about being a one-hit wonder — a category she shares with dozens of artists who had one perfect song and spent the rest of their careers in its shadow.

The song itself, meanwhile, has had an extraordinary afterlife. It's been covered, sampled, and referenced across genres and decades:

It appeared in the Priscilla, Queen of the Desert soundtrack (1994), the beloved Australian film about drag queens crossing the outback, where it was performed as a lip-sync number — an ironic and affectionate recontextualisation.
It's been used in numerous film and television soundtracks as shorthand for a particular kind of wistful, middle-aged female regret.
It remains a karaoke staple worldwide, particularly in Asia, where the song's emotional directness resonates strongly.
It's been parodied and memed, which is its own form of cultural immortality.

The One-Hit Wonder Paradox

There's something worth saying about the phrase "one-hit wonder," because it's usually used dismissively — as if having only one successful song is a failure. But consider what it actually means: out of the millions of songs recorded every year, across all of human history, you created one that broke through the noise and embedded itself in the culture permanently. One song that people are still listening to, still crying to, still singing in karaoke bars forty years later.

Most musicians never achieve that. Most songs vanish within weeks of release. Charlene wrote (or more precisely, was given) a song that captured a universal human feeling with such precision that it transcended its genre, its era, and its commercial context. That's not failure. That's a kind of immortality.

Why I Keep Coming Back to It

I've listened to "I've Never Been to Me" probably a dozen times since that afternoon in the coffee shop. Each listen reveals something I didn't catch before — a vocal inflection, a lyric I'd glossed over, a shift in the narrator's tone from wistful to urgent.

The song works because it tells a truth that's hard to hear: that the grass isn't greener, that freedom without rootedness is just expensive loneliness, and that the ordinary life you're tempted to dismiss might be the paradise you're looking for. It's a message delivered by someone who learned it the hard way, speaking to someone who hasn't learned it yet.

Not a bad thing to be reminded of, over a cup of coffee, on a random Tuesday afternoon.

The Matrix and the Choice That Never Goes Away

Thu, 23 Apr 2026 00:00:00 GMT

I rewatched The Matrix recently. It's been over twenty-five years since it came out, and I've probably seen it half a dozen times, but this viewing hit differently. Not because of the bullet-dodging or the leather coats or the green code raining down the screen — those are still great — but because of a two-minute scene in a dingy room where a man in sunglasses holds out two pills and asks a question that, the older I get, feels less like science fiction and more like a daily choice.

The Film in Brief

For anyone who somehow hasn't seen it: The Matrix was released in March 1999, written and directed by the Wachowskis (Lana and Lilly Wachowski, credited at the time as the Wachowski Brothers). It stars Keanu Reeves as Thomas Anderson, a software programmer by day and hacker by night who goes by the alias Neo. He is plagued by a nagging sense that something is fundamentally wrong with the world — a feeling he can't articulate but can't shake.

He's contacted by Morpheus (Laurence Fishburne), a legendary figure in the hacker underground, who reveals the truth: the world Neo knows — his apartment, his office, the steak he eats for dinner — is a simulation. A neural-interactive computer program called the Matrix, generated by machines to keep the human race docile while their bodies are harvested for energy. The year isn't 1999. It's closer to 2199. The real world is a scorched wasteland. Everything Neo has ever experienced has been a dream fed directly into his brain.

Trinity (Carrie-Anne Moss) is Morpheus's lieutenant — a fierce, quiet presence who believed in Neo before he believed in himself. Agent Smith (Hugo Weaving) is the Matrix's enforcer — a sentient program designed to eliminate threats to the system, delivered with a chilling, mannered menace that remains one of the great villain performances in cinema.

The film was a cultural earthquake. It grossed over $460 million worldwide, won four Academy Awards (all technical: editing, sound, visual effects, sound effects editing), and introduced "bullet time" — a visual effect where time slows to a crawl while the camera orbits the action — that was immediately copied by every action film for the next decade. It drew on cyberpunk fiction, Hong Kong martial arts cinema, anime (particularly Ghost in the Shell), philosophy, and religious symbolism, blending them into something that felt genuinely new.

But the moment everyone remembers isn't an action sequence. It's a conversation.

The Choice

Morpheus sits Neo down in a cracked leather armchair. The room is dark, rain-streaked. Morpheus opens his hands. In the left: a blue pill. In the right: a red pill.

"You take the blue pill — the story ends, you wake up in your bed and believe whatever you want to believe. You take the red pill — you stay in Wonderland, and I show you how deep the rabbit hole goes."

He pauses, then adds:

"Remember: all I'm offering is the truth. Nothing more."

Neo takes the red pill. The Matrix dissolves. He wakes up naked in a pod of pink slime, his body atrophied, cables plugged into his spine, surrounded by millions of identical pods stretching to the horizon. The truth is not a gift. It's a horror.

The scene works because it's not really about Neo. It's about us.

What the Blue Pill Actually Offers

The blue pill is usually described as the coward's choice — ignorance, denial, the comfortable lie. But I think that reading is too simple, and the film is smarter than that.

Consider what the blue pill actually provides:

Stability. Neo's life in the Matrix isn't glamorous, but it's functional. He has a job, an apartment, a routine. The blue pill preserves all of that. The red pill destroys it — permanently, irreversibly, and in exchange for a life of war, scarcity, and sleeping in a hovercraft.

Relationships. Every person Neo knows exists in the Matrix. His colleagues, his neighbours, every human connection he's ever made. Taking the red pill means leaving all of them behind — not just physically, but epistemologically. They become, in a sense, non-real. How do you relate to people when you know their entire reality is a fabrication and they don't?

Functionality. The Matrix works. The steak tastes like steak. The sunset looks like a sunset. The simulation is, for all practical purposes, indistinguishable from reality. There's a famous scene later in the film where the character Cypher (Joe Pantoliano) — a red-pill taker who regrets his choice — makes a deal with Agent Smith to be re-inserted into the Matrix. Over a virtual steak dinner, he says:

"I know this steak doesn't exist. I know that when I put it in my mouth, the Matrix is telling my brain that it is juicy and delicious. After nine years, you know what I realize? Ignorance is bliss."

Cypher is the film's villain (he betrays his crew), but his logic is harder to dismiss than the film wants you to think. If the simulation is perfect, and the "real" world is objectively worse in every material way, what exactly is the argument for the red pill?

What the Red Pill Actually Costs

The red pill is usually framed as courage, awakening, enlightenment. And it is those things. But the film is honest about what it costs:

Comfort disappears. The real world in The Matrix is brutal. The food is tasteless protein slop. The clothing is rags. The ship is cramped, cold, and under constant threat. Every character who took the red pill traded material comfort for truth — and not one of them can go back.

Certainty disappears. Once you know the world isn't what it appears to be, you can never fully trust your perceptions again. The Matrix's most unsettling idea isn't that we might be in a simulation — it's that we'd have no way of knowing. The red pill doesn't give you certainty. It gives you a different kind of uncertainty.

Innocence disappears. There's a reason Morpheus warns Neo that he doesn't unplug people past a certain age — the shock is too great. The red pill isn't just information; it's a form of trauma. You can't unknow what you learn. The weight of it is permanent.

You become responsible. Before the red pill, Neo was a victim — someone trapped in a system he didn't create and didn't know about. After the red pill, he has knowledge, and knowledge creates obligation. He can't just live in the real world and ignore the billions of people still dreaming in pods. The truth makes demands.

Why the Metaphor Endures

The phrase "red pill / blue pill" has escaped the film entirely. It's become a freestanding cultural concept — one of those rare pieces of fiction that generates its own vocabulary. People use it in contexts that have nothing to do with the movie: politics, relationships, career decisions, health, finance.

The reason it endures, I think, is that it captures a pattern that repeats at every scale of human life:

The comfortable narrative vs. the uncomfortable truth.

We encounter this choice constantly, in forms both trivial and profound:

The job you know isn't right for you, but it pays well and changing would be hard. Blue pill: stay. Red pill: quit and face the uncertainty.
The relationship that looks fine from the outside but feels hollow from the inside. Blue pill: maintain the appearance. Red pill: have the conversation you've been avoiding.
The health symptom you've been ignoring because getting it checked might mean hearing something you don't want to hear. Blue pill: assume it's nothing. Red pill: make the appointment.
The belief you've held your entire life that doesn't survive contact with evidence. Blue pill: double down. Red pill: let the belief go and deal with the disorientation.

In every case, the blue pill offers the same thing: continuity. And in every case, the red pill offers the same thing: disruption in service of truth. The trade-off is always the same. Comfort now, at the cost of living in a fiction. Or pain now, in exchange for something real.

The Film's Blind Spot

There's a tension in The Matrix that I don't think the film fully resolves, and it's worth naming: the red pill is presented as objectively correct.

Morpheus isn't offering a perspective. He's offering the truth. The Matrix is a simulation, and the real world is real, and that's that. Neo's choice is framed as courage vs. cowardice, waking up vs. staying asleep, freedom vs. slavery.

But real life doesn't work that way. In real life, most "red pill" moments don't come with a Morpheus figure who actually knows the truth. They come from people who believe they know the truth — and who may be wrong, or partially right, or right about the problem but wrong about the solution. The metaphor is powerful precisely because it's clean: the truth is verifiable, the lie is total, the choice is binary. Reality is messier. Most of our blue-pill-vs-red-pill moments involve trading one incomplete understanding for another, hopefully less incomplete one.

The film's clarity is its strength as storytelling and its weakness as philosophy. It makes you feel the urgency of choosing truth over comfort. But it doesn't prepare you for the harder question: what do you do when you're not sure which pill is which?

Cypher Was Wrong (But Understandable)

I keep coming back to Cypher, the crew member who chooses to return to the Matrix. He's the film's Judas figure — he literally betrays his friends and gets several of them killed. But strip away the betrayal, and his existential position is interesting.

Cypher's argument is essentially: if subjective experience is all that matters, and the simulation provides better subjective experience than reality, then the simulation is the rational choice. This is a serious philosophical position. It's a version of hedonism — the idea that what matters is the quality of experience, not the metaphysical status of its source.

The film's counter-argument, embodied by Morpheus and Neo, is that truth has intrinsic value — that a life built on a lie is diminished even if the lie feels good, and that human dignity requires the freedom to see reality as it is.

I side with Morpheus, but I think the film would be richer if it took Cypher's position more seriously. The best counter to Cypher isn't "you're a coward" (which is how the film frames it). It's "a life you can't choose isn't a life, even if it's pleasant." The blue pill's fatal flaw isn't that the Matrix is unpleasant — it isn't. Its fatal flaw is that it removes the capacity for genuine choice. You can't choose to stay in the Matrix if you don't know you're in one. Cypher can make his choice because he already took the red pill. The billions of people in pods never got the option.

The blue pill isn't a choice. It's the absence of one.

What I Take From It Now

When I first saw The Matrix as a teenager, I thought it was about computers and kung fu. Rewatching it at this age, I think it's about the ongoing, never-settled negotiation between comfort and honesty.

The red pill isn't a one-time event. You don't take it once and spend the rest of your life in clarity. It's a choice that recurs — every time you encounter information that threatens your current model of the world, every time you have the option to look deeper or look away, every time someone offers you a comfortable explanation and you have to decide whether to accept it or push further.

The film's most honest moment is Morpheus's quiet caveat, the line that's easy to miss:

"Remember: all I'm offering is the truth. Nothing more."

Not happiness. Not success. Not comfort. Just truth — and the freedom and burden that come with it. That's the deal. Twenty-five years later, it's still the only deal worth taking.

Scaling the Peak: Why the Morning Trail is Our Favorite Family Ritual

Sun, 03 May 2026 00:00:00 GMT

If you live in Hong Kong, you know the city usually moves at two speeds: "Fast" and "I-needed-this-done-yesterday." But every weekend, my wife, my daughter, and I trade the concrete canyons for something a little greener.

Our destination? The Morning Trail.

Starting from the hallowed, scholarly grounds of HKU and ending at the summit of The Peak, this trail isn't just a hike; it’s a workout, a history lesson, and a family bonding session all rolled into one steep, paved ribbon of adventure.

The "Gateway" to the Clouds: Starting at HKU

We usually start our journey at Kotewall Road, right by the University of Hong Kong. There’s something poetic about starting a grueling uphill climb at a place of higher learning—mostly because by the time we reach the top, I’ve forgotten everything I ever knew except for the location of my water bottle.

The first stretch up Hatton Road is the ultimate "wake-up call." It’s paved (thankfully), but it’s got enough of an incline to let your calves know that the weekend pancakes weren't a great idea.

A Quick History Lesson (Without the Exam)

The Morning Trail follows a path that dates back to the early 20th century. Originally, this wasn't for influencers or toddlers; it was a military access road.

The "Boundary Stone": Keep an eye out for the City of Victoria boundary stone dating back to 1903. It marks the old limits of the city. Tell your kids it’s a magical marker, and they might actually stop to look at it!

Ghost Stories and Ruins: Pinewood Battery

About halfway up, we always take a detour to Pinewood Battery. If you’re hiking with kids, this is the "Golden Ticket."

Built in 1903, this was the highest coastal defense battery in Hong Kong. During World War II, it was heavily shelled by Japanese forces. Today, the ruins are safe to explore, overgrown with banyan roots that look like something out of Tomb Raider.

Pro Tip: My daughter loves playing hide-and-seek among the old bunkers. It’s the perfect spot to rest your legs while the kids burn off that "I-had-sugar-for-breakfast" energy.

The "Billion Dollar View"

Once you clear the steep sections and hit the junction of Lugard Road and Harlech Road, the hard work is over. You’ve officially reached the loop around the Peak.

We usually take Lugard Road. Why? Because it offers what I call the "Billion Dollar View." You’re walking on a narrow path suspended over the cliffside, looking straight down at the skyscrapers of Central, the shimmer of Victoria Harbour, and the mountains of Kowloon in the distance.

In the morning mist, it feels like you're walking in the clouds. It’s the moment where my wife and I finally stop huffing and puffing and remember why we love this city.

Why We Keep Coming Back

Is it steep? Yes. Will your daughter ask "Are we there yet?" at least twelve times? Probably.

But there is something magical about the Morning Trail. It’s the sound of the cicadas drowned out by your family’s laughter (and heavy breathing). It’s the way the air gets five degrees cooler the higher you go. And most importantly, it’s the ice cream or egg tarts waiting for us at the Peak Galleria once we finish.

Quick Stats for Your Next Trip:

Difficulty: 2/5 (Steep, but fully paved).
Duration: 1 to 1.5 hours (depending on how many "snack breaks" the little ones demand).
Best Time: Before 9:00 AM to beat the heat and the crowds.

See you on the trail!

Down the QR Rabbit Hole — A Weekend with Python & Pixels

Tue, 05 May 2026 00:00:00 GMT

I never thought much about QR codes — they were just those black-and-white squares I pointed my phone at. Then yesterday happened. I opened a Python terminal, typed four lines, and generated one myself. That was enough to make me want to understand everything.

A Little History: The Inventor Nobody Remembers

QR codes were invented in 1994 by Masahiro Hara and his team at Denso Wave, a Toyota subsidiary in Japan. At the time, automotive assembly lines were drowning in paperwork — each car component needed a barcode scan, but the old 1D barcodes (the zebra stripes you see on grocery items) could only hold about 20 alphanumeric characters. Tracking complex part numbers was a logistical nightmare.

Hara's insight was to go two-dimensional. Legend has it he was playing the board game Go one afternoon and noticed how the black-and-white stones on a grid could encode vast positional information. The analogy stuck, and the QR (Quick Response) code was born.

Fun Fact

Denso Wave deliberately chose not to enforce their QR code patent, releasing it as an open standard. That single decision is arguably what made QR codes ubiquitous worldwide. No licensing fees, no gatekeepers.

For years, QR codes remained niche — mostly used in Japanese manufacturing and logistics. Their mainstream breakthrough in the West came slowly, aided by smartphone cameras, and then dramatically accelerated in 2020 when contactless everything became essential. COVID menus, vaccine passes, payment terminals — QR codes were suddenly everywhere.

What a QR Code Actually Is

A QR code is a 2D matrix barcode — a grid of black and white squares (called modules) that encodes data using spatial patterns. Unlike a 1D barcode that only varies horizontally, a QR code carries information in both dimensions, which is why it can hold so much more.

Data Type	Maximum Capacity
Numeric only	7,089 digits
Alphanumeric	4,296 characters
Binary bytes	2,953 bytes
Kanji	1,817 characters

Anatomy of a QR Code

Every QR code — no matter what it encodes — contains the same structural components:

Component	Description
Finder Patterns	Three identical square patterns in the corners (top-left, top-right, bottom-left). Their 1:1:3:1:1 dark-light ratio lets scanners detect the code at any angle or rotation.
Alignment Patterns	Smaller squares placed within the data area (for Version 2+). They help correct for distortion when the code is on a curved surface or photographed at an angle.
Timing Patterns	Alternating black-and-white strips running between the finder patterns. They establish the coordinate system — like a ruler baked into the code itself.
Format Information	Strips adjacent to the finder patterns encoding the error correction level and mask pattern used. Stored twice for redundancy.
Data & Error Correction	The bulk of the QR code. Your actual payload is encoded here using Reed-Solomon error correction codewords.
Quiet Zone	A mandatory 4-module-wide white border around the entire code. Without it, scanners can't reliably find the edges against a background.

Versions, Sizes & Error Correction

QR codes come in 40 versions, ranging from Version 1 (21×21 modules) to Version 40 (177×177 modules). Each version step adds 4 modules to each side. More modules = more data capacity.

Version	Grid Size	Max Alphanumeric	Common Use
1	21×21	25 chars	Very short codes, labels
3	29×29	77 chars	Short URLs
5	37×37	154 chars	Contact info, short links
10	57×57	395 chars	Long URLs, vCards
25	117×117	1,367 chars	Dense data payloads
40	177×177	4,296 chars	Maximum capacity

One of the most underrated features of QR codes is error correction. Using Reed-Solomon error correction, a QR code can still be decoded even if part of it is obscured or damaged. There are four levels:

Level	Code	Recovery Capacity	Trade-off
Low	L	~7% can be restored	Smallest size, fragile
Medium	M	~15% can be restored	Good default
Quartile	Q	~25% can be restored	Recommended for logos
High	H	~30% can be restored	Largest, most robust

This is why you can put a logo in the center of a QR code and it still scans — the logo deliberately destroys some modules, and the error correction fills them back in. As long as less than 30% of the code is damaged (with level H), decoding succeeds.

How Data Gets Encoded — The Process Under the Hood

When you give a QR encoder a string like "https://example.com", here's roughly what happens before a single pixel is drawn:

1. Mode selection. The encoder inspects the data and picks the most efficient encoding mode. Purely numeric data uses a 10-bit-per-3-digit scheme. Alphanumeric (A–Z, 0–9, a handful of symbols) uses 11 bits per 2 characters. Binary/byte mode handles arbitrary UTF-8 at 8 bits per character.

2. Data encoding. The characters are converted to binary bit streams per the chosen mode. For example, in alphanumeric mode, "AC" becomes a number (10×45 + 12 = 462) encoded in 11 bits.

3. Error correction codewords. The data bits are divided into blocks, and Reed-Solomon codewords are computed for each block. These extra codewords carry enough redundancy to reconstruct damaged data.

4. Interleaving & final bit stream. Data and error correction blocks from different codeword sequences are interleaved — this spreads burst errors across multiple blocks, improving resilience.

5. Module placement. The bit stream is mapped onto the grid in a specific zigzag pattern, skipping functional regions (finder patterns, timing strips, etc.).

6. Masking. A mask pattern (one of 8 predefined XOR patterns) is applied to the data modules to ensure no large uniform regions exist — such regions confuse scanners. The encoder tries all 8 masks and picks the one with the best "penalty score."

Generating QR Codes with Python

Okay — theory mode off. Here's what actually got me down this rabbit hole. I installed the qrcode library and had a working QR code in under two minutes.

Installation

# Install the library (Pillow handles image rendering)
pip install qrcode[pil]

Basic Usage — The Lazy Way

import qrcode

# One-liner: generate and save
img = qrcode.make("https://example.com")
img.save("my_first_qr.png")

That's it. A 290×290 PNG with a perfectly valid QR code. I was almost disappointed by how easy it was — until I started digging into the configuration options.

Fine-Grained Control

import qrcode
from qrcode.constants import ERROR_CORRECT_H

qr = qrcode.QRCode(
    version=None,                      # None = auto-select smallest version that fits
    error_correction=ERROR_CORRECT_H,  # 30% damage recovery
    box_size=10,                       # pixels per module
    border=4,                          # quiet zone in modules (min = 4)
)

qr.add_data("https://example.com/super-long-url?with=parameters")
qr.make(fit=True)          # recalculate version to fit the data

img = qr.make_image(
    fill_color="black",
    back_color="white"
)
img.save("custom_qr.png")

# Pro tip: inspect what version was auto-selected
print(f"Version: {qr.version}")        # e.g. Version: 3
print(f"Grid size: {qr.modules_count}") # e.g. Grid size: 29

Batch Generation — QR Codes for a List of URLs

import qrcode
from pathlib import Path

urls = [
    ("home",    "https://example.com"),
    ("docs",    "https://docs.example.com"),
    ("contact", "https://example.com/contact"),
]

output_dir = Path("qr_codes")
output_dir.mkdir(exist_ok=True)

for name, url in urls:
    img = qrcode.make(url)
    img.save(output_dir / f"{name}.png")
    print(f"Generated {name}.png")

Styled QR Code with a Custom Color Scheme

import qrcode
from qrcode.image.styledpil import StyledPilImage
from qrcode.image.styles.moduledrawers.pil import RoundedModuleDrawer

qr = qrcode.QRCode(error_correction=qrcode.constants.ERROR_CORRECT_H)
qr.add_data("https://example.com")
qr.make(fit=True)

img = qr.make_image(
    image_factory=StyledPilImage,
    module_drawer=RoundedModuleDrawer(),   # rounded modules
    color_mask=qrcode.image.styles.colormasks.SolidFillColorMask(
        front_color=(0, 82, 204),    # deep blue modules
        back_color=(255, 255, 255)   # white background
    )
)
img.save("styled_qr.png")

Practical Warning

Styled and colored QR codes look great but test them on multiple devices before publishing. Low contrast ratios (e.g., light blue on white) can fail on older scanner apps. Rule of thumb: always ensure a dark-on-light contrast ratio of at least 4:1.

Real-World Use Cases Worth Knowing

What surprised me most after this deep-dive is the range of use cases QR codes actually handle well:

WiFi credentials — The WIFI:T:WPA;S:MyNetwork;P:MyPassword;; format lets phones join a network without typing a password. Useful for office guest networks.
vCards / contact sharing — A QR code encoding a vCard 3.0 payload lets someone scan and instantly add you to their contacts. No app required.
Cryptocurrency addresses — Every crypto wallet uses QR codes for addresses. Instead of typing a 42-character hex string, you scan. The QR code may also encode the amount and memo using the bitcoin:?amount=0.01 URI scheme.
TOTP / 2FA setup — Authenticator apps (Google Authenticator, Authy) use QR codes to import TOTP secrets. The payload follows the otpauth:// URI scheme.
Event ticketing — A signed QR code payload can encode a ticket ID plus an HMAC signature. The scanner verifies the signature — no internet needed for validation.

The Takeaway

What started as a throwaway afternoon experiment turned into a genuine appreciation for an elegantly designed standard. QR codes are thirty years old, patent-free, work offline, require no special hardware beyond a camera, carry error correction baked in, and are readable from any rotation. Honestly, that's a remarkable engineering achievement.

The Python qrcode library makes generation trivially easy, but now I understand why those four lines of code produce something a phone can decode reliably — the mathematics of Reed-Solomon, the geometry of finder patterns, and the deliberate choice to keep the spec open.

Next experiment on my list: decode a QR code from scratch, pixel by pixel, without any library. Wish me luck.

"The Sound of Silence" — A Song Written in Darkness That Lit Up the World

Wed, 22 Apr 2026 00:00:00 GMT

I first heard "The Sound of Silence" years ago, watching a movie. I don't remember which scene it was playing over, but I remember the feeling — that slow, creeping recognition that the song was describing something I'd felt but never been able to name. The melody was gentle, almost hymn-like, but the lyrics were doing something else entirely. They were angry. They were sad. They were prophetic in a way that felt uncanny for a song written in 1964.

I've come back to it many times since. And every time, it sounds less like a folk song from the sixties and more like a diagnosis of right now.

The Songwriters

Paul Simon

Paul Simon was born on October 13, 1941, in Newark, New Jersey, and grew up in the Kew Gardens Hills neighbourhood of Queens, New York. His father, Louis Simon, was a working musician — a bass player and bandleader — so music was not an abstraction in the household. It was a trade, a daily presence, a thing you practiced and got better at.

Simon began writing songs as a teenager. He was small, bookish, and intensely competitive — qualities that would define both his genius and his difficult reputation throughout his career. By his early twenties, he was already a sophisticated songwriter, drawing on folk, gospel, and early rock and roll, but pushing the lyrical content toward a literary complexity that was unusual for pop music at the time. He wasn't writing love songs. He was writing short stories.

His solo career and collaborative work would eventually produce some of the most acclaimed albums in popular music: Bridge over Troubled Water (1970), Graceland (1986), The Rhythm of the Saints (1990). He has won sixteen Grammy Awards, been inducted into the Rock and Roll Hall of Fame twice (as a solo artist and as part of Simon & Garfunkel), and is widely regarded as one of the finest songwriters in the English language.

But in 1963, he was twenty-one years old, largely unknown, and sitting in a dark bathroom writing a song about silence.

Art Garfunkel

Art Garfunkel was born on November 5, 1941, in Forest Hills, Queens — just a few miles from Simon. The two met at school when they were eleven years old and discovered an immediate musical chemistry. Where Simon was the writer and instrumentalist, Garfunkel was the voice — a pure, high tenor that could make the simplest melody sound like it was floating.

Garfunkel studied mathematics and architecture at Columbia University, and there was always something of the mathematician in his approach to singing: precise, structural, interested in the architecture of harmony. His voice was the instrument through which Simon's dense, literary lyrics became emotionally accessible. Without Garfunkel's voice, Simon's songs risked being too cerebral. Without Simon's songs, Garfunkel's voice risked being too beautiful and too empty. Together, they were greater than the sum of their parts — which made it all the more painful when the partnership fractured.

Their professional relationship was famously volatile. They split in 1970 at the peak of their fame, reunited for a legendary concert in Central Park in 1981 (attended by an estimated 500,000 people), split again, reunited for tours, and split again. The pattern repeated for decades. The creative tension between them — Simon's need for control, Garfunkel's need for recognition — was both the engine and the poison of the partnership.

How the Song Was Written

In late 1963, Paul Simon was twenty-one and feeling the weight of a world that seemed to be coming apart. President Kennedy had been assassinated on November 22, 1963. The event shook the country in a way that is difficult to overstate — it was the first major national trauma of the television age, watched and re-watched by millions. The sense of shock, grief, and disorientation was pervasive.

Simon has described writing "The Sound of Silence" in his bathroom, in the dark. He would turn off the lights, sit with his guitar, and let the words come. The darkness, he said, helped him concentrate — it removed distractions, collapsed the world down to nothing but the sound of the guitar and the rhythm of the words.

"I used to go off in the bathroom, because the bathroom had tiles, so it was a slight echo chamber. I'd turn on the water so that it would mask the sound so that nobody else could hear, and I'd play."

The song emerged over several months in late 1963 and early 1964. Simon was drawing on the Kennedy assassination, on his own sense of alienation, and on a broader feeling that people were losing the ability — or the willingness — to communicate honestly with each other. The "silence" in the title isn't peace. It's the absence of genuine connection. It's people talking without saying anything, hearing without listening, surrounded by others and completely alone.

The Song

The lyrics of "The Sound of Silence" are structured as a vision — a dream, or perhaps a waking nightmare. The narrator greets darkness as "my old friend," immediately establishing a relationship with isolation that is intimate, familiar, and resigned.

Verse by Verse

"Hello darkness, my old friend / I've come to talk with you again" — The song opens not with a complaint but with a greeting. Darkness is personified as a companion, someone the narrator returns to. This isn't a song about discovering loneliness. It's about living with it.

"Because a vision softly creeping / Left its seeds while I was sleeping" — The vision is involuntary. It plants itself in the narrator's mind without permission, the way anxieties and premonitions do. It's not a choice to see what he sees. It's an imposition.

"In restless dreams I walked alone / Narrow streets of cobblestone" — The imagery is almost medieval — narrow, confined, solitary. The world of the dream is not open or liberating. It's claustrophobic.

"People talking without speaking / People hearing without listening" — This is the heart of the song's critique. Communication has become performance. Words are exchanged, but meaning is not. Everyone is broadcasting; no one is receiving. Written in 1964, these lines are almost unbearably prescient in the age of social media, 24-hour news cycles, and infinite content.

"People writing songs that voices never share" — Even the artists, the people whose job it is to communicate, are failing. Songs are written but never truly heard. The creative act itself has become hollow.

"And the people bowed and prayed / To the neon god they made" — The "neon god" is consumerism, television, spectacle — whatever bright, artificial thing has replaced genuine spiritual or human connection. The people worship it not because they believe in it, but because they have nothing else.

"And the sign said, 'The words of the prophets are written on the subway walls and tenement halls'" — The prophets are not on television or in churches. They're in the margins — the graffiti artists, the poor, the overlooked. The truth is being spoken, but in places no one with power bothers to look.

"And whispered in the sounds of silence" — The final line brings the song full circle. The truth is there, but it's quiet, easily drowned out, easily ignored. You have to be willing to sit in the silence to hear it.

The Two Versions

"The Sound of Silence" was released twice, and the difference between the two versions is one of the most famous stories in popular music.

The Acoustic Version (1964)

Simon and Garfunkel recorded the song for their debut album, Wednesday Morning, 3 A.M., released in October 1964 on Columbia Records. The album was produced by Tom Wilson, a staff producer at Columbia who would later become famous for producing Bob Dylan's Bringing It All Back Home and albums by the Velvet Underground and Frank Zappa.

The original recording was sparse and acoustic — two voices and a guitar. The album was a commercial failure. It sold poorly, received little attention, and Simon and Garfunkel effectively broke up. Simon moved to England, where he played folk clubs and recorded a solo album, The Paul Simon Songbook. Garfunkel returned to his studies at Columbia University.

The partnership appeared to be over.

The Electric Version (1965)

In early 1965, Tom Wilson noticed that "The Sound of Silence" was getting unexpected radio play in several markets, particularly around Boston and Florida. Without consulting Simon or Garfunkel — who were on different continents and not speaking — Wilson went back into the studio and overdubbed electric guitar, bass, and drums onto the existing acoustic recording.

This was an audacious, arguably outrageous move. Wilson essentially remixed the song into a folk-rock track without the artists' knowledge or consent, inspired by the success of the Byrds' electrified version of Bob Dylan's "Mr. Tambourine Man." He heard the same potential in "The Sound of Silence" — a folk song that could cross over to a rock audience if given the right sonic frame.

The overdubbed version was released as a single in September 1965. By January 1966, it had reached number 1 on the Billboard Hot 100. Simon, still in England, heard about his own hit single on the radio. He flew back to the United States. Simon & Garfunkel reunited, and the rest is history.

The irony is exquisite: one of the most significant artistic partnerships in popular music was resurrected by a producer's unauthorised remix.

The Movie Connection

For many people — myself included — "The Sound of Silence" is inseparable from Mike Nichols' 1967 film The Graduate, starring a young Dustin Hoffman as Benjamin Braddock, a college graduate who returns home to an affluent suburb with no idea what to do with his life.

Nichols used Simon & Garfunkel's music extensively throughout the film, including "The Sound of Silence," which plays over the opening credits as Benjamin rides an airport moving walkway — passive, expressionless, carried forward by a mechanism he didn't choose. The song also appears at key moments of Benjamin's alienation and drift.

The pairing was perfect. Benjamin's condition — surrounded by people, unable to connect with any of them, suffocated by expectations he can't articulate — is precisely what the song describes. The film gave the song a visual vocabulary: the swimming pool where Benjamin floats in a wetsuit while his parents' friends watch from above, the hotel room where he stares at the ceiling, the church where he finally breaks through the glass.

The Graduate introduced "The Sound of Silence" to an audience far beyond the folk-music world. For an entire generation, the song became the soundtrack of educated, comfortable, purposeless despair — the feeling of having everything and wanting none of it.

Why the Song Endures

"The Sound of Silence" has been covered hundreds of times, in genres ranging from heavy metal to classical. Disturbed's 2015 cover — a dramatic, operatic reinterpretation by vocalist David Draiman — went viral, accumulated over two billion views on YouTube, and introduced the song to yet another generation. Simon himself praised the cover, calling it "a really powerful thing."

But the song endures not because of its covers or its film placements. It endures because it describes a condition that has only become more acute since 1964.

The failure of communication. We have more tools for connection than at any point in human history — social media, instant messaging, video calls, AI chatbots — and yet loneliness is at epidemic levels. The "people talking without speaking, people hearing without listening" that Simon described as a vision has become a literal description of how many people experience daily life.

The worship of spectacle. The "neon god" has evolved from television to smartphones, from billboards to infinite-scroll feeds. The basic dynamic is unchanged: we create bright, addictive, meaning-free content and then worship it because the alternative — sitting in silence, facing ourselves — is too uncomfortable.

The marginalisation of truth. The prophets are still writing on subway walls. The most honest, most urgent voices in any society are rarely the ones with the biggest platforms. The song's insistence that truth lives in the margins, not the mainstream, remains as relevant as it was sixty years ago.

The Sound of Silence in 2026

I think about this song when I'm in a crowded room where everyone is looking at their phone. I think about it when I read a comments section full of people shouting past each other. I think about it when I catch myself scrolling through content — not reading it, not engaging with it, just consuming it — the way you might leave a television on for background noise.

The song doesn't offer a solution. That's part of its power. Simon doesn't tell you how to break through the silence. He just describes it with such precision that you can't pretend it isn't there. The recognition itself is the point — the willingness to sit in the dark bathroom, turn off the distractions, and listen to what the silence is actually telling you.

Sixty years on, the song is still waiting for us to hear it. Really hear it. And most of us are still talking without speaking.

Step Into the Sunlight — Why 15 Minutes Outside Can Change Your Day

Thu, 07 May 2026 00:00:00 GMT

I stepped outside today around noon. No particular plan — just felt sluggish after a morning of screen time and decided to walk around the block. The sun was high, the air was warm, and within ten minutes something shifted. The mental fog lifted. My shoulders dropped. By the time I sat back down at my desk, I felt like a different person. Not caffeinated-different — reset-different. Calmer, sharper, more present.

It's a small thing, walking outside in the middle of the day. But I keep forgetting how much it matters, and I suspect I'm not alone. So I went down the rabbit hole: why does sunlight make us feel so much better, and what exactly is it doing to our bodies?

The answers are more interesting — and more urgent — than I expected.

We're an Indoor Species Now

Here's a number that stopped me: the average person in a developed country now spends roughly 90% of their time indoors. That figure comes from the EPA and has been echoed by studies in Europe and Asia. We wake up in a house, commute in a car or train, work in an office, and come home to screens. Many of us go entire weekdays without meaningful sun exposure.

This is historically unprecedented. For the vast majority of human history, we lived and worked outdoors. Our biology evolved under the sun — our hormones, our immune systems, our sleep cycles, our moods. We moved indoors at industrial scale only in the last century or so, and our bodies haven't caught up.

The result is what some researchers call "indoor sickness" — not a formal diagnosis, but a constellation of problems that correlate strongly with insufficient light exposure: poor sleep, low mood, weakened immunity, vitamin deficiencies, and chronic fatigue. Sound familiar?

What Sunlight Actually Does

Sunlight isn't just "nice weather." It triggers a cascade of biological processes that affect nearly every system in the body. Here are the big ones:

1. Vitamin D Synthesis

This is the one most people know about, but the details are worth understanding. When UVB rays from the sun hit your skin, they convert a cholesterol compound (7-dehydrocholesterol) into vitamin D3, which your liver and kidneys then process into its active form.

Vitamin D is technically a hormone, not a vitamin, and it's involved in an extraordinary range of functions:

Bone health — it regulates calcium and phosphorus absorption. Without it, bones weaken (rickets in children, osteomalacia in adults).
Immune function — vitamin D modulates both the innate and adaptive immune systems. Deficiency is linked to higher susceptibility to infections, including respiratory illness.
Mood regulation — vitamin D receptors are found throughout the brain, particularly in areas involved in mood and emotion. Low vitamin D levels are consistently associated with higher rates of depression.
Muscle function — deficiency causes muscle weakness and pain, which is often misattributed to aging or inactivity.

An estimated 1 billion people worldwide are vitamin D deficient or insufficient. In the UK, it's especially common during winter months when UVB intensity is too low for meaningful synthesis. But even in summer, office workers who eat lunch at their desks often don't get enough.

The recommended approach: 10–30 minutes of midday sun on exposed skin (arms, legs, face), several times a week. The exact time depends on your skin tone — darker skin needs more time because melanin reduces UVB absorption. You don't need to burn. You just need to be outside.

2. Serotonin and Mood

Sunlight exposure triggers the brain to produce serotonin — the neurotransmitter most associated with feelings of well-being, calm, and focus. This happens through the eyes: when bright light hits the retina, it signals the brain via the retinohypothalamic tract to ramp up serotonin synthesis.

This is the mechanism behind Seasonal Affective Disorder (SAD), the well-documented pattern of depression that occurs in winter months when sunlight is scarce. SAD affects an estimated 5% of the population severely and up to 20% in milder forms (the "winter blues").

But you don't need a clinical diagnosis to feel the effect. Even on a normal workday, the difference between getting bright outdoor light and staying under fluorescent office lighting is measurable. Studies have found that workers with windows and natural light exposure report better mood, fewer headaches, and less eye strain than those in windowless environments. And even window light is a fraction of what you get by actually going outside — indoor light is typically 100–500 lux, while outdoor light on a cloudy day is 10,000+ lux and direct sunlight can reach 100,000 lux.

That ten-minute walk at noon? It wasn't placebo. My brain was literally manufacturing more serotonin.

3. Circadian Rhythm Regulation

Your body runs on a roughly 24-hour internal clock — the circadian rhythm — and sunlight is its primary calibration signal. Morning light exposure, in particular, tells the suprachiasmatic nucleus (a tiny region in the hypothalamus) that it's daytime. This sets off a chain:

Cortisol rises in the morning (the healthy kind — it wakes you up and makes you alert).
Melatonin is suppressed during daylight hours, keeping you awake.
Melatonin production begins 12–14 hours after your morning light exposure, making you sleepy at the right time.

If you don't get enough bright light during the day — especially in the morning — this clock drifts. Melatonin release gets delayed. You struggle to fall asleep at night, wake up groggy, and reach for caffeine to compensate. It's a cycle that millions of people are stuck in without realising that the root cause is not enough light, not too little sleep.

Neuroscientist Andrew Huberman has been particularly vocal about this. His practical advice: get 10 minutes of outdoor light within the first hour of waking, and again in the late afternoon. Even on overcast days, outdoor light is bright enough to set the circadian clock. Sunglasses reduce the effect, so he recommends going without them for that morning exposure (obviously, don't stare at the sun).

4. Nitric Oxide and Blood Pressure

This one surprised me. When sunlight — specifically UVA rays — hits your skin, it triggers the release of nitric oxide from stores in the skin into the bloodstream. Nitric oxide is a vasodilator: it relaxes blood vessel walls, lowering blood pressure.

A landmark 2014 study from the University of Edinburgh found that a single session of UVA exposure equivalent to 30 minutes of midday sun significantly lowered blood pressure in volunteers. The effect was independent of vitamin D and lasted for some time after the exposure ended.

The researchers argued that the cardiovascular benefits of moderate sun exposure might outweigh the skin cancer risk for most people — a statement that runs counter to decades of "avoid the sun" public health messaging. The lead author, Dr. Richard Weller, put it provocatively: "We suspect that the benefits to heart health of sunlight will outweigh the risk of skin cancer."

This doesn't mean baking in the sun for hours. It means the dogma of total sun avoidance may itself carry health risks.

5. Immune Function Beyond Vitamin D

Sunlight affects immunity through pathways that go beyond vitamin D. Research published in Scientific Reports in 2016 found that blue light in sunlight energises T cells — a key component of the immune system — causing them to move faster and respond more effectively to threats. The researchers described it as sunlight literally making immune cells more active.

There's also evidence that regular moderate sun exposure is associated with lower rates of certain autoimmune diseases, including multiple sclerosis and type 1 diabetes, with prevalence increasing at higher latitudes where sunlight is weaker. The relationship is complex and not fully understood, but the geographic pattern is consistent and hard to explain by other factors alone.

How Much Is Enough?

The research points to a surprisingly modest amount:

10–30 minutes of midday sun, several times a week, is sufficient for vitamin D synthesis in most people. Darker skin tones need the higher end of that range.
Morning light exposure (within the first hour of waking) is critical for circadian rhythm — even 10 minutes makes a measurable difference.
You don't need direct sunlight for the circadian and serotonin benefits. Outdoor light on a cloudy day is still 10–50 times brighter than indoor lighting.
You don't need to tan or burn. The point is regular, moderate exposure — not weekend marathon sunbathing sessions.

The key insight is that consistency matters more than duration. A daily 15-minute walk outside does more for your health than an occasional afternoon at the beach.

The Sunscreen Nuance

I want to be careful here because the "sunlight is good" message can be taken too far. Skin cancer is real, and excessive UV exposure — particularly sunburns — is a well-established risk factor for melanoma and other skin cancers.

But the conversation has become more nuanced in recent years. Dermatologists increasingly acknowledge that total sun avoidance carries its own health costs. The current consensus is evolving toward a middle ground:

Brief, unprotected exposure (10–20 minutes, depending on skin type and UV index) for vitamin D and other benefits.
Sunscreen for longer exposure, especially if you're fair-skinned, at high altitude, or near reflective surfaces like water or snow.
Never burn. Sunburns, especially in childhood, are the primary skin cancer risk factor. Moderate exposure without burning is the goal.

What I'm Doing Differently

Writing this post has been a useful exercise in convincing myself to do something I already know works. Here's my plan, and it's deliberately simple:

Morning light — I'm going to step outside for 10 minutes with my coffee before sitting down to work. No sunglasses, no phone.
Midday walk — even if it's just around the block. Today proved that this works. The trick is making it a default, not a decision.
Weekend outdoor time — I already do this sometimes, but I want to be more intentional about it. A park, a walk, a bench in the sun. Not every weekend has to be productive.

None of this is revolutionary. None of it requires equipment, memberships, or willpower. It's just… going outside.

The Bigger Picture

There's something almost absurd about the fact that we need to remind ourselves to go outside. For most of human history, the problem was the opposite — finding shelter, shade, protection from the elements. Now we've built environments so comfortable and so consuming that we can go days without meaningful exposure to the thing that powers most life on Earth.

The research is clear: sunlight isn't optional. It's a biological input that our bodies require for basic functions — sleep, mood, immunity, bone health, cardiovascular health. We didn't evolve to live under fluorescent lights and blue-tinted screens, and the consequences of doing so are showing up in population-level data on depression, sleep disorders, vitamin deficiency, and chronic disease.

But the fix is free, and it takes fifteen minutes.

Step outside. The sun's still there.

Reclaiming the Spirit: My Three-Hour Ascent of Lion Rock

Tue, 21 Apr 2026 00:00:00 GMT

Last Saturday, while most of the city was still stirring over its first cup of nai cha, I found myself standing at the foot of one of Hong Kong’s most enduring icons. Now that I'm middle-aged, my weekends have shifted. The late-night dimly lit bars of my younger years have been replaced by the early-morning golden light of our country parks.

Being 40ish, I've found that these treks are less about speed and more about perspective. I spent exactly three hours on the trail last Saturday—from the first step up the concrete stairs to the final descent back into the urban sprawl. It wasn’t a race, and it certainly wasn't a "stroll," but it was exactly what the soul (and the joints) needed.

The Climb: A Tale of Three Stages

The Lion Rock hike is a classic for a reason. It’s accessible, punishing, and rewarding all at once. For those who haven't done it recently, the route from Wong Tai Sin through Shatin Pass Road is the way to go.

The Ascent: It starts with a steady, rhythmic climb. This is where you question your fitness levels.
The Ridge: Once you hit the MacLehose Trail Section 5, the path levels out briefly, teasing you with glimpses of the Kowloon Peninsula through the trees.
The Peak: The final scramble to the "head" of the lion is where the magic happens. Standing at 495 meters, you aren't just looking at a view; you’re looking at the heartbeat of Hong Kong.

Feature	Details
Duration	~3 Hours (including photo stops)
Difficulty	3.5 / 5 (Those steps are no joke)
Start Point	Wong Tai Sin MTR / Shatin Pass Road
Best Time	Before 9:00 AM to beat the heat and the crowds

More Than Just Granite: The "Lion Rock Spirit"

As I sat on the ridge, looking down at the dense grids of Wong Tai Sin and the distant shimmering towers of Central, I couldn't help but think about what this mountain means to us.

In Hong Kong, Lion Rock isn't just a geological formation; it is a cultural compass. Many of us grew up hearing about the "Lion Rock Spirit" (獅子山精神). It’s a term rooted in the 1970s, popularized by the RTHK drama Below the Lion Rock.

To the older generation, it represented the "can-do" attitude—the grit and solidarity of refugees and workers who built this city from nothing. To those of us in our middle-age, it’s a reminder of perseverance. In a world that feels increasingly fast-paced and unpredictable, the mountain remains unmoved. It reminds us that whether the economy is up or the weather is down, we keep climbing. We put aside discord, we work hard, and we write our own stories.

Why Hiking is the Middle-Aged Secret Weapon

Let’s talk about the physical reality. In my 40ish years, I’ve realized that my body doesn't bounce back like it used to. But hiking? Hiking is the "Goldilocks" of exercise—it’s just right.

1. Low-Impact, High-Reward

Unlike pounding the pavement on a run, hiking on natural trails is gentler on the knees. The uneven terrain forces your "stabilizer muscles" to wake up. It improves balance and core strength without the high-impact jarring of a treadmill.

2. The "Green" Therapy

There is a clinical term for this—shinrin-yoku or "forest bathing." Being surrounded by the lush greens of the Country Park regulates our parasympathetic nervous system. It lowers cortisol (the stress hormone) and clears the mental "fog" that accumulates after a 50-hour work week.

3. Cardiovascular Resilience

Three hours of varied incline is a masterclass in zone-2 cardio. It strengthens the heart, improves circulation, and—let’s be honest—allows for that extra dim sum basket on Sunday morning without the guilt.

Final Reflections

From the paved paths of the lower slopes, to the craggy rocks of the middle ridge, and finally to the soaring heights of the summit—every level of the hike offered a different perspective on the city I call home.

If you haven’t been up there lately, go. Don’t worry about the "trail runners" zooming past you in their $2,000 gear. Take your time. Bring plenty of water (I polished off 1.5 liters easily).

We often look at the skyline from the Tsim Sha Tsui promenade, looking up. But there is something profoundly grounding about standing on the Lion’s back and looking down. It reminds you that while the city is big, your ability to conquer its challenges is even bigger.

See you on the trails.