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

Points: 2

# Comments: 0

It's been like a day since the merge, presumably such followups are coming.

But I suppose if you are already using LLMs it's more reasonable to try and go from Zig straight to Rust with no/minimal unsafe.

Trying to eliminate all unsafe as part of the rewrite, whether done by human or LLM, would be making too big of a change in the process of rewriting.

Broadly I think there are three approaches:

1. For frequent and small CPU heavy tasks, just run them on the IO threads. As long as you don't leave too long between `.await` points (~10ms) it seems to work okay.

2. Run your sans-io code on a dedicated CPU thread and do IO from an async runtime. This introduces overhead that needs to be weighed against the amount of CPU work.

3. Have the sans-io code output something like `Output::DoHeavyCompute { .. }` and later feed the result back as `Input::HeavyComputeResult { .. }`, in the middle run the work on a thread pool.

I also want to address something that I've seen in several sub-threads here: Rust's specific async implementation. The key limitation, compared to the likes of Go and JS, is that Rust attempts to implement async as a zero-cost abstraction, which is a much harder problem than what Go and JS does. Saying some variant of "Rust should just do the same thing as Go", is missing the point.

For now the best option to write code that wants to live in both worlds is sans-io. Thomas Eizinger at Fireguard has written a good article about this[1] pattern. Not only does it nicely solve the sync/async issue, but it also makes testing easier and opens the door to techniques like DST[2]

I have my own writing on the topic[3], which highlights that the problem is wider than just async vs sync due to different executors.

0: https://github.com/rust-lang/effects-initiative

1: https://www.firezone.dev/blog/sans-io

2: https://notes.eatonphil.com/2024-08-20-deterministic-simulat...

3: https://hugotunius.se/2024/03/08/on-async-rust.html

The one downside of custom extensions is that you aren’t, AFAIK, able to use them with many hosted Postgres installs, notably AWS RDS.

0: https://www.statista.com/statistics/283221/per-capita-health...

1. The tariffs are too broad, they don't target a single or a few industries.

2. Trump has gone back and forth many times on them, using them as negotiating leverage, not as long term incentives.

3. They are on very shaky legal grounds and will likely end up getting reversed by either the Supreme Court or the next president.

If you want to use tariffs to encourage on-shoring you make them targeted and pass them with bipartisan support through congress. Companies need stability and long term guarantees for the kind of capital expenditure that is needed. Even better if you use a mix of carrot and stick, rather than all stick

Tbf this applies to Rust too. If the author writes

   fn foo(bar: Box)

Had they written

   fn foo(bar: impl BarTrait)