DEV Community: Reece Harris

Turn Any File Into a Art Masterpiece!

Reece Harris — Mon, 14 Jul 2025 21:47:44 +0000

Ever wanted to see your data? Not just in boring old spreadsheets or text files—but as a vibrant, colorful image? With my latest side project, RGBA Data Encoder, you can now transform any file into a PNG by packing raw bytes into pixel channels!

How It Works

Each pixel in a PNG has four channels: Red, Green, Blue, and Alpha (RGBA). My encoder takes your file, converts it to hexadecimal, and then stores two hex characters per channel—meaning one pixel = four bytes of your original data.

The result? A lossless, perfectly reconstructable image version of your file. Dodgy compression, no tricks—just pure, unadulterated data turned into art.

Example Time!

Doom (PDF) → 4.8MB (original 6.2MB) -1.4MB (smaller than original!)
Bad Apple (MP4) → 37.8MB (original 21.7MB) +16.1MB (way bigger, but way cooler!)

"Doom, but make it abstract expressionism."

"The entire Bad Apple video… as a single, chaotic image."

Why Would You Do This?

Steganography? Maybe.
Archival storage? If you really like PNGs.
Just for fun? Absolutely.

This isn’t about efficiency—it’s about seeing data in a new way. Want to hide a secret message in plain sight? Turn your resume into a modern art piece? Encode your favorite meme into another meme? The possibilities are endless (and slightly ridiculous).

⚡ Try It Yourself

The encoder & decoder are super simple—just a few lines of JavaScript. Want to play around with it? Star the repo and turn your files into pixel art today!

(And yes, it’s 100% reversible. Your data is safe… just very colorful.)

🔗 Check it out here!

The Hidden Challenge of Disposable Email Detection (And How You Can Help)

Reece Harris — Mon, 14 Jul 2025 11:53:38 +0000

Disposable email services have become a double-edged sword for developers. While they offer privacy-conscious users a way to avoid spam, they also enable abuse of online services. That's why many platforms try to block them—but maintaining an accurate disposable domain list is harder than it looks.

The Scale of the Problem

Our open-source project currently tracks 205,824 known disposable domains, but here's the catch:

New disposable providers emerge daily (often with legitimate-sounding domains)
Legitimate domains sometimes get falsely flagged (causing real users problems)
Providers constantly rotate domains to bypass filters

This creates an endless game of cat-and-mouse that no single maintainer can handle alone.

How We Keep Up

Our system combines:

Automated scraping of known disposable providers
Community-contributed lists from various sources
Manual verification of disputed domains

But automation alone isn't enough. The most valuable contributions come from humans spotting false positives—like when a legitimate email service gets mistakenly blacklisted.

Why This Matters

Every incorrectly flagged domain means:

🚫 Legitimate users locked out of services
⏳ Developer time wasted handling support tickets
🔄 Constant maintenance overhead

Join the Effort

We've intentionally kept contribution barriers low because:

✅ No coding experience needed to report false flags

✅ Small corrections have big impact (single domains help real users)

✅ Great first open-source contribution

How to help:

Review the allow_list.txt for missing legitimate domains
Report new disposable providers you encounter
Help improve our scrapers if you have technical skills

This isn't about promoting a tool—it's about maintaining a community resource that helps balance privacy and security across the web. The more eyes we have on this, the better it works for everyone.

Contribute to the project here →

Footnote: Special thanks to all current contributors—your pull requests directly reduce false positives for thousands of applications using this data.

The World's Largest Disposable Email Domain List – How We Keep It Updated

Reece Harris — Thu, 10 Jul 2025 14:47:56 +0000

Most disposable email domain lists become outdated quickly as temporary email services constantly rotate domains. Our solution? A fully automated system that aggregates data from multiple trusted sources and scrapes providers directly – currently tracking over 180,000 disposable domains.

How We Build the List

1. Automated Aggregation from Trusted Sources (Weekly)

We pull data from 6+ authoritative disposable domain lists via GitHub Actions, including:

📜 Text-based lists:

📊 Structured formats:

DeviceAndBrowserInfo's disposable API (JSON)
Laravel-Disposable-Email (JSON)
TempEmailDomainMXRecords (CSV)

✅ Allowlist integration:

We cross-check with disposable-email-domains/allowlist to remove false positives.

2. Direct Scraping of Temporary Email Services (Daily)

We actively monitor 10+ disposable email providers (and growing) to catch newly rotated domains that haven't yet appeared in public lists.

This two-pronged approach ensures:

🔹 Maximum coverage from established lists

🔹 Timely detection of newly created domains

🔹 Minimal false positives through allowlisting

Keeping the List Clean

To prevent legitimate domains from being blocked:

All entries are checked against our allowlist
Major email providers (Gmail, Outlook, etc.) are automatically excluded
Users can submit corrections via allow_list.txt

Access the Data

Use it in your projects via:

npm install throwaway-email@latest

Or use the raw domain list directly:

📁 domains.txt

Help Improve the List

We welcome contributions to:

Add new disposable email sources
Improve scrapers for temporary email services
Report false positives

Contribute on GitHub →

A Faster Approach to Email Validation: Why We Ditched Regex

Reece Harris — Thu, 10 Jul 2025 14:39:39 +0000

Email validation is a common requirement for nearly every web application, yet most implementations rely on regular expressions—an approach that's often slower and less accurate than it needs to be. Today, I want to share an alternative method that not only validates emails more efficiently but also checks against disposable domains—all while being faster than traditional regex-based solutions.

The Problem with Regex for Email Validation

Most email validation libraries use regular expressions to check if an email address conforms to RFC standards. While regex is powerful, it has some drawbacks:

Performance overhead: Complex regex patterns can be slow, especially when validating millions of emails.
Incomplete RFC compliance: Many regex patterns either over-restrict (blocking valid emails) or under-restrict (allowing invalid formats).
Lack of additional checks: Regex alone can't verify whether an email domain is disposable or temporary.

A Different Approach: Bitmask Logic and Set Lookups

Instead of relying on regex, we implemented a validation method that:

Uses bitmask comparisons for character validation (faster than regex matching).
Checks RFC compliance by directly validating email structure (length, @ position, dot rules).
Includes disposable domain detection with a preloaded database of 180,000+ known temporary email providers.
Optionally verifies TLDs against ICANN's official list.

The result? A 13.7% performance improvement over the fastest regex-based validator we tested, while also providing more thorough validation.

How It Works

The validation process follows these steps:

Basic structural checks (length, @ position, local/domain part sizes).
Local part validation (alphanumeric + special characters, no invalid dot placements).
Domain validation (correct label formatting, hyphen rules, TLD length).
Disposable domain check (instant lookup against a Set of known temporary email domains).
TLD verification (optional check against ICANN-recognized top-level domains).

Because we avoid regex, the validation logic is both faster and more transparent—you can see exactly which rules are being enforced.

Real-World Performance

In benchmarks against popular email validation libraries, this approach consistently outperformed regex-based solutions:

Library	Avg. Time per Validation
throwaway (this method)	155.73 ns
email-validator	180.47 ns
@shelf/is-valid-email	404.70 ns

The difference becomes significant when validating large datasets—for example, processing 1 million emails would take:

~156ms with this method
~180ms with email-validator
~405ms with @shelf/is-valid-email

Disposable Email Detection

Beyond basic validation, this method includes real-time disposable domain checking. The database is automatically updated weekly by scraping known sources of temporary email providers, ensuring new domains are detected quickly.

If a domain is incorrectly flagged (e.g., a legitimate service is mistakenly marked as disposable), users can contribute fixes by submitting pull requests to an allow list.

Open and Community-Driven

The project is open-source (GPL-3.0 licensed) and encourages community contributions:

Adding new disposable domains (via automated scrapers or manual submissions).
Improving validation logic (e.g., better handling of quoted strings or internationalized emails).
Fixing false positives in the disposable domain list.

Try It Out

If you're looking for a faster, more comprehensive email validation solution, you can test it with:

npm install throwaway-email@latest

Or use the raw domain list directly from the GitHub repository.

Example Usage

import validEmail from 'throwaway-email';

// Basic validation (TLD + disposable check)
validEmail("user@example.com"); // true
validEmail("user@tempmail.com"); // false (disposable)
validEmail("user@invalid.tld"); // false (unknown TLD)

Final Thoughts

Regex isn't always the best tool for the job—sometimes, a more direct approach can yield better performance and accuracy. If you're working on a project that requires robust email validation, consider trying this method and contributing to its improvement.

What do you think? Have you encountered performance issues with regex-based validation before? Let us know your experiences!

View the project on GitHub | Contribute to the domain list

Why on-boarding processes can be a snooze fest (and how to fix It with svelte)

Reece Harris — Tue, 25 Mar 2025 09:56:50 +0000

Let’s face it: onboarding processes in web applications can be a drag. You’ve got forms to fill out, instructions to read, maybe a progress bar that crawls while the user waits for some backend magic to happen. As developers, we pour our hearts into building sleek, functional apps, but when it comes to onboarding, we often leave users staring at a screen, twiddling their thumbs. Why? Because waiting sucks, and static loading screens or walls of text don’t exactly scream “fun.”

The truth is, onboarding doesn’t have to be boring. It’s a chance to hook users, show off your app’s personality, and keep them engaged while they get set up. But too often, we fall into the trap of “good enough” design—spinners, generic messages, or a multi-step form that feels like a tax return. Users aren’t here for that. They want to dive in, not wait around.

Waiting Kills the Vibe

Picture this: a new user signs up for your app. They’re excited! They click “Get Started,” and… they’re hit with a loading screen. Or maybe a “Verify Your Email” prompt that leaves them hanging. Those little moments of downtime might only last a few seconds, but to the user, it feels like forever. Studies show attention spans are shrinking—people bounce if they’re not entertained or engaged fast. In web dev, we’re so focused on functionality that we forget: boring onboarding can lose users before they even begin.

So, how do we fix it? Sure, we could optimize load times or streamline steps (and we should), but there’s another angle: make the wait fun. Enter a wild idea—games. Yep, games! Why not give users something to do while they’re stuck in that onboarding limbo? It’s a small twist that can turn a mundane process into a memorable one.

Meet "svelte-games"

I’ve been tinkering with this problem myself, and I’m excited to share my latest open-source project: svelte-games. It’s a lightweight package designed for Svelte developers who want to sprinkle some joy into their apps. The idea is simple: drop in a game component wherever you’d normally have dead space—like during onboarding—and let users play while they wait.

Here’s how easy it is to use:

<script lang="ts">
  import Snake from 'svelte-games/Snake.svelte';
</script>

<Snake />

Boom! With one line, you’ve got a fully functional Snake game right in your Svelte app. No fuss, no complex setup—just a ready-to-go component that’s lightweight and customizable. Imagine sticking this in your onboarding flow: instead of a “Please wait…” message, users get to chase a high score while their account syncs. It’s a tiny addition that screams, “Hey, we’re different—and we care about your experience.”

🎮 Demo some of the games here.

Why Games? Why Svelte?

Games are universal. They’re quick to grasp, require no explanation, and instantly pull people in. Pair that with Svelte’s simplicity and performance (no heavy runtime overhead, just pure compiled JS), and you’ve got a match made in heaven. svelte-games isn’t about turning your app into a gaming platform—it’s about adding a spark where users might otherwise tune out.

Right now, the package includes classics like Snake, but I’m dreaming bigger: Tetris, Pong, maybe even a little trivia component. It’s open-source, so you can fork it, tweak it, or add your own games to the mix. The goal? Make it carefree for Svelte devs to experiment with fun.