Tag
9 posts
Temporal's sleep-for-days races a 30-day timer against a signal channel via NewSelector. Resonate's equivalent is ctx.Sleep(d) + f.Await(nil) — Selector gone, durability kept.
Port Temporal's sleep-for-days sample to Resonate. The timer leg of the Selector loop maps to ctx.Sleep(d) + f.Await(nil); crash recovery resumes on the remaining time, not from zero.
The two-loop discipline — dispatch all before awaiting any — is identical in both systems. `workflow.ExecuteActivity` / `future.Get` simply becomes `ctx.RPC` / `f.Await`.
Port Temporal's splitmerge-future Go sample to Resonate. The two-loop idiom is identical — dispatch all, then await all — but `ctx.RPC` replaces `workflow.ExecuteActivity` and `f.Await` replaces `future.Get`.
Temporal's child-workflow mechanism collapses into one registered function that calls itself by name via ctx.RPC. No separate child type, no ContinueAsNew, no per-child options.
Port Temporal's child-workflow pattern to Resonate. A function calls itself via ctx.RPC — no child-workflow type, no WithChildOptions, no ContinueAsNew to bound history.
Temporal's helloworld maps to a single Go function — no workflow/activity types, no task queue, no activity options. Just `resonate.Register` and a promise ID.
Port Temporal's helloworld Go sample to Resonate. The workflow/activity split, the task queue, and activity options collapse into one registered function invoked by a durable promise ID.
Temporal registers compensation eagerly with defer closures that unwind LIFO. Resonate runs it inline in the error branch — same reverse-order rollback, different shape.
Maps Temporal's saga sample to example-money-transfer-go: defer-LIFO compensation vs. inline guarded undo — same reverse-order rollback, different code shape.
Temporal's await-signals needs a signal channel, a listener goroutine, a flag, and workflow.Await. Resonate collapses all four into one ctx.Promise().
Port Temporal's await-signals pattern to Resonate. One latent ctx.Promise() replaces a signal channel, a listener goroutine, a flag variable, and workflow.Await — the promise record itself is the pending state.
The durable-loop-of-ticks pattern — ctx.RPC then ctx.Sleep each iteration — replaces workflow.ExecuteActivity + workflow.NewTimer + NewSelector with two two-liners per tick.
A durable loop of ctx.RPC + ctx.Sleep ticks that resumes at the next pending tick after a crash; maps structurally to Temporal's sleep-for-days, timer, and cron samples.
Checkpointed steps + an operator approval gate: a production Go orchestrator that maps two Temporal patterns to two Resonate primitives.
A Kubernetes node-drain orchestrator composing checkpointed steps (ctx.Run) and an operator approval gate (ctx.Promise) — mapping Temporal's saga and await-signals patterns side by side.
ctx.RPC + Await, ctx.Detached, and the two-loop fan-out — mapped from Temporal's child-workflow, ABANDON policy, and splitmerge-future.
Three RPC dispatch shapes — await-chain, detached, and fan-out — mapped from Temporal child-workflow variants to Resonate's ctx.RPC and ctx.Detached.
We value your privacy
We use strictly necessary cookies to run this site. With your consent we also use Google Analytics to understand traffic. We do not load analytics until you choose to allow it. Privacy Policy.