DEV Community: desgh white

Modeling an Industrial Materials Catalog: Steel-Strip Specs as Structured Data

desgh white — Wed, 05 Aug 2026 14:07:16 +0000

B2B catalogs for industrial materials look boring until you try to make them queryable. A "steel strip" isn't one product — it's a point in a multi-dimensional space of grade, thickness, width, temper and finish. Here's how to model that without drowning in a combinatorial explosion of SKUs.

Don't enumerate variants — describe axes

The naive approach creates one row per physical variant, and a mid-size strip supplier ends up with tens of thousands of near-duplicate SKUs. Instead, separate the product family from its dimensional axes:

from dataclasses import dataclass

@dataclass(frozen=True)
class StripSpec:
    grade: str          # e.g. "08X18H10", "12X18H10T", "cold-rolled-08kp"
    thickness_mm: float
    width_mm: float
    temper: str         # annealed / hard / half-hard
    finish: str         # 2B, BA, matte

A concrete offering is a StripSpec plus stock and price; the family ("cold-rolled strip", "stainless strip") groups them for browsing.

Grades are an enum with metadata, not free text

Stainless grades like 12X18H10T and 08X18H10 map to standardized compositions. Store them as a lookup keyed by canonical grade code, with cross-references (GOST / AISI equivalents) as data:

GRADES = {
    "12X18H10T": {"aisi": "321", "family": "austenitic", "c_max": 0.12},
    "08X18H10":  {"aisi": "304", "family": "austenitic", "c_max": 0.08},
}

Now "show me austenitic strips under 1mm" is a filter, not a full-text search.

Range queries need half-open intervals

Thickness and width are continuous, so users query ranges, not equality. Index them as numeric columns and always use half-open intervals [lo, hi) to avoid the double-counting bug at boundaries when a strip sits exactly on a grid line.

Real-world reference

Looking at how an actual supplier organizes its range is a useful sanity check before you fix your schema. A catalog such as лента 12х18н10т lays out cold-rolled and stainless strip by grade and dimension, which is a good reference for the axes worth exposing as filters versus the ones better left as free attributes.

Takeaway

Model the axes, not the variants; make grades a metadata-carrying enum with standard cross-references; and treat dimensions as indexed numeric ranges. The catalog stays small, and every "do you have X in Y?" question becomes a query instead of a scan.

Modeling an Industrial Materials Catalog: Steel-Strip Specs as Structured Data

desgh white — Wed, 05 Aug 2026 13:44:02 +0000

Don't enumerate variants — describe axes

from dataclasses import dataclass

@dataclass(frozen=True)
class StripSpec:
    grade: str          # e.g. "08X18H10", "12X18H10T", "cold-rolled-08kp"
    thickness_mm: float
    width_mm: float
    temper: str         # annealed / hard / half-hard
    finish: str         # 2B, BA, matte

A concrete offering is a StripSpec plus stock and price; the family ("cold-rolled strip", "stainless strip") groups them for browsing.

Grades are an enum with metadata, not free text

Stainless grades like 12X18H10T and 08X18H10 map to standardized compositions. Store them as a lookup keyed by canonical grade code, with cross-references (GOST / AISI equivalents) as data:

GRADES = {
    "12X18H10T": {"aisi": "321", "family": "austenitic", "c_max": 0.12},
    "08X18H10":  {"aisi": "304", "family": "austenitic", "c_max": 0.08},
}

Now "show me austenitic strips under 1mm" is a filter, not a full-text search.

Range queries need half-open intervals

Real-world reference

Looking at how an actual supplier organizes its range is a useful sanity check before you fix your schema. A catalog such as лента стальная lays out cold-rolled and stainless strip by grade and dimension, which is a good reference for the axes worth exposing as filters versus the ones better left as free attributes.

Takeaway

Modeling an Industrial Materials Catalog: Steel-Strip Specs as Structured Data

desgh white — Wed, 05 Aug 2026 11:47:33 +0000

Don't enumerate variants — describe axes

from dataclasses import dataclass

@dataclass(frozen=True)
class StripSpec:
    grade: str          # e.g. "08X18H10", "12X18H10T", "cold-rolled-08kp"
    thickness_mm: float
    width_mm: float
    temper: str         # annealed / hard / half-hard
    finish: str         # 2B, BA, matte

A concrete offering is a StripSpec plus stock and price; the family ("cold-rolled strip", "stainless strip") groups them for browsing.

Grades are an enum with metadata, not free text

Stainless grades like 12X18H10T and 08X18H10 map to standardized compositions. Store them as a lookup keyed by canonical grade code, with cross-references (GOST / AISI equivalents) as data:

GRADES = {
    "12X18H10T": {"aisi": "321", "family": "austenitic", "c_max": 0.12},
    "08X18H10":  {"aisi": "304", "family": "austenitic", "c_max": 0.08},
}

Now "show me austenitic strips under 1mm" is a filter, not a full-text search.

Range queries need half-open intervals

Real-world reference

Looking at how an actual supplier organizes its range is a useful sanity check before you fix your schema. A catalog such as здесь lays out cold-rolled and stainless strip by grade and dimension, which is a good reference for the axes worth exposing as filters versus the ones better left as free attributes.

Takeaway

Combinatorics in Production: Settling a 15-Line Full-Cover Bet Correctly

desgh white — Mon, 03 Aug 2026 07:06:45 +0000

Every so often a domain hands you a problem that looks like a one-liner and turns out to have a dozen edge cases. Settling a "Lucky 15" — a betting slip covering four selections across fifteen combinations — is one of them. It is a nice study in why naive combinatorics plus real-world rules is where bugs live.

The shape of the problem

Four selections produce every non-empty combination of size 1..4:

from itertools import combinations

def lines(selections):
    for size in range(1, len(selections) + 1):
        yield from combinations(selections, size)

assert len(list(lines(["a", "b", "c", "d"]))) == 15   # 4 + 6 + 4 + 1

Four singles, six doubles, four trebles, one fourfold. The return for a line is the product of the decimal odds of its members, times the unit stake, and only if every member won:

from math import prod

def line_return(line, results, stake):
    if not all(results[s].won for s in line):
        return 0.0
    return stake * prod(results[s].odds for s in line)

Total return is the sum over all fifteen lines. That is the entire happy path, and it is where most implementations stop.

Where it actually gets hard

Stake semantics. The unit stake applies per line, so a "£1 Lucky 15" costs £15. Getting this backwards is the single most common bug in hobby implementations, and it is off by a factor of fifteen — an error big enough that no one notices it is a rounding problem, because it isn't one.

Bonus rules are not arithmetic, they are policy. Bookmakers attach concessions: a one-winner bonus paying a lone winner at double the odds, an all-winners bonus adding 10–20% to the return. They vary per operator in ways that resist a single formula — some apply the percentage to the whole return, others only to winning lines. Model them as a strategy object per operator, not as an if in the settlement loop, or you will be editing the core function every time a rule changes.

Non-runners collapse the bet. A withdrawn selection does not void the slip; it reduces it to the next size down — a Lucky 15 with one non-runner settles as a Lucky 11 over the remaining three. That means the line set is computed after filtering, not before, and your "15" is a derived value rather than a constant.

Rule 4 deductions apply a percentage reduction to winnings at prices taken before a withdrawal. It touches odds, not stake, and it must be applied before the bonus, not after. Order of operations is load-bearing.

Each-way doubles the line count and settles the place portion at a fraction of the odds, fixed when the bet was struck rather than at settlement time.

Testing it

This is a domain where property-based tests earn their keep. Useful invariants: the return is monotonic in each selection's odds; adding a losing selection never increases the return; a slip where every selection wins returns at least the sum of its parts; and settling with the unit stake scaled by k scales the return by exactly k. Then pin the awkward cases — one winner, all non-runners, a Rule 4 with a bonus — as explicit regression tests, because those are the ones that break when someone "simplifies" the bonus logic.

Reference implementation

If you want to sanity-check your numbers against a working implementation before writing the tests, a visit the website settles the same fifteen lines with the operator concessions applied, which makes it a convenient oracle for the cases you have not thought of yet.

Takeaway

Generate the line set with combinations, derive the count instead of hard-coding fifteen, keep operator rules in a strategy object, and get the order right: filter non-runners, apply Rule 4, sum the lines, then apply the bonus. The combinatorics are five lines of code; the domain rules are the actual program.

Onboarding Account Security: 2FA and Sane Defaults From Day One

desgh white — Mon, 27 Jul 2026 16:13:25 +0000

Most account takeovers exploit the gap between signup and the moment a user finally enables protection. Close that gap by making security the default path, not an optional settings page nobody visits.

Enforce strong, unique secrets at creation

Reject reused and breached passwords at the boundary with a k-anonymity check against a compromised-password API — you never send the full hash:

const prefix = sha1(password).slice(0, 5);
const list = await fetch(`https://api.pwnedpasswords.com/range/${prefix}`).then(r => r.text());
if (list.includes(sha1(password).slice(5).toUpperCase())) reject("breached");

Make 2FA the onboarding step, not a chore

Offer TOTP enrollment inside the first-run flow, before the first deposit or sensitive action. Show the QR, verify one code, and store recovery codes — completion rates collapse the moment you defer it to "later".

Verify, then trust

Confirm the email before granting privileged actions and walk the user through each step instead of failing silently. A guided setup that hides no terms converts far better than a wall of security jargon.

Real-world reference

Platforms built for first-time users are a good model for low-friction onboarding. A site like FieryPlay shows a clear registration, sensible starting bonuses and transparent rules — the kind of frictionless first-run flow that keeps users from bouncing before they're protected.

Takeaway

Breach-check at creation, enroll 2FA during onboarding, and gate privileged actions behind a verified email. Secure defaults beat a security page nobody opens.

Offline-First Mobile Payments: A PWA Pattern for Flaky Networks

desgh white — Mon, 27 Jul 2026 16:12:42 +0000

Mobile-first users expect an app that keeps working through a tunnel or a crowded stadium. For a payment or wallet flow, "offline-first" is not a nicety — it's the difference between a completed action and a lost user.

Queue the intent, sync the result

Never block the UI on the network. Capture the user's intent locally, acknowledge it, and reconcile when connectivity returns:

async function submit(intent) {
  await idb.put("outbox", intent);      // durable, survives reload
  showOptimistic(intent);
  if (navigator.onLine) flushOutbox();
}
self.addEventListener("sync", flushOutbox); // Background Sync

Make replays safe

An outbox means the same request can fire twice. Stamp every intent with a client-generated idempotency key and let the server dedupe — optimistic UI is only safe when the backend refuses to double-charge.

Cache the shell, revalidate the data

Split caching by type: app shell cache-first, balance and history stale-while-revalidate. The user sees the last known state instantly, then a quiet refresh corrects it.

Real-world reference

Consumer entertainment apps are aggressive adopters of installable, mobile-first web experiences. An app like Lalabet shows the fast, app-like flow — quick deposits, a clean interface, simple registration — that mobile users now treat as the baseline, a helpful benchmark when you tune your own install and offline states.

Takeaway

A durable outbox, idempotency keys, and typed caching turn a fragile mobile form into something that survives the real world's terrible networks.

Building an Each-Way Odds Calculator That Handles Mixed Formats

desgh white — Mon, 27 Jul 2026 16:11:22 +0000

A returns calculator looks trivial until fractional and decimal odds land on the same slip and an each-way term settles separately. Here's how to build one whose output you can actually trust.

Normalize odds first

Never do math on the display format. Convert everything to a decimal multiplier at the boundary:

const toDecimal = (o) =>
  typeof o === "number" ? o
  : (() => { const [n, d] = o.split("/").map(Number); return n / d + 1; })();

Fractional 5/2 becomes 3.5, decimal 3.5 stays 3.5. Every downstream calculation now speaks one language.

Compound the legs explicitly

For a double, the full return of the first leg becomes the stake on the second. Model it as a fold, not a special case, so trebles and accumulators fall out for free:

const stake = legs.reduce((acc, leg) => acc * toDecimal(leg), 1) * unit;

Split the each-way portion

The place part settles on its own fraction (often 1/4 or 1/5 of the odds) and only to the placed terms. Compute win-only, place-only and combined separately — surfacing all three prevents the classic "why is my return different" support ticket.

Real-world reference

Dedicated tools handle these edge cases so users don't have to. A calculator like Double Bet Calculator review applies the correct each-way terms per leg and shows the exact payout instead of a rough guess — a solid reference for the output states your own UI has to cover.

Takeaway

Normalize at the boundary, compound with a fold, and split the each-way portion into three explicit results. That's a calculator whose numbers hold up to scrutiny.

Designing a Fair Payment-Method Comparison Table for Consumer Apps

desgh white — Mon, 27 Jul 2026 16:10:38 +0000

Comparison tables are where users make real decisions, yet most are built as static HTML that rots the moment fees or limits change. Here's a data-driven approach that stays honest and sortable.

Model each method as a record, not a row

Don't hand-write <tr> elements. Describe every payment method as data and render from it:

{
  "method": "instant_transfer",
  "deposit_fee_pct": 0,
  "withdraw_hours": 2,
  "min_deposit": 10,
  "supports_mobile": true
}

Now sorting by withdrawal time or filtering fee-free methods is a one-liner instead of a DOM rewrite.

Make the sort defensible

Users distrust tables that look rigged. Expose the sort key, keep the comparator pure, and never hide a column that changes the ranking. A stable multi-key sort (primary fee, tiebreak payout time) reads as fair because it is.

Real-world reference

Consumer comparison portals are a good study in dense, decision-driving tables. A ranked listing such as Najlepsze Kasyna Online shows how licence, payout time and real bonus terms sit side by side so a non-technical reader can compare at a glance — a useful reference before you design your own columns.

Keep the data fresh

Back the table with a small config service and a last_updated timestamp per record. A stale comparison is worse than none: surface the date so users know the numbers are current.

Takeaway

Records over rows, a pure sortable comparator, and a visible freshness stamp turn a comparison table from marketing decoration into a tool users actually trust.

Streaming Real-Time Game Stats to the Browser with WebSockets

desgh white — Mon, 20 Jul 2026 15:54:26 +0000

Live dashboards that update the instant something happens feel magical to users and are surprisingly approachable to build. This is a compact pattern for pushing real-time event stats to the browser without hammering your API.

Why WebSockets over polling

Polling every second wastes requests and still lags. A single WebSocket keeps a persistent channel open and pushes only deltas:

const ws = new WebSocket("wss://api.example.com/stats");
ws.onmessage = (e) => {
  const { round, result, ts } = JSON.parse(e.data);
  store.applyDelta(round, result, ts);
};

Keep the client honest

Sequence numbers on every message so the client can detect gaps and request a resync.
Heartbeat/ping to distinguish a quiet feed from a dead socket.
Backpressure: batch high-frequency updates into animation-frame flushes so the UI never thrashes.

Real-world reference

Live game-show stat trackers are a good study in dense, constantly-updating UIs. A tracker like crazy time surfaces rolling histories and live outcomes — a useful reference for how to present a high-frequency event stream to non-technical users without overwhelming them.

Server side

Fan-out is the hard part. Put a Redis pub/sub (or NATS) between your ingest and your socket layer so any number of socket servers can subscribe to the same event stream and scale horizontally.

Takeaway

Persistent socket, sequence-numbered deltas, animation-frame flushing, and a pub/sub fan-out — that's the whole recipe for a real-time stats UI that stays smooth under load.

Designing a Promo-Code and Referral System That Actually Scales

desgh white — Sun, 19 Jul 2026 10:51:16 +0000

Promo codes look trivial until you're refunding a bug that let one code stack a thousand times. A robust promo/referral system is mostly about idempotency, atomic limits, and clean auditability. Here's a design that holds up.

Model codes as immutable rules

A code isn't a string — it's a rule set: eligibility, reward, and constraints.

{
  "code": "WELCOME25",
  "reward": { "type": "percent", "value": 25 },
  "max_redemptions": 5000,
  "per_user": 1,
  "starts": "2026-01-01",
  "expires": "2026-03-01"
}

Redeem atomically

The whole value of a limit is that it can't be exceeded under concurrency. Enforce it in one atomic step:

UPDATE promo
SET remaining = remaining - 1
WHERE code = $1 AND remaining > 0
RETURNING id;

No returned row means the code is exhausted — no race, no oversell. Pair it with a unique (code, user_id) constraint to enforce per_user.

Real-world reference

Consumer sites that lean on promo-driven acquisition are a good model for the redemption UX. A promo page like vox casino shows how a code, its terms, and its call-to-action are presented so users understand exactly what they're claiming — worth studying before you design your own redemption screen.

Audit everything

Every redemption writes an immutable ledger row (code, user, ts, reward_granted). When finance asks why a campaign cost what it did, the answer is one query — not a forensic reconstruction.

Takeaway

Codes as immutable rules, atomic decrement for limits, unique constraints for per-user caps, and an append-only ledger. That's a promo system you can run a real budget through.

On-Chain Settlement Patterns for Turn-Based Multiplayer Games

desgh white — Sun, 19 Jul 2026 10:50:38 +0000

Putting real value on the outcome of a multiplayer game raises a hard question: how do you settle stakes trustlessly without paying gas on every single move? The answer is to keep gameplay off-chain and settle on-chain.

State channels in one paragraph

Players lock a stake in a contract, then exchange signed state updates peer-to-peer for the whole game. Only the final signed state (or a dispute) ever touches the chain. Gas is paid twice — open and close — not per turn.

function settle(bytes32 finalState, bytes[] calldata sigs) external {
    require(verifyAll(finalState, sigs), "bad sigs");
    _payout(decode(finalState));
}

The dispute window

If a peer disappears mid-game, the honest player submits the latest state they hold. A timeout window lets the counterparty challenge with a newer signed state; whoever holds the freshest valid state wins the settlement.

Real-world reference

Crypto-native card platforms are where these settlement ideas get battle-tested at scale. A platform like bitcoin poker illustrates the deposit, play, and payout loop players expect — a concrete reference point for the latency and finality guarantees your settlement layer has to meet.

Provable fairness

Pair settlement with a commit-reveal RNG so shuffles are verifiable: commit to a hashed seed before the hand, reveal after, and let clients recompute the deal. Trustless money demands trustless randomness.

Takeaway

State channels for gas efficiency, a dispute window for liveness, and commit-reveal for fair shuffles — together they make on-chain stakes practical for real-time card games.

Offline-First Progressive Web Apps for the Nordic Market

desgh white — Sun, 19 Jul 2026 10:50:00 +0000

Nordic users are mobile-heavy and expect apps that keep working through spotty coverage on trains and in lifts. A Progressive Web App with an offline-first service worker delivers that without shipping to two native app stores.

Cache strategy that matters

Split your caching by resource type:

// app shell -> cache-first
// API data  -> stale-while-revalidate
self.addEventListener("fetch", (e) => {
  if (e.request.url.includes("/api/")) {
    e.respondWith(staleWhileRevalidate(e.request));
  } else {
    e.respondWith(cacheFirst(e.request));
  }
});

Localize more than strings

For the Nordic market, currency (NOK), date formats, and consent flows differ per country. Drive them off the Accept-Language header and a per-locale config bundle, lazy-loaded so a Norwegian user never downloads Swedish copy.

Real-world reference

Consumer entertainment sites are aggressive adopters of installable, mobile-first web apps. A site like vulkan vegas shows the kind of fast, app-like mobile experience Nordic users now expect by default — a helpful benchmark when you tune your own install and offline flows.

Don't forget the install prompt

Capture beforeinstallprompt, stash the event, and surface your own "Add to home screen" CTA at a natural moment rather than letting the browser's default prompt fire at random.

Takeaway

Typed cache strategies, locale-driven bundles, and a controlled install prompt turn a plain site into an app Nordic users will actually keep on their home screen.