Probably true, but it's a shame because there are better ways of storing and processing the data, ways that natively handle binary files, semantics, and large files without falling over.

[1]: https://gavinhoward.com/2025/04/how-i-solved-the-expression-...

[1]: https://gavinhoward.com/uploads/designs/yore.md

https://en.wikipedia.org/wiki/High-Tech_Employee_Antitrust_L...

But most importantly, I want to finally become as kind, patient, and charitable as I have always wanted to be.

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

Points: 2

# Comments: 0

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

Points: 4

# Comments: 0

And if you don't have time, just go to the bullet point list at the end; that's all of the best practices, and they are fantastic.

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

Points: 3

# Comments: 0

To those for whom it is, please don't feel obligated to continue. I haven't, and I made this public so that others will be able to discard their feelings of obligation.

Let's get paid to hold up the sky.

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

Points: 3

# Comments: 1

I like this paper. While it's not anything groundbreaking or sensational, it did help me with the design of something I am working on.

But then, for those that choose to only use blocking I/O or green threads, they still pay the penalty of async merely existing.

> That’s a really bad take. It’s not much different from what they did to make allocators explicit.

I mean, Zig explicit allocators are really the same thing is Go interfaces, just dressed up as an innovative feature by a specific use case. This is what I mean by "appearing" innovative: they are taking old and tested ideas and presenting them in new ways to make them appear new.

Also, Zig could have had explicit allocators without needing to pass them to every function [1].

> They’ve moved away from designing in a bunch of fancy syntax that locks users into one particular concurrency model, and gone for a more explicit and boring design which puts power in the hands of the user.

Except that if every function is made async, they have actually removed from users the power to choose to not use async.

[1]: https://jai.community/t/context/163

I see that blocking I/O is an option:

> The most basic implementation of `Io` is one that maps to blocking I/O operations.

So far, so good, but blocking I/O is not async.

There is a thread pool that uses blocking I/O. Still good so far, but blocking I/O is still not async.

Then there's green threads:

> This implementation uses `io_uring` on Linux and similar APIs on other OSs for performing I/O combined with a thread pool. The key difference is that in this implementation OS threads will juggle multiple async tasks in the form of green threads.

Okay, they went the Go route on this one. Still (sort of) not async, but there is an important limitation:

> This implementation requires having the ability to perform stack swapping on the target platform, meaning that it will not support WASM, for example.

But still no function colors, right?

Unfortunately not:

> This implementation [stackless coroutines] won’t be available immediately like the previous ones because it depends on reintroducing a special function calling convention and rewriting function bodies into state machines that don’t require an explicit stack to run.

(Emphasis added.)

And the function colors appear again.

Now, to be fair, since there are multiple implementation options, you can avoid function colors, especially since `Io` is a value. But those options are either:

* Use blocking I/O.

* Use threads with blocking I/O.

* Use green threads, which Rust removed [2] for good reasons [3]. It only works in Go because of the garbage collector.

In short, the real options are:

* Block (not async).

* Use green threads (with their problems).

* Function colors.

It doesn't appear that the function colors problem has been defeated. Also, it appears to me that the Zig team decided to have every concurrency technique in the hope that it would appear innovative.

[1]: https://gavinhoward.com/2022/04/i-believe-zig-has-function-c...

[2]: https://github.com/aturon/rfcs/blob/remove-runtime/active/00...

[3]: https://www.open-std.org/JTC1/SC22/WG21/docs/papers/2018/p13...

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

Points: 1

# Comments: 0