Posts

Setting up domain configurations for GitHub Pages

Expand, migrate, verify, switch, and contract across independently deployed application versions.

Shutdown is a protocol: stop admission, drain in-flight work, flush state, then release dependencies.

Separate syntactic validation, domain rules, and authorization, then return stable problem details.

A lease bounds stale ownership only when fencing tokens protect the resource from expired holders.

Rejecting excess work early preserves useful throughput and bounded latency for admitted requests.

Atomic updates, locks, or optimistic versions must protect read-modify-write as one decision.

Retries spend remaining deadline and capacity; they do not create either.

Randomized election timeouts and term monotonicity turn competing candidates into one current leader.

Design indexes from predicates, join keys, ordering, selectivity, and write cost together.

Concurrency equals arrival rate times time in system, giving a fast check for queues and resource demand.

A package is stable when its responsibilities, exported surface, and dependency direction are narrow.

Compare-and-swap plus leases can encode ownership, but clients must handle revision and expiry races.

The key determines ordering and skew; partition count sets the ceiling for group parallelism.

Logs need stable event names, correlation, severity discipline, and deliberate data minimization.

Persist the business effect and message identity in one atomic boundary whenever possible.

A hash ring limits key movement, but load balance still depends on virtual nodes and key distribution.

Choose isolation by naming the anomaly that would violate a business invariant.

Translate user journeys into load, latency, consistency, privacy, availability, and cost envelopes.

End-to-end exactly-once claims decompose into deduplication, atomicity, and replay-safe effects.

Prefer compatible evolution; version only when semantics truly conflict and plan convergence.

Choose the weakest ordering guarantee the business invariant needs and encode it per entity.

Bind a client key to request identity and persist the decided response for the retry window.

Generics can remove unsafe casts while explicit synchronization and expiry semantics preserve correctness.

Allocation work starts with profiles and escape analysis, then targets lifetime and representation.

Sign payloads, preserve event identity, acknowledge quickly, and make processing replay-safe.

Each service adds deployment, ownership, observability, compatibility, and failure-management obligations.

Child goroutines should share cancellation, error propagation, and a bounded lifetime with their parent.

Use channels for ownership transfer and coordination, not as a universal replacement for locks.

Pool size must reflect database concurrency, transaction duration, and queueing—not application goroutine count.

Understand sync primitives deeper by building them.

Batch APIs need per-item outcomes, bounded size, deterministic identity, and explicit atomicity.

Stream with hard limits, quarantine content, verify type independently, and decouple scanning from trust.

Intersecting read and write quorums provide a reasoning tool, not automatic availability or freshness.

Every goroutine needs an exit condition that remains reachable when downstream work stops.

Define ownership, expiry, invalidation, stampede control, and degraded behavior before adding cache code.

Random peer exchange trades immediate agreement for scalable, failure-tolerant convergence.

A pipeline without bounded queues and cancellation is an outage amplifier.

Deadlines cross service boundaries; status codes must separate retryable transport conditions from domain outcomes.

Detect skew, isolate the key, coalesce work, and change partitioning only with evidence.

Automate checks for the architectural properties that must remain true as teams and systems change.

Token buckets express sustained rate and burst capacity while keeping admission decisions cheap.

Propagate context, name spans by operation, and attach identifiers without recording sensitive payloads.

Why Go JSON Unmarshal turns int64 into float64 and how to fix it.

Choose receiver and parameter semantics from ownership, mutability, and copy cost rather than habit.

Seek from the last ordered key to keep page cost stable and results coherent.

Stabilize impact, preserve a timeline, test hypotheses with signals, and separate recovery from diagnosis.

Benchmarks need stable inputs, allocation reporting, multiple runs, and a comparison tied to user impact.

Use short-lived identity-bound credentials and design renewal and revocation as runtime paths.

Partition for lifecycle, order for filtering locality, and measure cardinality before choosing codecs.