DEV Community: FUG

February 29 Needs a Policy Parameter, Not a Hidden Exception

FUG — Sat, 17 Oct 2026 15:37:04 +0000

As of 2026-10-15

A birthday reminder fails on February 29, so a developer catches the exception and substitutes February 28. The program now runs. But the patch has also chosen a policy about when somebody's anniversary occurs in a non-leap year. That choice belongs in the feature's contract, where users and tests can see it.

We build the free age calculator at agecalc.fyi. Its English FAQ explicitly says that it uses March 1 for February 29 birthdays in non-leap years. That visible rule is the starting point here. We will implement two possible reminder conventions, without treating either one as a universal legal rule.

Keep the birthday unchanged

Someone born on February 29 should retain February 29 in the source record. Do not “repair” their date of birth to make a yearly scheduler simpler. A date of birth describes an event that happened; an anniversary date is a value derived for a particular target year.

The Gregorian leap-year rule makes years divisible by four leap years, except century years unless divisible by 400. Thus 2000 is a leap year, while 2100 is not. For application code, Python already supplies calendar.isleap; datetime.date validates calendar dates. Their behavior is documented in the Python calendar module and date API.

Source birthday	Target year	February 28 policy	March 1 policy
2000-02-29	2027	2027-02-28	2027-03-01
2000-02-29	2028	2028-02-29	2028-02-29
2000-02-29	2100	2100-02-28	2100-03-01
2000-05-12	2027	2027-05-12	2027-05-12

The policy changes only the missing-date case. A normal birthday should not move, and a leap-year February 29 should remain February 29. Those are good invariants because they prevent a narrowly intended workaround from becoming a general month-end adjustment.

An executable policy, with boundary tests

Save this as birthdays.py and run python3 birthdays.py. It uses only the standard library. anniversary returns a date; completed_years computes a whole-year age under the same explicit convention. The latter is a calendar model, not an eligibility determination for a contract or public service.

from calendar import isleap
from datetime import date
import unittest


def anniversary(born, year, policy):
    if policy not in ("feb28", "mar1"):
        raise ValueError("Unknown leap-day policy")
    if born.month == 2 and born.day == 29 and not isleap(year):
        month, day = (2, 28) if policy == "feb28" else (3, 1)
        return date(year, month, day)
    return date(year, born.month, born.day)


def completed_years(born, as_of, policy):
    if as_of < born:
        raise ValueError("Reference date precedes birth")
    boundary = anniversary(born, as_of.year, policy)
    return as_of.year - born.year - int(as_of < boundary)


class BirthdayTests(unittest.TestCase):
    def test_non_leap_boundaries(self):
        born = date(2000, 2, 29)
        cases = [
            (date(2027, 2, 27), "feb28", 26),
            (date(2027, 2, 28), "feb28", 27),
            (date(2027, 2, 28), "mar1", 26),
            (date(2027, 3, 1), "mar1", 27),
        ]
        for as_of, policy, expected in cases:
            with self.subTest(as_of=as_of, policy=policy):
                self.assertEqual(completed_years(born, as_of, policy),
                                 expected)

    def test_centuries_and_ordinary_dates(self):
        born = date(2000, 2, 29)
        self.assertTrue(isleap(2000))
        self.assertFalse(isleap(2100))
        for policy in ("feb28", "mar1"):
            self.assertEqual(anniversary(born, 2028, policy),
                             date(2028, 2, 29))
            self.assertEqual(anniversary(date(2000, 5, 12), 2027, policy),
                             date(2027, 5, 12))
        self.assertEqual(anniversary(born, 2100, "mar1"),
                         date(2100, 3, 1))

    def test_rejected_inputs(self):
        with self.assertRaises(ValueError):
            date(2027, 2, 29)
        with self.assertRaises(ValueError):
            anniversary(date(2000, 2, 29), 2027, "rollover")
        with self.assertRaises(ValueError):
            completed_years(date(2000, 2, 29), date(1999, 1, 1), "mar1")


if __name__ == "__main__":
    unittest.main()

For February 28, 2027, the year subtraction is 2027 - 2000 = 27. Under the March 1 policy the anniversary has not arrived, so subtract one and obtain 26. Under the February 28 policy it has arrived, so the result remains 27. The disagreement is exactly the declared policy, not an arithmetic error.

Do not hide the choice in exception handling

A broad except ValueError that substitutes the end of February can swallow unrelated input problems. An impossible source date, an unsupported year and a missing anniversary are different cases. Validate the source date first, then handle the known February 29 branch deliberately.

The function also rejects unknown policy strings even for ordinary birthdays. That catches misspellings immediately instead of letting them survive until the next leap-day record reaches production. A typed enum can serve the same purpose in a larger application.

Reminders and age displays need a shared contract

If the profile says a person is still 26 but the birthday banner says they turned 27 today, inspect whether two features used different conventions. Store the policy near the feature configuration and pass it to both calculations. Include it in bug reports alongside the birth date and reference date, using synthetic dates where possible.

For legal age gates, get the applicable rule and jurisdiction separately. Do not infer those requirements from a birthday-party reminder, a general calculator or a developer's default. The functions above deliberately do not contain a country table.

The web calculator also exposes a reference-date field. That is useful for inspecting a boundary without waiting for it to occur: compare the day before, the chosen anniversary and the day after. An executable test should use fixed dates for the same reason. A test that depends on today's date can pass for months while missing the only boundary that matters.

FAQ

Why not add 365 days to find the next birthday?

That advances a duration. It does not preserve a month and day across leap years.

Is February 28 always wrong?

No. It is one explicit anniversary convention. This calculator's displayed rule uses March 1 instead.

Should I change the stored birth date?

No. Keep the original valid date and derive each year's anniversary separately.

Does this calculate months and days too?

No. The example returns anniversaries and completed years only. Month-and-day decomposition needs its own documented convention.

The age calculator is free to use without signing up.

Inspect an age at a chosen reference date

When Fancy Names Collapse to One Search Key: Testing NFKC Collisions

FUG — Fri, 16 Oct 2026 15:17:09 +0000

As of 2026-10-15

A directory may contain Alice, Ａlice and 𝐀lice. They look related, but a literal string comparison treats them as different text. Making them searchable under the same query is a product decision. Making them the same account is a much larger decision, and should not happen as an accidental side effect of a search helper.

We build the free fancy text generator at fancyfont.fyi. Its page offers Unicode text styles, copying and a profile preview, and advises keeping searchable words plain. This article looks at a separate developer problem: how an application of your own can search stylized display names without destroying their original spelling.

Keep a second key

Store the display text and the search key separately. The display value is what the person entered. The key expresses your chosen matching policy. The durable account ID should be independent of both.

Unicode provides canonical and compatibility normalization. NFC can bring canonically equivalent forms together while retaining compatibility distinctions. NFKC also folds compatibility distinctions, so fullwidth and mathematical styled letters can become ordinary letters. Unicode cautions that compatibility normalization loses information; see its normalization FAQ and normalization specification.

For a casual directory, that may be a useful search behavior. For mathematical text, a distinct styled letter may carry meaning. Applying NFKC to every stored document would be a much broader change than adding a forgiving name search. Keep the transformation close to the feature that needs it.

Value	Purpose	Can several records share it?
Account ID	Stable record identity	No
Display name	Presentation chosen by the person	Often yes
Normalized search key	Match candidates	Yes, by design
Unique handle	Product-defined public identifier	Depends on a separate policy

Run a collision fixture before building the index

Save the following as names.cjs and run it with Node.js. The sample uses NFKC and lowercase as a deliberately limited directory-search policy. It does not claim to implement full Unicode case folding or an identifier security standard.

const assert = require("node:assert/strict");

function searchKey(value) {
  if (typeof value !== "string") throw new TypeError("Expected text");
  return value.normalize("NFKC").toLowerCase().normalize("NFKC");
}

const people = [
  { id: "u1", display: "Alice" },
  { id: "u2", display: "Ａlice" },
  { id: "u3", display: "𝐀lice" },
  { id: "u4", display: "Alicé" }
];

const index = new Map();
for (const person of people) {
  const key = searchKey(person.display);
  if (!index.has(key)) index.set(key, []);
  index.get(key).push(person);
}

assert.equal("Ａ".normalize("NFC"), "Ａ");
assert.equal("Ａ".normalize("NFKC"), "A");
assert.equal("𝐀".normalize("NFKC"), "A");
assert.equal(searchKey("Cafe\u0301"), searchKey("Café"));
assert.notEqual(searchKey("Café"), searchKey("Cafe"));
assert.notEqual(searchKey("Straße"), searchKey("STRASSE"));
assert.notEqual(searchKey("a"), searchKey("\u0430"));

const matches = index.get(searchKey("ALICE")) ?? [];
assert.deepEqual(matches.map(person => person.id), ["u1", "u2", "u3"]);
assert.equal(people[2].display, "𝐀lice");
console.log(matches);

The search for ALICE returns three candidates. That is the intended result: three records share a key. If the index stored a single person per key, each insertion would overwrite the previous match. A normalization improvement would then quietly become a data-loss bug.

Notice what the assertions refuse to collapse. An accented letter is not automatically the unaccented letter. The German sharp s is not converted to ss by this lowercase pipeline. A Cyrillic small a is not the Latin a, despite their appearance in many typefaces. These examples are executable boundaries for this particular helper.

Decide what a collision means in each workflow

In a search box, a collision can produce several results. Show enough context to help the user choose without exposing private details. In an invitation flow, accept a stable identifier or require selection of the intended record. A display-name match alone is weak evidence of the recipient's identity.

In account registration, the same collision may require rejection if the product promises unique handles under this matching rule. That uniqueness must also be enforced where records are stored. Checking in the browser and then inserting without a shared constraint leaves a race between simultaneous registrations.

The key lesson is not to use one helper indiscriminately. Searching, displaying, authenticating and reserving a handle are separate operations. A convenient search result should not authorize access to somebody else's account or silently rename their profile.

Version the policy before changing existing data

Suppose a directory originally indexed exact lowercase text and later adds NFKC. Previously distinct keys can now collide. Rebuild into a new index, inspect the collision groups, and decide how each affected feature should behave before switching traffic.

Keep the old display values during that migration. Normalization is not a reversible encoding: once several inputs have become the same output, the output cannot tell you which original was used. Storing only the normalized value would make it impossible to restore the original presentation accurately.

A migration report can list the policy version and measured collision groups without exposing private names.

Test the UI as well as the helper

The sample verifies string behavior, but a useful search interface also needs tests for empty queries, pasted whitespace, sorting and selection. Decide whether trimming is part of your policy. This helper intentionally does not remove punctuation or trim a person's display name.

Run the fixtures in the runtimes that will produce and consume the key. If your database applies a different collation, compare its uniqueness behavior with the application helper. Compare actual strings, not policy labels.

FAQ

Should I replace display names with NFKC output?

Usually keep the original and derive a separate key. Compatibility normalization can discard distinctions the person intended.

Does normalization stop impersonation?

No. It is a text transformation, not proof of identity or a complete look-alike detection system.

Is lowercase the same as Unicode case folding?

No. The sharp-s assertion demonstrates one difference. Pick a matching policy for the languages and feature you support.

Does the generator provide this search index?

No. The page provides styled text. The index here is an independent example for developers.

The text generator is free, with no sign-up or app required.

Create styled text to use in your own test fixtures

An Exact-Zero Cart Ledger with BigInt and a JSON Round Trip

FUG — Thu, 15 Oct 2026 15:17:17 +0000

As of 2026-10-15

A spending game can make zero a meaningful state: the timer stops when the balance is exactly empty. That turns an ordinary shopping cart into a useful programming exercise. Every purchase, sale and restored save needs to preserve the same accounting identity, even after a long sequence of clicks.

We build the free spending game at 40jo.fyi. Its English page describes buying and selling items, entering quantities, a receipt and a timer that stops at zero. The code below is an independent teaching example, not a description of the site's implementation. Its prices are invented test inputs, not market prices or values copied from the game.

Choose a unit before choosing a type

Our sample ledger uses integer credits. If an application instead supports dollars and cents, its unit could be cents. Do not let some functions accept whole dollars while others expect cents: a precise type cannot repair an ambiguous unit.

JavaScript's largest safe integer is 2 ** 53 - 1, or 9,007,199,254,740,991. A balance of 27 billion whole credits fits comfortably inside that boundary. A large-looking number alone is therefore not a reason to claim that Number is broken. Here we use BigInt to give an extensible integer ledger one consistent arithmetic type.

BigInt represents integers, not arbitrary decimal fractions. Mixed Number/BigInt arithmetic is generally rejected, and a raw BigInt cannot be serialized by ordinary JSON.stringify without a conversion policy. Those behaviors are specified by ECMAScript's numeric types and serialization rules. The interesting design work is at the boundaries: input, state transitions and storage.

Boundary	Accepted representation	Rejected example
Quantity input	Nonnegative decimal digit string	`"1.5"`
Internal amount	Integer credits as BigInt	A floating-point price
Saved quantity	Decimal string in JSON	A raw BigInt value
Cart update	A complete affordable new quantity	A negative balance

Make the update atomic

The following program runs as one file with Node.js. It has no dependencies beyond Node's assertion module. Save it as ledger.cjs and run node ledger.cjs. A failed operation throws before changing the cart, so the caller can display the error without repairing partial state.

const assert = require("node:assert/strict");

function unsigned(text) {
  if (typeof text !== "string" || !/^(0|[1-9][0-9]*)$/.test(text)) {
    throw new TypeError("Expected an unsigned decimal string");
  }
  return BigInt(text);
}

const budget = 1000n;
const prices = new Map([["book", 125n], ["ticket", 300n]]);
let cart = new Map();

function spent(items) {
  let total = 0n;
  for (const [id, quantity] of items) {
    if (!prices.has(id)) throw new RangeError("Unknown item");
    if (typeof quantity !== "bigint" || quantity < 0n) {
      throw new RangeError("Invalid quantity");
    }
    total += prices.get(id) * quantity;
  }
  return total;
}

function setQuantity(id, text) {
  if (!prices.has(id)) throw new RangeError("Unknown item");
  const next = new Map(cart);
  next.set(id, unsigned(text));
  if (spent(next) > budget) throw new RangeError("Over budget");
  cart = next;
  return budget - spent(cart);
}

assert.equal(setQuantity("book", "2"), 750n);
assert.equal(setQuantity("ticket", "2"), 150n);
assert.throws(() => setQuantity("ticket", "3"), /Over budget/);
assert.equal(budget - spent(cart), 150n);
assert.throws(() => setQuantity("book", "1.5"), /decimal/);

// Selling both tickets restores their full cost.
assert.equal(setQuantity("ticket", "0"), 750n);
assert.equal(setQuantity("book", "8"), 0n);

const saved = JSON.stringify({
  version: 1,
  quantities: [...cart].map(([id, q]) => [id, q.toString()])
});
const parsed = JSON.parse(saved);
assert.equal(parsed.version, 1);
const restored = new Map(
  parsed.quantities.map(([id, q]) => [id, unsigned(q)])
);
assert.equal(spent(restored), budget);
console.log("Ledger checks passed; remaining credits:",
            (budget - spent(restored)).toString());

Two books cost 2 × 125 = 250 credits. Two tickets add 2 × 300 = 600, so spending is 850 and the balance is 1,000 - 850 = 150. Asking for a third ticket would make the ticket subtotal 900 and the whole cart 1,150. The rejection leaves the previous 850-credit cart intact.

Selling the tickets returns spending to 250. Setting the book quantity to eight makes it 8 × 125 = 1,000, which reaches exactly zero. No tolerance or rounding rule is involved because every operation is integer addition, multiplication or subtraction.

The receipt should come from the cart

Avoid maintaining independent mutable values for the balance, receipt total and cart total. Three counters require every event handler to update all three correctly. In this example the cart is the state; spending and balance are derived views. A receipt renderer can use the same quantities and prices.

The useful invariant is budget = spent + remaining. Check it after buying, selling, resetting and restoring. Another useful property is reversibility: setting an item's quantity back to its old value should restore the old total, provided the catalog price has not changed.

A real catalog needs a price-version policy. If a saved cart refers to yesterday's prices, should restoring it use the old catalog or recalculate at today's prices? Our small example fixes the catalog for its lifetime. A deployed application should make that choice explicit rather than silently calling a changed receipt the original one.

JSON is an interface, not a backup spell

The sample restores only the JSON it just created. An imported save needs additional validation: object shape, version, allowed item IDs, duplicate IDs, quantity-string length and total affordability. A duplicate ID would otherwise be overwritten by Map, concealing an ambiguous import. Cap input lengths before parsing huge integers as well.

Store an explicit unit and catalog version when the file can leave the application. Strings preserve digits, but the receiver still needs to know what those digits mean. Converting a decimal string through Number before calling BigInt defeats that purpose if the number is outside the safe range.

FAQ

Does a billion-credit budget require BigInt?

No. Check the largest intermediate integer against Number's safe range. BigInt is an explicit integer design choice here.

Can I use BigInt for decimal prices directly?

No. Choose a fixed smallest unit and parse into it, or use a decimal arithmetic design with documented rounding.

Why store quantities instead of the displayed balance?

The quantities and catalog reconstruct the receipt and total. A balance alone cannot explain what was purchased.

Does this reproduce the game's source code?

No. It demonstrates a ledger invariant inspired by the page's exact-zero objective.

The spending game is free to play without signing up.

Try an exact-zero spending challenge

Date Differences Without Traps: Calendar Days, UTC, Midnight, and DST

FUG — Wed, 14 Oct 2026 15:00:37 +0000

As of October 8, 2026

The interval from March 8 to March 9 is one calendar day. In a daylight-saving location, the elapsed time between two local midnights can be 23 hours. Code that divides milliseconds by 86_400_000 and expects every local date transition to behave alike eventually returns the wrong answer.

We make a date calculator that distinguishes a countdown from a day number and counts dates in the device’s local calendar. Its “count the start date as day 1” switch exists because the arithmetic is only safe after the product decides what its words mean.

Start by naming the interval

An exclusive elapsed-day difference counts boundaries crossed: March 1 to March 2 is one day. Inclusive counting counts the labeled dates themselves: March 1 through March 2 is two days. Neither is universally correct.

Question	Start date included?	March 1 to March 2
“How many days until March 2?”	No	1
“What day number is March 2 if March 1 is day 1?”	Yes	2
“100 days after January 1”	No	April 11 in a non-leap year
“The 100th day from January 1”	Yes	April 10 in a non-leap year

Adding one after a calculation is not a general fix. It is an explicit inclusive convention and needs to appear in the UI, API name, and tests. A legal deadline, a hotel stay, and a relationship anniversary can use different conventions even when their dates look identical.

A date-only value is not an instant

2026-10-08 identifies a civil calendar date. 2026-10-08T00:00:00Z identifies one instant at UTC midnight. new Date("2026-10-08") parses the date-only ISO form as UTC in JavaScript, then getters such as getFullYear() and getDate() display it in the host’s local zone. West of UTC, that can look like October 7.

For user-entered date fields, keep the value as a YYYY-MM-DD string until you deliberately perform calendar arithmetic. Do not create an instant merely to subtract two dates. A time-zone-aware appointment is a different data type and needs its own policy.

The following helper parses a date-only string and converts it to a UTC day index. UTC is used here as a neutral calendar grid, not as a claim that the user chose UTC. Each civil date gets one index, so daylight-saving clock changes cannot alter the result.

const MS_PER_DAY = 24 * 60 * 60 * 1000;

function parseIsoDate(value) {
  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
  if (!match) throw new TypeError("Expected YYYY-MM-DD");

  const [, year, month, day] = match.map(Number);
  const stamp = Date.UTC(year, month - 1, day);
  const check = new Date(stamp);
  if (check.getUTCFullYear() !== year ||
      check.getUTCMonth() !== month - 1 ||
      check.getUTCDate() !== day) {
    throw new RangeError("Invalid calendar date");
  }
  return stamp;
}

function daysBetween(start, end, { inclusive = false } = {}) {
  const difference = (parseIsoDate(end) - parseIsoDate(start)) / MS_PER_DAY;
  return difference + (inclusive ? 1 : 0);
}

console.log(daysBetween("2026-03-01", "2026-03-02"));
// 1
console.log(daysBetween("2026-03-01", "2026-03-02", { inclusive: true }));
// 2

The round-trip check catches values such as February 30, which Date.UTC would otherwise normalize into a later real date. The result may be negative when the end date precedes the start date; callers should decide whether a negative past-due count is useful or should be rejected.

Why local midnight subtraction fails

This common pattern treats local midnights as if they were always separated by the same duration:

const days = (new Date(2026, 2, 9) - new Date(2026, 2, 8)) / 86_400_000;

In a zone whose clocks move forward during that interval, it can produce a fraction below one. Rounding it may hide a problem for one case while creating another around a clock change in the other direction. setDate(getDate() + 1) is useful for stepping through local calendar dates, but subtracting two local Date objects measures instants, not date labels.

There is a converse trap: forcing all date-only inputs through UTC instants then rendering them with local getters changes the displayed date in some zones. Use UTC getters consistently when inspecting a UTC-grid date, or keep date-only strings and format them with a date-only formatter.

Keep calendar and elapsed-time features separate

Calendar-day difference and elapsed duration are both valid operations. A timer until 2026-10-08T09:00:00+09:00 should use instants and milliseconds. A “days until birthday” feature should use local calendar dates and show “Today” when the date labels match. Combining them in a single function with an undocumented boolean creates ambiguous results.

The calculator page adds or subtracts days, weeks, months, and years; it also lists anniversary dates. Month arithmetic is not day arithmetic. January 31 plus one month has to choose a convention because February lacks the 31st. The page uses the last day of February for that case. Define and test the convention before offering a “+ 1 month” control.

Product feature	Input model	Recommended operation
Countdown to a date	Local date labels	UTC day-index subtraction or calendar API
“Day 1” anniversary	Local date labels	Calendar arithmetic plus inclusive rule
Meeting duration	Zoned instants	Instant subtraction
Add one month	Calendar date	Explicit month-end convention

Modern environments may offer Temporal, whose PlainDate represents a date without time or zone. Where it is available through the runtime or a supported polyfill, it makes the type distinction clearer. The small helper above remains useful when an application must depend only on broadly deployed Date and strict date strings.

Test the boundary, not only the average day

Put dates on both sides of a month end, leap day, year end, and a DST clock change into tests. Run any local-time logic under more than one TZ setting in CI. Test reversed ranges and invalid dates. Most importantly, assert the product wording alongside the result: the test should say “exclusive calendar days” or “inclusive day number,” not merely expect(result).toBe(1).

FAQ

Should a countdown include today?

Usually no: tomorrow is one day away and today is the destination. A day-number feature can legitimately include the start date instead.

Why not divide milliseconds by 24 hours?

That measures elapsed time between instants. Local daylight-saving transitions can make a calendar day shorter or longer than 24 hours.

Is UTC always the right user time zone?

No. UTC in the helper is a stable indexing technique for date-only values. A meeting or deadline with a specified local time needs a real time-zone rule.

Does the calculator handle leap years?

The tool page says it uses the real calendar, including February 29, and counts whole calendar days in the device’s local date.

Check a free countdown, date difference, date addition, or anniversary date

Wi-Fi and vCard QR Codes: The Text Payloads Behind the Squares

FUG — Sun, 11 Oct 2026 21:17:42 +0000

As of October 8, 2026

A Wi-Fi QR code is not a special encrypted picture. At its core, it is text such as WIFI:T:WPA;S:CafeNet;P:correct-horse-battery;H:false;;. A phone recognizes the convention and offers to join the network. A contact QR works the same way: it carries vCard text that a scanner can turn into a contact card.

We build a QR generator with Wi-Fi and vCard options, so we treat the payload as the primary artifact. The rendered modules, colors, and download format come after the payload is correct. A beautifully styled code with a malformed escaped value still gives a guest the wrong result.

The Wi-Fi payload is a small field language

The widely used Wi-Fi QR convention starts with WIFI: and uses semicolon-delimited fields. The common fields are T for authentication type, S for SSID, P for password, and H for hidden-network status. The payload ends with a second semicolon.

Field	Meaning	Example value
`T`	Network authentication type	`WPA`
`S`	Network name (SSID)	`CafeNet`
`P`	Network password	`correct-horse-battery`
`H`	Whether the network is hidden	`false`

For an ordinary WPA network, the full payload can be WIFI:T:WPA;S:CafeNet;P:correct-horse-battery;H:false;;. A scanner may support a slightly different subset of values, so a generator should not promise identical behavior on every camera app. The reliable workflow is to scan the completed code with the intended devices before it reaches a sign or guest handout.

Delimiters are data hazards. A semicolon ends a field; a colon separates its label from its value; a backslash introduces escaping. In this convention, backslash-escape characters that could be interpreted as syntax inside a value. Do not hand-concatenate untrusted input and hope that an SSID containing punctuation happens to work.

function wifiEscape(value) {
  return String(value).replace(/([\\;,:\"])/g, "\\$1");
}

function wifiPayload({ ssid, password, auth = "WPA", hidden = false }) {
  return `WIFI:T:${wifiEscape(auth)};S:${wifiEscape(ssid)};` +
    `P:${wifiEscape(password)};H:${hidden ? "true" : "false"};;`;
}

console.log(wifiPayload({
  ssid: "Tea;Time",
  password: "a:b\\c"
}));
// WIFI:T:WPA;S:Tea\;Time;P:a\:b\\c;H:false;;

The exact accepted authentication labels and empty-password behavior deserve device testing. A payload builder should validate its own supported choices rather than silently changing a network setting. It should also make the privacy consequence visible: whoever scans the code can recover its plaintext network configuration. Do not place a guest code where an unrestricted password would be inappropriate.

vCard is contact text, not a screenshot

vCard is a text contact interchange format. A small vCard QR often starts with BEGIN:VCARD, declares a VERSION, supplies properties such as FN for the formatted name and TEL or EMAIL, then closes with END:VCARD.

BEGIN:VCARD
VERSION:3.0
FN:Jordan Lee
ORG:North Street Studio
TEL;TYPE=CELL:+1-555-0100
EMAIL:jordan@example.test
END:VCARD

Each line is a property. The property name can have parameters after semicolons, followed by a colon and its value. That looks simple until real names or notes contain commas, semicolons, line breaks, or backslashes. Escape text values according to the vCard version you choose, and do not send a display-formatted phone number when your destination expects an international number.

Use a maintained vCard library when the input goes beyond a few controlled fields. It reduces the chance of mixing vCard versions or failing to fold long physical lines. A minimal helper can demonstrate the text escaping rule, but it is not a substitute for full conformance testing:

function vcardText(value) {
  return String(value)
    .replace(/\\/g, "\\\\")
    .replace(/\n/g, "\\n")
    .replace(/;/g, "\\;")
    .replace(/,/g, "\\,");
}

For a contact, include only fields the recipient needs. A QR displayed at a public booth may be copied by anyone. A landing page can be changed later; static vCard data printed on a badge cannot. Verify the scanned result in the phone’s contact preview before distributing it.

The payload controls density

The QR symbol carries a finite number of bits. More payload text can require a higher version, which makes the grid denser. A long vCard with multiple addresses, labels, and notes may therefore be harder to scan at a small printed size than a short Wi-Fi payload. Encoding mode and the QR library’s settings also affect the final symbol.

Error correction adds redundant codewords. The familiar L, M, Q, and H levels trade capacity for resilience to damage. Higher correction can help a clean code survive a minor obstruction, but it can also increase density for the same payload. It is not a license to cover a fixed percentage of modules with an arbitrary logo.

Decision	What it changes	What to verify
Add another vCard field	Payload length and possibly density	Scan distance at final print size
Raise error correction	Redundancy and often symbol size	Finished code with any logo
Escape punctuation	Payload interpretation	A scanner reads the original value
Export SVG instead of PNG	Scaling behavior, not encoded data	Quiet zone and print contrast

The generator page offers nine QR types, lets a user style a code, and exports PNG or SVG. It says the content is encoded directly rather than through a redirect, so the code has no redirect layer to maintain. That does not make the embedded Wi-Fi password or contact details timeless; those values still need review whenever they change.

A production checklist

Log the payload before rendering, but never log a real Wi-Fi password in an analytics event or browser console. Generate the symbol from the exact string, preserving its encoding. Keep a quiet margin, strong contrast, and a label that tells people what will happen after scanning. Then test on more than one actual phone, not just the device that generated it.

For vCards, check that each target contacts app assigns the name, phone, and email to the expected fields. For Wi-Fi, test joining a safe test network first and make a plan for password rotation. These are interface tests, not merely image tests.

FAQ

Can a Wi-Fi QR code hide the password from someone who scans it?

No. The code needs to contain the configuration a compatible scanner uses to join. Treat a shared QR as shared network access.

Does a vCard QR need a website?

No. A vCard QR can contain the contact text directly. It can also become large when many fields are included.

Is higher error correction always better?

No. It consumes capacity and can make a symbol denser. Select it for the actual print and decoration conditions, then scan-test the result.

Why does punctuation break some codes?

Payload formats use punctuation as syntax. Values must be escaped according to the format rather than inserted as raw text.

Build and download a free Wi-Fi, vCard, or other QR code in your browser

Character Counts in JavaScript: Code Units, Code Points, Graphemes, and UTF-8 Bytes

FUG — Sat, 10 Oct 2026 20:57:44 +0000

As of October 8, 2026

"\u{1F44D}\u{1F3FD}".length is 4. A reader looking at the resulting single modified thumbs-up symbol sees one symbol. JavaScript sees four UTF-16 code units. Neither observation is broken; they answer different questions. The bug starts when a product requirement says “characters” without naming the unit.

We make browser tools, including a counter that shows counts with and without spaces and UTF-8 bytes. That interface is deliberately more specific than a single number: a tweet field, a storage column, and a visible counter may each have a different definition of length.

Four units hiding behind one word

JavaScript strings are sequences of UTF-16 code units. String.prototype.length reports that representation. Basic Latin letters normally occupy one code unit. Many code points outside the Basic Multilingual Plane occupy a surrogate pair, so they take two. Emoji sequences can contain multiple code points: a base symbol, a skin-tone modifier, a variation selector, or a zero-width joiner sequence.

A Unicode code point is the numbered value assigned by Unicode, such as U+0061 for a. A grapheme cluster is a user-perceived text element. The cluster can be one code point, but it can also be a sequence. UTF-8 bytes are encoded storage or transport units; their number depends on encoding rather than on what is visibly drawn.

Example	Visible symbols	UTF-16 code units	Code points	UTF-8 bytes
`A`	1	1	1	1
`é` (precomposed)	1	1	1	2
`U+1F600` (grinning face)	1	2	1	4
`U+1F44D U+1F3FD` (modified thumbs-up)	1	4	2	8

The second row carries an extra warning. The visible é can also be written as e followed by a combining acute accent. That alternative has two code points and three UTF-8 bytes while still usually displaying as one grapheme cluster. A rule that needs stable comparison may also need a normalization policy; counting alone does not supply one.

Use an explicit counter

This small utility makes the four choices visible. It uses for...of for code points, Intl.Segmenter for grapheme clusters when available, and TextEncoder for UTF-8 length.

function counts(text, locale = "en") {
  const codeUnits = text.length;
  const codePoints = Array.from(text).length;
  const bytesUtf8 = new TextEncoder().encode(text).length;

  const graphemes = typeof Intl.Segmenter === "function"
    ? Array.from(
        new Intl.Segmenter(locale, { granularity: "grapheme" }).segment(text)
      ).length
    : null;

  return { codeUnits, codePoints, graphemes, bytesUtf8 };
}

console.log(counts("A\u{1F600}\u{1F44D}\u{1F3FD}"));
// { codeUnits: 7, codePoints: 4, graphemes: 3, bytesUtf8: 13 }

Array.from(text) and [...text] iterate by code point, so they avoid splitting a surrogate pair into two values. They do not solve the grapheme problem: the modifier in the U+1F44D U+1F3FD sequence remains a second code point. Intl.Segmenter asks the platform to apply Unicode text-segmentation rules, which is much closer to the count a person expects in an input box.

Treat the fallback carefully. Returning null is more honest than quietly substituting code-point length and labelling it a grapheme count. If a server enforces a visible-symbol limit, use a compatible segmentation library or define the accepted client platforms; client-side advice alone cannot enforce a server rule.

“With spaces” is a policy, not another encoding

The difference between characters with spaces and characters without spaces is usually a filtering rule applied before counting. On the counter page, the regular character total includes spaces and line breaks, while the no-spaces total excludes whitespace. That means a paragraph break affects one total and not the other.

Do not implement “without spaces” as text.replaceAll(" ", "") unless a single ASCII space is truly the stated policy. Tabs, newlines, non-breaking spaces, and other Unicode whitespace may be present after a paste. For a broad whitespace rule, use a Unicode-aware regular expression:

function countWithoutWhitespace(text) {
  return Array.from(text.replace(/\s/gu, "")).length;
}

This example deliberately returns code-point length. If the product promise is “visible characters without whitespace,” segment the filtered string into graphemes instead. Also decide whether line endings are normalized before validation. \r\n is two code units but represents one line break in many environments; a copied Windows text block can otherwise surprise both users and tests.

Match the counter to the boundary

The right question is: what will reject, store, bill for, or display this text? A database byte limit calls for encoded-byte validation using the exact database encoding. A JavaScript API documented in UTF-16 units may legitimately use .length. A field described to ordinary readers as “up to 50 characters” should normally consider grapheme clusters, then explain exceptions if the receiving platform uses another rule.

Avoid claiming that a generic counter predicts every external service. Some platforms use weighted limits, normalize text, treat URLs specially, or apply their own version of Unicode segmentation. The counter page offers presets for X posts, meta descriptions, Instagram captions, and essays, but a final paste into the destination remains the authoritative check.

A useful UI exposes the chosen measure in the label itself: “50 visible characters,” “256 UTF-8 bytes,” or “280 platform units.” It should show the remaining amount from the same function used to block submission. A meter driven by graphemes alongside a server rule driven by bytes creates the exact off-by-several error it was meant to prevent.

Test strings belong in the suite

ASCII-only tests make almost every length function look correct. Add cases for a supplementary-plane character, combining marks, a skin-tone sequence, a family emoji joined with zero-width joiners, tabs, line endings, and non-breaking spaces. Store the expected unit in the test name, not merely a bare integer.

Requirement	A defensible measurement	Test that catches the wrong choice
Browser field limited by UTF-16 units	`text.length`	A supplementary-plane emoji
Reader-facing symbol counter	Grapheme segmentation	A modified symbol or a joined emoji sequence
API or database byte quota	`TextEncoder().encode(text).length`	Korean text or emoji
Copy limit excluding whitespace	Stated filter plus stated unit	Tab and newline input

This vocabulary may feel fussy until a customer cannot submit a short-looking name, or a byte-limited request fails only for Korean or emoji text. Naming the unit turns a mysterious edge case into an inspectable contract.

FAQ

Is `string.length` a character count?

It is a UTF-16 code-unit count. It matches a simple character count for many basic strings, but not for all Unicode text.

Does spreading a string count what a person sees?

Not always. [...text] counts code points, while one visible grapheme can contain several code points.

Why do UTF-8 byte counts matter?

They matter where an encoded payload has a byte ceiling, such as a protocol or storage boundary. They are not automatically a reader-facing character count.

Should spaces be removed before validation?

Only when the stated rule excludes whitespace. Preserve the original text for display unless the product explicitly transforms it.

Compare words, character totals, whitespace-free totals, and UTF-8 bytes with our free counter

Fancy Text Is Unicode Data: What Developers Should Know About Accessibility

FUG — Fri, 09 Oct 2026 20:57:55 +0000

As of October 8, 2026

A copied letter is not necessarily a font

When someone pastes a bold-looking name into a social profile, there may be no CSS or custom typeface involved. Many so-called fancy fonts substitute characters from Unicode's Mathematical Alphanumeric Symbols range, which begins at U+1D400. This means the text itself changes. We make small free web tools, and we think that distinction should be visible to anyone using a text converter.

Take an ordinary capital A and a mathematical bold capital 𝐀. They resemble one another visually, but they are different code points. Copying the second one into another application preserves that distinct character if the platform supports it. Changing the CSS font on the first A, by contrast, leaves its underlying character intact.

Mathematical alphabet characters were designed to distinguish symbolic variables in mathematical notation, not to supply every social-media typography preference. The characters are useful in the right context, but they can introduce unexpected behavior in ordinary names and sentences.

A tiny JavaScript experiment

The bold mathematical Latin capitals start at U+1D400. Basic Latin uppercase A through Z are consecutive, so a demonstration converter can use code-point arithmetic:

function mathBoldCapitals(input) {
  return [...input].map((char) => {
    const code = char.codePointAt(0);
    if (code >= 65 && code <= 90) {
      return String.fromCodePoint(0x1D400 + code - 65);
    }
    return char;
  }).join("");
}

console.log(mathBoldCapitals("HELLO 123"));
// 𝐇𝐄𝐋𝐋𝐎 123

The spread syntax iterates Unicode code points rather than individual UTF-16 code units. That matters because mathematical bold capitals sit outside the Basic Multilingual Plane and are represented by surrogate pairs in JavaScript strings.

This snippet intentionally handles only A–Z. Lowercase letters and digits have their own ranges, and some visual styles contain gaps or special historical exceptions. A production converter should use an explicit, tested mapping rather than assuming every decorative alphabet forms a single contiguous sequence.

Why display, search, and speech can diverge

Visual similarity does not establish text equivalence everywhere. Search engines, application search boxes, screen readers, and copy-paste pipelines may normalize styled letters differently. A person searching for an ordinary spelling might miss a display name composed entirely of mathematical symbols, depending on the service.

Assistive technology introduces a different concern. A screen reader could announce a mathematical letter by its formal name, read it with an unexpected pause, or handle it as a familiar letter. Results vary across operating systems, language settings, and assistive technologies. There is no honest universal claim that every decorative character is inaccessible, or that all screen readers interpret it the same way.

Unicode normalization also deserves attention. NFKC normalization can map many mathematical alphanumeric symbols back to their plain-letter equivalents. This can help with comparisons, but it is not something we can assume every social app uses consistently. Nor should software silently rewrite all text without considering the user's intent.

Text form	What changes?	Practical consequence
CSS bold	Presentation	Underlying letters remain ordinary
Mathematical bold 𝐀	Character code point	Copy and search behavior can differ
Decorative separators	Extra symbols	May create pauses in spoken output
Plain Latin text	Neither	Most predictable across systems

A good compromise for profile names

We recommend keeping a readable core name in ordinary characters and using stylized text sparingly. The name people should type into search should remain findable. Decorative symbols can frame a short subtitle instead of replacing all essential information. When important details are involved, test the pasted version with selection, search, and spoken output.

Short profile bios are a better place for experimentation than security codes, addresses, registration forms, or instructions people must copy exactly. Fancy symbols can also be confusing in code snippets, usernames with strict character restrictions, and fields where normalization affects matching.

For teams that publish public-facing content, we like a simple checklist: compare the standard and stylized versions, copy both into the destination application, inspect them on mobile, and try a screen reader if accessibility matters. The last step is particularly valuable because the environment where the text ends up is the one that counts.

What a generator can and cannot change

A fancy text generator can replace supported letters and numbers with styled Unicode alternatives. It cannot make every language's complete script magically acquire equivalent mathematical letter sets. Decorations such as dividers, however, can sit alongside words in any language. That distinction prevents disappointment when someone pastes Japanese or Korean text expecting each character's strokes to change.

Our free text tool offers 56 styles, including bold, script, gothic, bubble, and small caps, with a copy workflow for names, bios, and captions. It also has a matching-name option for friends. Its role is to provide options; the user still decides where special characters belong.

FAQ

Are mathematical bold letters the same as applying bold formatting?

No. They are different Unicode code points. CSS formatting changes appearance without replacing the underlying Latin letter.

Will screen readers always read fancy text incorrectly?

No single result applies everywhere. Some combinations may be understandable, while others may announce symbol names. Testing is the reliable approach.

Can decorations work around non-Latin writing?

Yes. A divider or surrounding ornament can be used with any language, even where the letters themselves are not restyled.

If you want to inspect the difference by copying a few examples, use our free fancy text generator.

QR Error Correction, Center Logos, and the Difference Between Static and Redirect Codes

FUG — Thu, 08 Oct 2026 20:57:50 +0000

As of October 8, 2026

What a QR code can recover

When we add a logo to a QR code, we are deliberately covering part of the symbol. That sounds like an error, because it is one. The reason a phone can sometimes read the result is that QR codes encode redundant information using Reed–Solomon error correction. We build free web tools, and this is one of the places where understanding a small technical detail makes a large practical difference.

QR codes offer four commonly named error correction levels: L, M, Q, and H. Higher correction adds redundancy, but it also takes capacity. Given the same content, a higher level may require a denser symbol. The percentages typically associated with each level describe approximate recoverable damage to codewords, not a guarantee that a logo covering that percentage of the visible square is safe.

Level	Approximate recovery	Typical decision
L	7%	Clean, unobstructed environments
M	15%	General-purpose codes
Q	25%	Modest decoration with testing
H	30%	More margin for a centered logo

A central logo is particularly unforgiving when it overlaps functional patterns or when the code is already dense. The three large position markers, their surrounding quiet regions, and other structural elements are essential. Error correction cannot repair every arbitrary shape of damage.

A minimal implementation

The familiar open-source JavaScript qrcode package allows a level to be selected explicitly. For a simple test page, an example looks like this:

import QRCode from "qrcode";

const destination = "https://example.org/info";
const pngDataUrl = await QRCode.toDataURL(destination, {
  errorCorrectionLevel: "H",
  margin: 4,
  width: 640,
});

document.querySelector("#preview").src = pngDataUrl;

This example generates a normal QR image. It does not add a logo or prove that one is safe. If your UI overlays a logo afterward, you need a separate scan test of the finished composite. Keep the destination short when possible, because longer payloads can produce more modules. Test with multiple phones, camera distances, and lighting conditions, including the worst case you expect on paper.

The margin option matters too. A QR code needs a quiet zone, usually at least four modules of uninterrupted background around the symbol. Cropping tightly for visual balance can break recognition even when the central data remains untouched.

Static payloads versus redirect services

A static QR code contains the destination itself, such as a URL, Wi-Fi configuration, or contact fields. A redirect-based dynamic service commonly puts its own short URL in the symbol and forwards scans to the destination configured on its server. That approach can make the destination editable, but it also adds a service dependency.

People often say a static QR code never expires. More precisely, the encoded data does not carry a service-imposed expiration date. The destination website can still shut down, a domain can lapse, a Wi-Fi password can change, or an event can end. The pattern on the page stays the same, but what it points to may stop working.

For a long-lived poster, we prefer an address the publisher controls. We also suggest printing the human-readable URL nearby. A scan failure should not make the information inaccessible.

PNG or SVG for production?

PNG is a raster image. Its quality depends on the exported pixel dimensions relative to the size at which it is printed. A sufficiently large PNG can work perfectly well on a small card, but enlarging a small export introduces blurry edges. SVG uses vectors, so a designer can scale it to a larger sign without interpolation blur.

Neither format rescues poor contrast, an undersized quiet zone, or an excessively ornate mark. Dark modules on a light background remain the safest starting point. Color combinations should be inspected in grayscale as well as on screen. A glossy surface or reflected light can undermine an apparently strong design.

When handing files to a print shop, communicate the final physical dimensions. Exporting a huge bitmap without knowing the target size is less useful than confirming the final module size and printing a proof.

Our review routine before putting a QR code in public

We first generate an undecorated version and scan it. Then we raise the error correction level if a logo is necessary, keep the logo compact, and scan the resulting composition. We check the printed proof rather than trusting a monitor preview. Finally, we verify the exact payload, including capitalization and punctuation in the destination URL.

We treat QR codes as interfaces, not decoration. Their job is to transfer a small piece of information reliably. A beautiful code that nobody can scan fails that job.

FAQ

Does level H guarantee that a large logo will scan?

No. H adds more recovery capacity, but location, density, contrast, printing, and decoder behavior still matter. The finished code must be tested.

Does a static QR code need an account or monthly renewal?

The encoded pattern needs neither. Whether the resource at the destination remains available is a separate question.

Which download should we use for a poster?

SVG is convenient for scaling in a print layout. A large, sharply rendered PNG may also work when the final dimensions are known.

We made a free browser-based QR generator with nine payload types, options for logos, colors, and shapes, and PNG or SVG downloads. Codes are generated in the browser without a redirect layer; it also includes a separate group check-in room feature. Try the free QR generator.

Check a Password Against a Breach List Without Sending the Password

FUG — Wed, 07 Oct 2026 20:11:23 +0000

As of October 8, 2026

A password check can query a breach list without putting the password in an HTTP request. The browser hashes the input, sends five hexadecimal characters, and checks the returned candidates locally. We build small web tools, and we like this approach because the network boundary is explicit enough to inspect.

Have I Been Pwned provides this pattern through its Pwned Passwords range endpoint. The useful question for developers is what crosses that boundary, what stays in memory, and what the answer actually establishes.

Follow the value through the browser

SHA-1 produces a 160-bit digest, represented here as 40 hexadecimal characters. Split that string into a five-character prefix and a 35-character suffix. Request https://api.pwnedpasswords.com/range/{prefix}, substituting the prefix. The response contains candidate suffixes and their occurrence counts.

The browser compares its own suffix with those candidates. It never needs to transmit the remaining hash characters to finish the lookup.

Value	Where it is used	Sent in the range request?
Original password	Browser input and hashing	No
Complete SHA-1 hash	Browser memory	No
First five hexadecimal characters	Range URL	Yes
Remaining 35 characters	Local comparison	No
Candidate suffixes and counts	Response parsing	Returned by the service

This is the k-anonymity lookup pattern: one prefix identifies a group of candidate hashes rather than identifying the complete hash in the request. It reduces disclosure. It does not make the request anonymous or hide ordinary network metadata from the service.

A browser function you can run

Use this on an HTTPS page or localhost, where the browser's Web Crypto API is available. Call it from a submit handler with the password field's value. For experiments, use a disposable test string rather than a real credential.

async function breachCount(password) {
  const bytes = new TextEncoder().encode(password);
  const digest = await crypto.subtle.digest('SHA-1', bytes);
  const hash = Array.from(new Uint8Array(digest), byte =>
    byte.toString(16).padStart(2, '0')
  ).join('').toUpperCase();

  const prefix = hash.slice(0, 5);
  const suffix = hash.slice(5);
  const response = await fetch(
    `https://api.pwnedpasswords.com/range/${prefix}`,
    { headers: { 'Add-Padding': 'true' } }
  );
  if (!response.ok) {
    throw new Error(`Lookup failed: HTTP ${response.status}`);
  }

  const lines = (await response.text()).trim().split(/\r?\n/);
  for (const line of lines) {
    const [candidate, count] = line.trim().split(':');
    if (candidate === suffix) return Number(count);
  }
  return 0;
}

The function resolves to an occurrence count, or zero if its suffix is absent from a successful response. Network failures reject the promise; unsuccessful HTTP responses throw. A calling interface should catch those errors and show “check unavailable.” Turning a failed request into zero would give an unsupported reassurance.

The optional Add-Padding: true request header asks for padding entries, reducing information exposed through response size. Padding entries have zero counts. Our exact suffix comparison therefore still produces zero for a matching padding entry. The endpoint and padding behavior are documented in the official API reference.

Keep the surrounding interface honest

Preserve the entered string exactly. Trimming whitespace or changing capitalization before hashing checks a different password. The uppercase conversion in the snippet applies only to the hexadecimal representation of the digest, so it does not alter the password itself.

We would trigger this check after an explicit action rather than sending a request for every keystroke. Repeated prefixes from partially typed input disclose more than a single completed check. Keep password values out of URLs, console output, analytics events, and error reports, too.

Local hashing describes this lookup mechanism. It cannot guarantee that every other script running on the page behaves safely. A browser implementation still needs a trustworthy page and careful handling of the input. SHA-1 also appears here for compatibility with the lookup dataset; it is not a suitable recommendation for storing account passwords.

Read the result as one piece of evidence

A positive count says the password appears in the dataset. It does not identify which of the reader's accounts was affected, and the count is not a count of breaches involving that particular reader.

Zero means no match was returned for this check. A new but predictable password can still be weak. Password strength estimation is a separate task, and a time-to-crack estimate depends on assumptions about guessing methods and attack conditions. Neither a score nor an estimated duration is a guarantee.

Our free checker follows the local SHA-1 and five-character-prefix flow. It shows the breach count alongside a 0–100 security score and a time-to-crack estimate, and includes a strong-password generator. We describe those outputs separately so the lookup result does not masquerade as a complete security assessment.

FAQ

Does the service receive my password or its full hash?

In the range request shown above, it receives the first five hexadecimal characters only. The password, full hash, and suffix comparison remain in the browser. That statement concerns this code path, not every possible script on a page.

Is a password safe if the count is zero?

No. Absence from the returned dataset does not establish strength or uniqueness. We would still avoid reuse and choose a long, unpredictable password for each account.

Why use SHA-1 when it is unsuitable for password storage?

Here it creates a lookup identifier compatible with the dataset. Secure password storage has different requirements, including resistance to repeated guessing. Reusing this snippet as a password storage design would confuse those two jobs.

Check a password with our free tool

DEV Community: FUG

February 29 Needs a Policy Parameter, Not a Hidden Exception

Keep the birthday unchanged

An executable policy, with boundary tests

Do not hide the choice in exception handling

Reminders and age displays need a shared contract

FAQ

Why not add 365 days to find the next birthday?

Is February 28 always wrong?

Should I change the stored birth date?

Does this calculate months and days too?

When Fancy Names Collapse to One Search Key: Testing NFKC Collisions

Keep a second key

Run a collision fixture before building the index

Decide what a collision means in each workflow

Version the policy before changing existing data

Test the UI as well as the helper

FAQ

Should I replace display names with NFKC output?

Does normalization stop impersonation?

Is lowercase the same as Unicode case folding?

Does the generator provide this search index?

An Exact-Zero Cart Ledger with BigInt and a JSON Round Trip

Choose a unit before choosing a type

Make the update atomic

The receipt should come from the cart

JSON is an interface, not a backup spell

FAQ

Does a billion-credit budget require BigInt?

Can I use BigInt for decimal prices directly?

Why store quantities instead of the displayed balance?

Does this reproduce the game's source code?

Date Differences Without Traps: Calendar Days, UTC, Midnight, and DST

Start by naming the interval

A date-only value is not an instant

Why local midnight subtraction fails

Keep calendar and elapsed-time features separate

Test the boundary, not only the average day

FAQ

Should a countdown include today?

Why not divide milliseconds by 24 hours?

Is UTC always the right user time zone?

Does the calculator handle leap years?

Wi-Fi and vCard QR Codes: The Text Payloads Behind the Squares

The Wi-Fi payload is a small field language

vCard is contact text, not a screenshot

The payload controls density

A production checklist

FAQ

Can a Wi-Fi QR code hide the password from someone who scans it?

Does a vCard QR need a website?

Is higher error correction always better?

Why does punctuation break some codes?

Character Counts in JavaScript: Code Units, Code Points, Graphemes, and UTF-8 Bytes

Four units hiding behind one word

Use an explicit counter

“With spaces” is a policy, not another encoding

Match the counter to the boundary

Test strings belong in the suite

FAQ

Is string.length a character count?

Does spreading a string count what a person sees?

Why do UTF-8 byte counts matter?

Should spaces be removed before validation?

Fancy Text Is Unicode Data: What Developers Should Know About Accessibility

A copied letter is not necessarily a font

A tiny JavaScript experiment

Why display, search, and speech can diverge

A good compromise for profile names

What a generator can and cannot change

FAQ

Are mathematical bold letters the same as applying bold formatting?

Will screen readers always read fancy text incorrectly?

Can decorations work around non-Latin writing?

QR Error Correction, Center Logos, and the Difference Between Static and Redirect Codes

What a QR code can recover

A minimal implementation

Static payloads versus redirect services

PNG or SVG for production?

Our review routine before putting a QR code in public

Is `string.length` a character count?