Hacker News: KraftyOne

New comment by KraftyOne in "Building durable workflows on Postgres"

KraftyOne — Thu, 28 May 2026 19:55:14 +0000

Secrets are orthogonal to durable execution--what are your concerns about using them together?

Building durable workflows on Postgres

KraftyOne — Thu, 28 May 2026 18:41:46 +0000

Article URL: https://www.dbos.dev/blog/postgres-is-all-you-need-for-durable-execution

Comments URL: https://news.ycombinator.com/item?id=48313530

Points: 347

# Comments: 142

Postgres Is All You Need for Durable Execution

KraftyOne — Thu, 21 May 2026 18:16:29 +0000

Article URL: https://www.dbos.dev/blog/postgres-is-all-you-need-for-durable-execution

Comments URL: https://news.ycombinator.com/item?id=48226873

Points: 1

# Comments: 0

What's Easy Now? What's Hard Now?

KraftyOne — Tue, 19 May 2026 16:49:37 +0000

Article URL: https://brooker.co.za/blog/2026/05/18/whats-easy-whats-hard.html

Comments URL: https://news.ycombinator.com/item?id=48195852

Points: 4

# Comments: 0

Goto Considered Harmful: Why Event-Driven Is a Poor Architecture

KraftyOne — Thu, 14 May 2026 18:16:42 +0000

Article URL: https://www.dbos.dev/blog/goto-considered-harmful-2026

Comments URL: https://news.ycombinator.com/item?id=48139103

Points: 2

# Comments: 2

Build Reliable Notifications with Postgres

KraftyOne — Thu, 07 May 2026 18:25:20 +0000

Article URL: https://www.dbos.dev/blog/low-latency-reliable-messaging-with-postgres

Comments URL: https://news.ycombinator.com/item?id=48052932

Points: 2

# Comments: 0

Who even uses jemalloc anyway?

KraftyOne — Wed, 06 May 2026 18:12:45 +0000

Article URL: https://theconsensus.dev/p/2026/04/16/who-even-uses-jemalloc-anyway.html

Comments URL: https://news.ycombinator.com/item?id=48039551

Points: 3

# Comments: 0

New comment by KraftyOne in "Does Postgres Scale?"

KraftyOne — Fri, 01 May 2026 03:08:39 +0000

> Based on the shown graph, this is misleading at best, essentially false. After 120K writes/s p50 spikes from 10ms to 1s (1 second for a write!!!!). That's two orders of magnitude latency spike, and an unacceptable one for an OLTP workload. It clearly shows the server is completely saturated, which is clearly a non operational regime. Quoting 144K is equivalent to quoting the throughput of a highway at the moment traffic comes to a standstill.

> Based on this graph the highest number I'd quote is 120K. And probably you want to keep operating the server within a safe margin below peak, but since this is a benchmark, let's call 120K the peak. Because actually p50 is not even the clear-cut. It should be a higher percentile (say p95) at which latency is within reasonable bounds. But for the shake of not over complicating, it could be taken as a reference.

You definitely don't want to run a production system at saturation! But it's worthwhile to measure a complex system like Postgres at saturation, see when it gets there and how it behaves there, and then run at a slightly lower throughput.

> Therefore, you are not measuring Postgres peak performance, but rather Postgres performance under the IO constraints of this particular system. Certainly, 120K IOPS is the maximum that this particular instance can have. But it doesn't show if Postgres could do better under a more performant IO disk. Actually, a good test would have been to try the next instance (db.m7i.48xlarge) with 240K IOPS and see if performance doubles (within the same envelop of p50 latency) or not. And afterwards to test on an instance with local NVMe (you won't find this in RDS).

I've done some testing (not in the blog post)--doubling instance size/IOPS doesn't improve performance significantly because it doesn't affect the WAL bottleneck. Local NVMe should have a significant impact in theory, but I haven't tested this myself.

> 300 seconds test duration?? This is not operational. You are not accounting for checkpoints, background writer, and especially autovacuum. Given that workflow pattern includes UPDATEs, you must validate bloat generation (or, equivalently, bloat removal) by a) observing much longer periods of time (e.g. 1h) and b) making sure the autovacuum configuration (and/or individual table vacuum configuration if required) makes bloat contained in a stable way. Otherwise, shown performance numbers will degrade over time, making them not realistic.

Those are usage examples (notice the 1000 rps)--actual benchmarks were run at and were stable at much longer duration.

New comment by KraftyOne in "Does Postgres Scale?"

KraftyOne — Thu, 30 Apr 2026 21:48:01 +0000

Yes, this benchmark deliberately uses RDS defaults to make the comparison fairer/more general.

One warning--the setting that would increase throughput the most (synchronous_commit = off) sacrifices durability to do so.

Does Postgres Scale?

KraftyOne — Thu, 30 Apr 2026 18:45:22 +0000

Article URL: https://www.dbos.dev/blog/benchmarking-workflow-execution-scalability-on-postgres

Comments URL: https://news.ycombinator.com/item?id=47966625

Points: 192

# Comments: 95

Measuring AI Ability to Complete Long Software Tasks

KraftyOne — Mon, 27 Apr 2026 16:32:19 +0000

Article URL: http://muratbuffalo.blogspot.com/2026/03/measuring-ai-ability-to-complete-long.html

Comments URL: https://news.ycombinator.com/item?id=47923783

Points: 2

# Comments: 0

Benchmarking How Postgres Scales

KraftyOne — Fri, 24 Apr 2026 18:19:02 +0000

Article URL: https://www.dbos.dev/blog/benchmarking-workflow-execution-scalability-on-postgres

Comments URL: https://news.ycombinator.com/item?id=47893949

Points: 2

# Comments: 0

New comment by KraftyOne in "Async Python Is Secretly Deterministic"

KraftyOne — Fri, 03 Apr 2026 20:08:56 +0000

Yes, this only applies for tasks created from the same (sync or async) function. If tasks are creating other tasks, anything is possible.

New comment by KraftyOne in "Async Python Is Secretly Deterministic"

KraftyOne — Fri, 03 Apr 2026 20:06:45 +0000

It's documented behavior for the low-level API (e.g. asyncio.call_soon https://docs.python.org/3/library/asyncio-eventloop.html#asy...). More broadly, this has been a stable behavior of the Python standard library for almost a decade now. If it does change, that would be a huge behavioral change that would come with plenty of warning and time for adjustment.

New comment by KraftyOne in "Async Python Is Secretly Deterministic"

KraftyOne — Fri, 03 Apr 2026 20:03:20 +0000

It's been a stable (and documented) behavior of the Python standard library for almost a decade now. It's possible it may change--nothing is ever set in stone--but that would be a large change in Python that would come with plenty of warning and time for adjustment.

New comment by KraftyOne in "Async Python Is Secretly Deterministic"

KraftyOne — Fri, 03 Apr 2026 19:22:46 +0000

That's the cool thing about this behavior--it doesn't matter how complex your program is, your async functions start in the same order they're called (though after that, they may interleave and finish in any order).

Async Python Is Secretly Deterministic

KraftyOne — Fri, 03 Apr 2026 18:55:12 +0000

Article URL: https://www.dbos.dev/blog/async-python-is-secretly-deterministic

Comments URL: https://news.ycombinator.com/item?id=47630592

Points: 79

# Comments: 36

Bridging Languages with Postgres and Workflows

KraftyOne — Fri, 20 Mar 2026 19:35:50 +0000

Article URL: https://www.dbos.dev/blog/making-languages-interoperable-with-postgres

Comments URL: https://news.ycombinator.com/item?id=47459520

Points: 2

# Comments: 0

Making Workflows Work Right in Golang

KraftyOne — Fri, 30 Jan 2026 21:28:14 +0000

Article URL: https://www.dbos.dev/blog/how-we-built-golang-native-durable-execution

Hacker News: KraftyOne

New comment by KraftyOne in "Building durable workflows on Postgres"

Building durable workflows on Postgres

Postgres Is All You Need for Durable Execution

What's Easy Now? What's Hard Now?

Goto Considered Harmful: Why Event-Driven Is a Poor Architecture

Build Reliable Notifications with Postgres

Who even uses jemalloc anyway?

New comment by KraftyOne in "Does Postgres Scale?"

New comment by KraftyOne in "Does Postgres Scale?"

Does Postgres Scale?

Measuring AI Ability to Complete Long Software Tasks

Benchmarking How Postgres Scales

New comment by KraftyOne in "Async Python Is Secretly Deterministic"

New comment by KraftyOne in "Async Python Is Secretly Deterministic"

New comment by KraftyOne in "Async Python Is Secretly Deterministic"

New comment by KraftyOne in "Async Python Is Secretly Deterministic"

Async Python Is Secretly Deterministic

Bridging Languages with Postgres and Workflows

Making Workflows Work Right in Golang

Building Decentralized Workflows That Scale