News for hackers. Stuff that matters.

SpicyG

Show HN: Context-Free Recovery via Constant-Time Enforcement

https://gist.github.com/SvengsFuture/d85bc01e26ef7dbc1b9c1bab2528b866

I wrote this to describe an execution model where recovery is enforced locally instead of inferred from history. Rather than retries replay or coordination each unit admits or rejects state and input pairs and resets immediately when constraints are violated. Recovery cost is constant failures do not correlate and tail latency never forms because there is no recovery negotiation. This is not...

( Read More... | no comments | on HN )

Show HN: A minimal example of why reactive systems oscillate

I kept seeing the same failure pattern across systems that look unrelated on the surface: autoscaling that flaps, alert storms that resolve on their own, retraining pipelines that chase noise, and failover logic that makes things worse before they get better.In each case, nothing was obviously “wrong.” The metrics were real. The thresholds made sense. The logic was locally defensible. What...

( Read More... | no comments | on HN )
Re:Ask HN: Can systems function correctly without memory? on Sunday December 28, 2025 @09:15AM (#46411208)
I think that’s a real tradeoff, but I’d frame it slightly differently. The rigidity here is intentional at the gate, not across the whole system. The constraint is that admissibility rules must be explicit and versioned, not that they never change. Evolution happens by introducing new admissible inputs (new proofs, new schemas, new validators), while the old ones continue to fail or succeed deterministically. If the system requires coordinated internal evolution to handle change, then yes, you drift toward a monolith. But if evolution is pushed to the edges (new request types, new validators, new execution paths) while the gate remains simple, the core doesn’t need to evolve in lockstep. I see this less as “rigidity vs flexibility” and more as where change is allowed to accumulate. If change accumulates inside the core, complexity grows superlinearly. If it accumulates at the boundary as new admissible forms, the core stays boring even as the surface evolves. There’s definitely an inflection point where negotiated state becomes unavoidable, but the goal is to push that point as far out as possible, not pretend it doesn’t exist.
Re:Ask HN: Can systems function correctly without memory? on Saturday December 27, 2025 @09:57PM (#46407954)
I agree, and I think this is where the distinction matters. I’m not claiming that state disappears, or that computation can be purely stateless all the way down. There is always state somewhere - registers, buffers, disks, networks. The question is where authority lives and whether correctness depends on reconstructing history. The inefficiency you point out is real: recomputing everything from arguments is often worse than persisting state. That’s why the pattern I’m aiming at isn’t “no state,” but no implicit, negotiated state. State can exist, be large, and even be shared — but it should be explicit, bounded, and verifiable, not something the system has to infer or reconcile in order to proceed. At the lowest levels, yes, registers hold values and operations mutate targets. But those mutations are local, immediate, and enforced by hardware invariants. Problems tend to appear higher up when systems start treating historical state as narrative, as something to reason about, merge, or explain, rather than as input with strict admissibility rules. So I see this less as a theoretical purity claim and more as a placement problem: push state to places where enforcement is cheap and local, and keep it out of places where it turns into coordination and recovery logic.
Re:Ask HN: Can systems function correctly without memory? on Saturday December 27, 2025 @09:54PM (#46407946)
I agree, and I think you’ve named the core constraint cleanly. The distinction I’m trying to draw isn’t “no memory ever,” but no implicit memory required for correctness. If there’s no memory, there’s nothing to corrupt. If memory is carried by the request, it can’t desynchronize from the request. That’s really the invariant I care about. I also agree that cryptographic techniques make this tractable in practice. Signed tokens, capabilities, idempotency keys, and replay protection let you move state to the edge, while also keeping the core enforcement logic stateless. In that model, reuse can be a feature rather than a bug, as long as it’s explicit and verifiable. Where I’ve seen things break down, is when state is large or shared and gets merged implicitly. As you say, sometimes you can’t pass it around like a football, but even then accessing it by key and merging it in a disciplined and bounded way, preserves the same principle: the system shouldn’t need to remember in order to act correctly. So for me it’s less “stateless vs stateful” and more “enforced state vs negotiated state.” Once the system starts negotiating with history, entropy creeps in very fast.

Ask HN: Can systems function correctly without memory?

I’ve been thinking about whether memory is actually a runtime requirement for correctness, or just a training signal whose effects persist even when recall is no longer needed.In practice, many distributed systems accumulate complexity because they treat state as something to negotiate with rather than something to enforce against. When systems attempt to reconcile past states in order to act...

( Read More... | 6 comments | on HN )