It would, hence why major cloud providers currently disable io_uring in many of their compute environments.

Author here.

I finally got it working. I had to flush both the encrypted writer and then the stream writer. There was also some issues with reading. Streaming works, but it'll always return 0 on the first read because Writer.Fixed doesn't implement sendFile, and thus after the first call, it internally switches from streaming mode to reading mode (1) and then things magically work.

Currently trying to get compression re-enabled in my websocket library.

(1) https://github.com/ziglang/zig/blob/47a2f2ddae9cc47ff6df7a71...

Thank you, this is amazing feedback/info. Yeah, we think the Tailscale integration is pretty neat too!

This is, unfortunately, a problem that many tech companies have made worse and more accessible as they have removed friction from these systems.

Most folks will remember the 2019 temination of lootbox key trading for CS:GO on Steam.

https://www.bbc.com/news/technology-50262447

https://www.gamesindustry.biz/research-identifies-suspicious...

https://www.sciencedirect.com/science/article/pii/S266628172...

I'm not sure what good ways there are to manage this generally, other than limiting the size or types of financial transactions that can occur within a system.

In Europe, we have: Phone repair shop. Pizzeria. Gambling cafe.

I think rusts glacial compile times prevent it from being a useful platform for web apps. Yes it's a nice language, and very performant, but it's horrible devex to have to wait seconds for your server to recompile after a change.

> Only thing? Just off the top of my head: That the LLM doesn't learn incrementally from previous encounters. That we appear to have run out of training data.

Ha, that almost seems like an oxymoron. The previous encounters can be the new training data!

Only thing? Just off the top of my head: That the LLM doesn't learn incrementally from previous encounters. That we appear to have run out of training data. That we seem to have hit a scaling wall (reflected in the performance of GPT5).

I predict we'll get a few research breakthroughs in the next few years that will make articles like this seem ridiculous.

I really like Rust but there are some quite frustrating core paper cuts that I wish would get more attention:

1. Self-referencing structs. Especially where you want to have something like a source file and the parsed AST in the same struct. You can't easily do that at the moment. It would be nice if there was something like an offset reference that made it work. Or something else...

2. The orphan rule. I get it, but it's still annoying. We can do better than newtype wrappers (which sometimes have to be nested 2 or 3 levels deep!).

3. The fact that for reasonable compile time you need to split projects into lots of small crates. Again, I understand the reasons, but the result sucks and we can definitely do better. As I understand it this is because crates are compiled as one compilation unit, and they have to be because circular dependencies are allowed. While that is true, I expect most code doesn't actually have circular dependencies so why not make those opt-in? Or even automatically split items/files within a crate into separate compilation units based on the dependency graph?

There's probably more; this is just what I can remember off the top of my head.

Hopefully that's constructive criticism. Rust is still my favourite programming language by far.