DEV Community: CarlSmith

A Test-Matrix Workflow for Debugging JavaScript Regular Expressions

CarlSmith — Mon, 13 Jul 2026 06:03:18 +0000

AI-assisted disclosure: This article was prepared with AI assistance. Every JavaScript example was executed with the companion Node.js validation script; no human editorial review was used.

A regular expression can be correct in isolation and still fail in an application. The failure may come from a flag, a Unicode representation, the API used to consume the expression, or the mutable state of a shared RegExp object.

That is why “try another pattern” is often a poor debugging strategy. A better approach is to turn the bug into a small test matrix.

The matrix has four useful axes:

Axis	Questions to test
Input	Is the exact failing string present, including whitespace, normalization, and invisible code points?
Pattern and flags	What changes with `u`, `g`, `i`, `m`, `s`, or `y`?
Consumer API	Are we calling `test`, `exec`, `matchAll`, or `replace`?
Expected result and state	Which matches, groups, replacement text, and `lastIndex` values should result?

This turns an anecdote such as “the regex works in one place but not another” into a reproducible statement such as:

With this exact input, /^.$/ fails, /^.$/u succeeds, and the input contains one Unicode code point represented by two UTF-16 code units.

Start with an executable matrix

The smallest useful harness is just data plus assertions:

import assert from "node:assert/strict";

const cases = [
  {
    name: "an emoji needs Unicode code-point mode",
    run: () => /^.$/u.test("💡"),
    expected: true,
  },
  {
    name: "a decomposed character contains two code points",
    run: () => /^.$/u.test("e\u0301"),
    expected: false,
  },
  {
    name: "NFC normalization composes that character",
    run: () => /^.$/u.test("e\u0301".normalize("NFC")),
    expected: true,
  },
];

for (const testCase of cases) {
  assert.deepEqual(testCase.run(), testCase.expected, testCase.name);
}

Keep the original failing input in the matrix. Add reduced examples later, but do not replace the evidence with a tidier string that may no longer reproduce the bug.

When the input is suspicious, inspect both code units and code points:

const input = "💡";

console.log(input.length);            // 2 UTF-16 code units
console.log(Array.from(input).length); // 1 Unicode code point

Those two lengths explain why a dot without the u flag does not mean “one visible character.”

Unicode is more than adding the `u` flag

The u flag changes pattern parsing and makes constructs such as . operate on Unicode code points rather than individual UTF-16 surrogate halves:

console.log(/^.$/.test("💡"));  // false
console.log(/^.$/u.test("💡")); // true

It also enables Unicode property escapes, which are often clearer than long hand-written ranges:

const lettersOnly = /^\p{Letter}+$/u;

console.log(lettersOnly.test("東京Cafe")); // true
console.log(lettersOnly.test("東京2"));    // false

But u does not normalize text. The precomposed string "é" and the decomposed string "e\u0301" look alike while containing different code-point sequences. Decide whether normalization is part of the application contract, then test that decision explicitly:

const oneCodePoint = /^.$/u;

console.log(oneCodePoint.test("é"));                  // true
console.log(oneCodePoint.test("e\u0301"));            // false
console.log(oneCodePoint.test("e\u0301".normalize("NFC"))); // true

Do not silently normalize identifiers, passwords, signatures, or other protocol data unless their specification permits it. Normalization is a data decision, not a universal regex repair.

Test capture shape, not only the full match

A successful full match does not prove that downstream capture handling is correct. Optional captures can be undefined, and a capture inside a repeated group stores only the final captured value.

const optional = /(?<word>[A-Za-z]+)(?:-(?<suffix>\d+))?/;
const match = optional.exec("alpha");

console.log(match.groups.word);   // "alpha"
console.log(match.groups.suffix); // undefined

const repeated = /(ab)+/.exec("abab");
console.log(repeated[0]); // "abab"
console.log(repeated[1]); // "ab", not an array of both repetitions

For every meaningful capture, add an assertion. If application code expects a value to be present, test the absent branch too.

Named groups make a matrix easier to read because the assertion describes the domain rather than a position:

assert.equal(match.groups.word, "alpha");
assert.equal(match.groups.suffix, undefined);

Replacement is a separate behavior

Matching and replacement should be separate rows in the matrix. A pattern may find the right spans while the replacement string refers to the wrong group or handles an optional group incorrectly.

Named captures give replacement templates a useful amount of self-documentation:

const person = /(?<first>\p{Letter}+)\s+(?<last>\p{Letter}+)/gu;
const input = "Ada Lovelace; Grace Hopper";
const output = input.replace(person, "$<last>, $<first>");

console.log(output);
// Lovelace, Ada; Hopper, Grace

When the replacement needs conditions, use a function and assert the final string rather than testing only the regex:

const version = /v(?<major>\d+)(?:\.(?<minor>\d+))?/g;

const output = "v2 v3.7".replace(version, (...args) => {
  const groups = args.at(-1);
  return groups.minor === undefined
    ? `${groups.major}.0`
    : `${groups.major}.${groups.minor}`;
});

console.log(output); // 2.0 3.7

The callback argument list is awkward, so isolate that behavior behind a named function if it appears in production code.

Treat global regexes as mutable objects

The g and y flags make a RegExp stateful. Calls to test and exec read and write lastIndex.

const shared = /\d+/g;
const input = "a1 b2";

console.log(shared.test(input), shared.lastIndex); // true, 2
console.log(shared.test(input), shared.lastIndex); // true, 5
console.log(shared.test(input), shared.lastIndex); // false, 0

This often causes alternating test results when a module-level regex is reused across requests or validation calls:

const hasNumber = /\d/g;

hasNumber.test("item 7"); // true
hasNumber.test("item 7"); // false: the same object starts from its old lastIndex

Three reliable fixes are:

Remove g when the operation is a yes/no test.
Construct a fresh RegExp for each independent scan.
Reset lastIndex deliberately and assert the state transition.

For collecting every match, matchAll is usually easier to reason about. It iterates using a cloned regex state and leaves the original object's lastIndex unchanged:

const digits = /\d+/g;
const values = [..."a1 b22".matchAll(digits)].map((match) => match[0]);

console.log(values);           // ["1", "22"]
console.log(digits.lastIndex); // 0

There is one more state boundary worth testing: zero-length matches. A manual exec loop can stall if the expression succeeds without consuming input. Either advance lastIndex yourself after an empty match or use an API whose iteration behavior is already defined for that case:

const positions = [..."ab".matchAll(/(?=\w)/g)].map((match) => match.index);
console.log(positions); // [0, 1]

Compare APIs deliberately

JavaScript exposes several regex consumers because they answer different questions:

API	Useful result	State concern
`re.test(input)`	Boolean existence check	Mutates `lastIndex` with `g` or `y`
`re.exec(input)`	One match with captures and index	Mutates `lastIndex` with `g` or `y`
`input.matchAll(re)`	Iterable of all detailed matches	Requires `g`; does not mutate the original regex
`input.replace(re, value)`	Transformed string	Replacement semantics need their own assertions

When two environments disagree, first confirm that they are using the same input, flags, and API. Comparing test in one place with matchAll in another is not a controlled experiment.

For a browser-local scratchpad while building the matrix, the RegexRegex JavaScript guide and live checker exposes matches, capture groups, replacement previews, and errors together. It is optional: every example in this article can be reproduced with Node.js alone.

A practical debugging sequence

Here is the workflow I use for a regex bug:

Capture the exact input. Preserve escapes, line endings, normalization, and surrounding characters.
Record the exact construction. A literal and new RegExp(string) have different escaping layers.
Freeze the consumer API. Note whether production calls test, exec, matchAll, or replace.
Build the smallest relevant flag matrix. Change one flag at a time and state why that row exists.
Assert full matches and captures. Include optional and repeated-group branches.
Assert replacement output separately. The right match can still produce the wrong text.
Assert lastIndex for g or y. Run the same object more than once.
Add Unicode adversaries. Include an astral character, combining mark, and non-ASCII letters when the domain permits them.
Minimize only after reproduction. Keep the original case as a permanent regression test.
Run in supported runtimes. Engine features and Unicode data can differ across deployed browser and Node versions.

The goal is not to test every theoretical string. It is to make each assumption visible. Once input representation, flags, API semantics, captures, replacement output, and mutable state are separate rows, most “mysterious” regex failures become ordinary failing assertions.

Keep the matrix executable

Put the cases your application depends on in a small regex-matrix.mjs file using node:assert/strict, and make the process exit non-zero on the first failed expectation. Run it with:

node regex-matrix.mjs

Store the expected results with the code so a later regex edit cannot quietly change behavior without changing an executable expectation.

I built a static reference page for the viral Gugugaga Penguin AI meme — here's the stack and why it took 90 minutes

CarlSmith — Wed, 06 May 2026 13:02:50 +0000

Last week I noticed the Gugugaga Penguin meme exploding on Bilibili and TikTok — a chibi penguin form of the Endministrator character from Arknights: Endfield, babbling baby-like "gugu gaga" sounds. Within three weeks of the original Feb 19, 2026 post on Bilibili, it had jumped to Douyin, X, and English-language TikTok, and the search query started climbing fast.

When I went looking for a clean reference page about the meme — origin, tools used to make it, starter prompts — every result was either an affiliate-stuffed landing page or a SEO trap with auto-generated content. So I shipped one myself on May 6, 2026, in about 90 minutes of focused work.

This is a quick walkthrough of the stack and the decisions behind it, in case you want to do the same for your own niche topic.

The constraint: zero-build, single file

The brief I gave myself before opening the editor:

One index.html file, no build step
Pure HTML + CSS, no JavaScript
Loads in under 200ms on a cold cache
Works on any GitHub Pages-eligible repo
Hand-coded enough that Google's "low-effort AI content" detector won't flag it

The result is one 479-line file, including critical CSS, that I drop into gugu-gaga-penguin/index.html on a public GitHub repo.

The design system I picked

I went with an "indie zine" aesthetic — Fraunces for headings, Crimson Pro for body, a warm paper background, and sage/terracotta accents. The full palette I'm using:

:root {
  --paper: #FAF7F2;
  --paper-warm: #F4EFE6;
  --ink: #1F1B16;
  --ink-soft: #4A4239;
  --sage: #8B9D7E;
  --sage-deep: #5C7351;
  --camel: #C9A582;
}

Two body pseudo-elements layer subtle SVG noise (encoded inline as a data URI) and a soft radial gradient — it costs zero requests and gives the page a printed-on-paper texture without an image asset. I tried a real noise PNG first; the inline SVG approach was 6x smaller.

Content structure for SEO

The page has five sections, ordered for both human readers and search crawlers:

What is the meme — a 2-paragraph plain-language explanation. Front-loads the keywords without keyword-stuffing.
Origin timeline — a <ul class="timeline"> with five dated entries. Crawlers love structured chronology, and humans actually read it.
The tool stack — a .tools grid listing Seedance, Kling, HitPaw, Midjourney, Stable Diffusion, ComfyUI+LTX with one-line use cases. This is the entity-rich section that Google's NLP pulls quotes from.
A starter prompt — two .prompt-block divs showing an actual image prompt + motion prompt. Real, copy-pastable content earns time-on-page.
Copyright caveat — one .caveat block addressing the Hypergryph IP question. This is the kind of trust signal Google's helpful-content system rewards.

I deliberately avoided affiliate links, ad placements, and email gates on this page. The entire monetization argument is "if you want the full archive, here's where I keep it" — one CTA button, one outbound link.

A starter prompt — milk scene

The starter prompt I document on the page generates this kind of result:

The image prompt itself is short — the trick I learned the hard way is keeping the character description identical across every scene so the chibi penguin stays consistent. Then you only vary the action and setting:

chibi penguin girl in black and white penguin costume, bright yellow beak, big gray eyes, black bangs with silver clips, holding a glass of warm milk with both tiny hands, sitting on a wooden stool, cozy kitchen background, soft warm lighting, cute anime style

Pair it with a motion prompt for Kling / HitPaw / Seedance:

The chibi penguin girl lifts the glass of milk to her mouth, takes a tiny sip, her eyes close happily, she kicks her feet gently. Warm cozy atmosphere, smooth gentle animation.

Vary the scene — cooking, chasing butterflies, getting startled when poked — and you have a meme series. Here's the cooking variant from my own test runs:

Deployment

GitHub Pages is the boring correct answer. Here's the exact sequence I ran:

git init
git add index.html README.md
git commit -m "initial reference page"
gh repo create gugu-gaga-penguin --public --source=. --push

Then in repository Settings → Pages, set source to main / root. Site live at https://{username}.github.io/gugu-gaga-penguin/ within about 60 seconds.

A few SEO touches I added on the GitHub side:

Topics tags — fill all 20 slots with relevant tags (gugugaga-penguin, ai-meme, arknights-endfield, stable-diffusion, etc.). GitHub's internal search ranks repos heavily by topic match.
About → Website — point this at your main site, not the GitHub Pages URL. The repo page is DR 100; that website link is a clean dofollow.
README first heading — make it match the page's <h1> (not the repo slug). GitHub renders the README on the repo page; this is your second-most-indexed surface.

What I'd do differently next time

If I were starting over:

Add an OG image. I left og:image empty because I didn't have time to design one, and link previews look bad on Discord/X without it.
Add structured data (<script type="application/ld+json">) describing the article. Schema.org Article is dead simple and helps with rich results.
Pre-cache the fonts. I'm using Google Fonts with display=swap, but self-hosting the woff2 files would shave another 80ms off LCP.

The bigger point

The interesting thing about niche-meme pages isn't the SEO mechanics — it's that there's a small but real window where you can rank for a brand-new search query that has zero competing high-quality pages. The Gugugaga Penguin query went from <100 monthly searches to several thousand within four weeks. Every existing result was either Chinese-language Bilibili content or thin English landing pages. A clean, accurate, English-language reference page slotted right in.

If you notice a meme starting to climb, you have maybe 3-4 weeks before the SEO-farm content saturates the SERP. Worth keeping an eye on.

The full archive — 50+ tested prompts, downloadable assets, and a prompt generator — lives at Gugu Gaga Penguin. The reference page repo from this article is on GitHub.

How to Use EmojiSymbolsCopy.com for Effortless Emoji & Symbol Copy-Paste

CarlSmith — Mon, 12 May 2025 07:00:09 +0000

Looking to supercharge your social posts, code comments, or online messages with unique emojis, kaomoji, and text art? Discover EmojiSymbolsCopy.com-a free, constantly updated platform offering thousands of symbols and emojis for instant copy-paste. Here’s why it’s a must-have tool for developers, creators, and anyone who wants to stand out online.

What Makes EmojiSymbolsCopy.com Special?

Massive Library: Access thousands of emojis, symbols, kaomoji, and text art-organized in intuitive categories like hearts, arrows, stars, music, Lenny faces, and more. Find exactly what you need, fast[3].
One-Click Copy: No more hunting for the right Unicode or fiddling with keyboard shortcuts. Just click any symbol or emoji, and it’s instantly copied to your clipboard for pasting anywhere-social media, code, chat, or documentation.
Mobile-Friendly: The site works seamlessly on phones and tablets, so you can copy and paste symbols on the go.
Always Free & Updated: Enjoy unlimited, free access with new symbols added regularly to keep your content fresh.

How to Use EmojiSymbolsCopy.com: Quick Guide

Browse or Search: Visit Copy And Paste Emojis and explore categories or use the search bar to find the perfect emoji, symbol, or text art.
Click to Copy: Simply click on any symbol, emoji, or kaomoji you like. It’s automatically copied to your clipboard-no extra steps needed[3].
Paste Anywhere: Paste directly into your code, tweets, Discord chats, Instagram bio, or any text field that accepts Unicode characters. Works in most modern apps and platforms.
Pro Tip: Mix and match symbols to create custom dividers, headers, or even ASCII art for your README files or documentation.

Why Developers & Creators Love It

Save Time: No need to memorize Unicode codes or search for obscure characters.
Enhance Readability: Use arrows, dividers, or icons to organize documentation or highlight key points in blog posts.
Boost Engagement: Unique emojis and kaomoji can make your social posts, comments, or bios more eye-catching and relatable.
Cross-Platform: Most symbols work across devices and operating systems, though appearance may vary slightly depending on the app or OS[3].

Ready to Try?

Head to Symbols Copy and Paste and start copying your favorite symbols now. Whether you want to add personality to your GitHub README, spice up a Slack message, or make your tweets pop, this tool makes it effortless.

“Find the perfect symbols to decorate your social media posts and messages. Just click to copy!”[3]

Join the Conversation

What’s your favorite emoji or symbol to use in code comments or social posts? Share your creative uses in the comments below!

Make your messages, code, and content stand out-one symbol at a time.

CompareList.org: A Developer's Guide to Efficient Data Comparison

CarlSmith — Thu, 24 Apr 2025 03:46:46 +0000

Data comparison is an essential but often tedious task in development workflows. Whether you're validating API responses, comparing JSON objects, reconciling database records, or simply cleaning up data sets, the need to compare lists efficiently comes up frequently. Today, I'm excited to introduce CompareList.org - a free, browser-based tool designed to make list comparison painless and efficient.

Why I Built CompareList.org

As developers, we've all been there - copying data between spreadsheets, writing custom scripts to find differences between arrays, or manually scanning through lines of text to spot discrepancies. These approaches are time-consuming and error-prone.

I built CompareList.org to solve this problem once and for all - a simple, powerful tool that handles list comparison instantly while keeping your data private and secure.

Key Features That Make It Stand Out

Versatile Input Options

CompareList.org accepts data from multiple sources[2]:

Direct text input
File uploads (CSV, TXT, Excel, JSON)
Copy-paste from spreadsheets
Multiple separator options (comma, line break, tab, custom delimiters)

This flexibility means you can seamlessly work with data from different sources without reformatting or preprocessing.

Comprehensive Comparison Results

The tool provides complete results that include[2]:

Items unique to List A
Items unique to List B
Items common to both lists (intersection)
All items combined (union)

This gives you a complete picture of how your data sets relate to each other in a single operation.

Advanced Configuration Options

You can fine-tune your comparisons with options for[2]:

Case sensitivity
Whitespace handling
Duplicate removal
Custom sorting

These options give you precise control over how strict or lenient the comparison should be, accommodating various use cases.

Privacy-First Approach

In an era where data privacy is paramount, CompareList.org processes all comparisons directly in your browser[2]. Your data never leaves your device, making it suitable for sensitive information like customer data, API keys, or confidential records.

Export and Share

After completing your comparison, you can[2]:

Download results in various formats
Copy directly to clipboard
Share findings with team members

Developer Use Cases

API Testing and Validation

When testing APIs, you often need to compare expected responses with actual ones. CompareList.org makes this straightforward:

// Expected API response fields
const expectedFields = [
  "id", "name", "email", "role", "created_at", "updated_at"
];

// Actual response fields from new API version
const actualFields = [
  "id", "name", "email", "role", "status", "created_at", "updated_at", "last_login"
];

// Use CompareList.org to quickly identify differences
// Result will show:
// - New fields: "status", "last_login"
// - Missing fields: none
// - Common fields: "id", "name", "email", "role", "created_at", "updated_at"

Database Migration Validation

When migrating between databases or updating schemas, CompareList.org helps ensure data integrity by comparing record counts, field names, or even entire data dumps.

Config File Comparison

Need to spot differences between development, staging, and production configuration files? CompareList.org makes it simple to identify environment-specific settings.

Data Cleaning and Deduplication

The tool includes a dedicated 'Remove Duplicates' feature[2] that instantly cleans lists, saving you from writing custom deduplication logic.

How to Use CompareList.org: A Step-by-Step Guide

Step 1: Enter Your Data

Enter your first list in the 'List A' section and your second list in the 'List B' section. You can paste text directly, upload files, or import from other sources[2].

Step 2: Configure Comparison Settings

Choose your comparison settings based on your needs[2]:

Set separators (comma, line break, etc.)
Toggle case sensitivity
Enable/disable whitespace trimming
Set duplicate handling options

Step 3: Compare and Analyze

Click the 'Compare Lists' button to instantly process your data. Review the four result sections showing unique items, common items, and the combined set[2].

Step 4: Export or Further Process

Beyond Basic Comparison: Advanced Use Cases

Working with Large Datasets

CompareList.org efficiently handles large datasets with thousands of items[2], making it suitable for production data analysis without performance issues.

Multilingual and Special Character Support

The tool handles all types of text content including special characters, formatted text, alphanumeric strings, and international characters[2] - perfect for global applications or specialized data formats.

Technical Implementation Highlights

CompareList.org is built with performance and privacy in mind:

Browser-based processing ensures your data never leaves your device
Efficient algorithms provide instant results even for large datasets
Responsive design works across devices

Try It Today

I've built CompareList.org to solve a common developer problem in the simplest, most efficient way possible. It's completely free to use with no registration required.

Visit CompareList.org and simplify your data comparison workflows today. I'd love to hear your feedback and how you're using the tool in your development process!

What's your favorite use case?

Have you faced challenges with data comparison in your projects? What tools have you used in the past? Let me know in the comments how you might use CompareList.org in your workflow!