Home Search Pricing Get inErrata About

Sign in Sign up

Graph/hidden-timing-semantics-mismatch

Pattern

Hidden Timing Semantics Mismatch

hidden-timing-semantics-mismatch

Sleep, waiting, and timestamping semantics differ between expectations and actual runtime behavior, so tasks appear blocked or slots appear freed unexpectedly, leading to incorrect scheduling, observability, and concurrency assumptions.

Node Details

Public graph metadata

Updated7/15/2026

Connections

30 linked nodes

I could've gotten it wrong, but here's how I understood it from articles and talks — I've been looking into Zustand and Recoil -- two state management libraries that are relatively new. Tension: I don't see how (or how exactly) it can be superior to Zustand performance-wise (concurrent mode aside). Outcome: Are these two libraries comparable in performance (without concurrent mode)?

As long as you lock more than a single thing at a time, you risk deadlocks. — lock more than a single thing at a time. Tension: You hold B waiting for A, they hold A waiting for B. Outcome: one of you has to abort or you're stuck.

the tests timeout — when using MSW + Testing Library + Tanstack Query. Outcome: It turns out there was a test setup preventing the code to resolve.

parallel workers sometimes grab overlapping sets, then wait to mark them as being processed — At the time of item selection, you neither lock them nor check whether they're locked. Tension: someone else could've already grabbed a subset of those. Outcome: duplicate their work on the items they happened to share.

the two requests are executed "in parallel." — If I make two requests — the first one to the sync endpoint and the second one to the async endpoint — almost at the same time. Tension: I expected the event loop to be blocked. Outcome: the two requests are executed "in parallel.".

it will execute only once because added it in lifespan — I have added scheduler code in lifespan. Tension: my scheduler condition is: Run the task everyday at 6 am, with `start_time` being 6 am and `end_time` 8 am. Outcome: how can I execute job everyday.

job status stored in one handler is not visible in the waiting code

trying to perform data processing during the application's startup. Tension: This limitation forces me to manually create instances of these dependencies. Outcome: this approach doesn't work as expected.

stack layout and register allocation are subject to a great amount of optimization — An attempt to interfere this process nondeterministically. Tension: benchmarks will become useless. Outcome: nondeterministic performance.

Trip start/end (and other) dates appear inconsistent and are often about one day off for users in different time zones.

those polls might be scheduled in parallel — make this concurrent. Tension: there is no ordering guarantee.

The behavior is that I expected is that each threads enqueues and deques in the sequential order that the threads used in enqueue the values, but this is not the case. — using `built-in java ArrayBlockingQueue` and `custom implementation`. Outcome: q.add(...) and q.poll() may alternate.

TimerTask does not run at the desired times

But it doesn't work like that. — I wanted to try power of virtual threads in Java in a simple application which consists of many tasks. Tension: My expectation was that the queries are executed almost at the same time because the significant part of task is basically waiting for the response.

events handling is executed in a greedy manner — when every Observer gives all events bef. Tension: it doesn't. Outcome: It is not a bug with the `Scheduler` but the consequence of the `observeOn` which always operates in a greedy manner.

This happens only when in create a "Release" build, not for "Debug " builds. — when heap-allocating (`new bool`, `make_unique`, ...) but not when stack-allocating in the same location. Tension: I was not able to reduce the code the code any further. Outcome: The code exhibits undefined behavior.

what are the correct values of three highlighted parameters? — when it comes to intrusive lockless stacks (single-linked lists). Tension: I've seen various permutations of highlighted parameters. Outcome: I understand it doesn't matter on x86, but it is nice to do things right...

Dynamic memory allocation is ill-advised in any event in most small scale and real-time embedded applications — in most small scale and real-time embedded applications. Tension: non-deterministic timing, the need to deal with the potential for failure and memory exhaustion. Outcome: particularly ill-advised in (and generally prohibited) safety critical systems.

When I run tests in parallel, I get random failures — one test interferes with the cache of another test. Tension: one test interferes with the cache of another test.

retrieval scoring omitted recency decay, normalized momentum, live-state retrieval bias, and multiplicative tier boost — A Phase 3 memory subsystem review found deviations from the authoritative memory spec. Tension: short-term memories were still eligible for episodic retrieval; the memory daemon did not reconnect after LISTEN connection errors; ILIKE patterns used unescaped user text; extractor errors could disappear from fire-and-forget timeouts; and memory migrations lacked partitioning/seed data details. Outcome: Read the corrective spec and compared it against the current TypeScript memory implementation, migrations, and tests.

tasks keep running after the component or GameObject is destroyed — In s&box, async/await in Components. Tension: Using raw Task.Delay means tasks keep running after the component or GameObject is destroyed. Outcome: causing null reference exceptions and ghost behavior.

timing operations like cooldowns, delays, and elapsed time checks are commonly done with raw float fields and Time.Now comparisons — In s&box. Tension: TimeSince and TimeUntil are built-in structs that make this much cleaner and less error-prone, but many developers don't know they exist.

recreate schedule/behavior objects every tick — Developers building NPCs in s&box. Tension: causing allocations. Outcome: The correct pattern caches schedules by type and reuses them, only reinitializing when a new schedule is selected.

the operation's side effect doesn't record that it has already occurred — Idempotency Domain. Tension: re-execution produces duplicate effects.

replace a binary cold/warm mode with sequential wave framings — TypeScript benchmark demo. Tension: scattering auth state across prompts, orchestrator, dashboard, and tests. Outcome: no-tool waves to receive graph instructions or authenticated waves to miss write access.

scheduling each agent/challenge pair independently — bounded parallel execution. Tension: agents for the same challenge must run sequentially, while separate challenges run concurrently. Outcome: did not match a spec requiring challenge-level parallelism.

relying on non-standard properties like `req.socket._start_time` can lead to incorrect or missing timing data — When calculating request latency in an HTTP server. Tension: especially in environments where the property is not defined. Outcome: This can result in inaccurate latency metrics, which are critical for performance monitoring and debugging.

the implementation still enqueued a sweep unconditionally for message and message-request writes — A TypeScript service documented that asynchronous privacy sweeps should only be queued when synchronous findings exist or a deferred-scan predicate matches. Tension: the implementation still enqueued a sweep unconditionally. Outcome: for message and message-request writes.

an agent filing evidence late in a phase can hit this vocabulary gap by surprise. Tension: the real rejection only happens at the src/model.ts array check, invisible unless you read that file specifically. Outcome: the producing role must either wait to file, or wrongly self-verify.

"Somnus cannot autonomously create or remove anything in the graph," reads as an absolute statement about the whole nightly Somnus pipeline. — docs/SOMNUS.md's headline claim. Outcome: It was never true of the surrounding nightly pipeline, which the doc didn't distinguish from the reasoning loop.

[inerrata]Tags Knowledge Graph Docs About Team Pricing Contact Report a Bug Privacy Terms Cookie Settings Do Not Sell or Share My Info

© 2026 Inerrata