Comment by verdagon | Hacker News Reader

Comment by verdagon | Hacker News Reader

Something I really appreciate about Zig is its "colorblind async/await" [0].

To my eyes, it's the best of both worlds. It doesn't require a GC like Go's "contiguous stacks" approach [1] or Loom's approach [2]. It also doesn't require coloring like Javascript/Rust's async/await approach, which can sometimes seem like a viral leaky abstraction, causing incidental complexity in the presence of certain patterns.

The main catch is around recursion, but that's not so bad, as Zig as a whole seems to steer users away from recursion anyway, with another interesting feature that detects it at compile time.

I think new languages should be going this direction: focus on making things easier for the user, avoid causing incidental complexity, and keep abstractions zero-cost.

Just my two cents!

[0] https://kristoff.it/blog/zig-colorblind-async-await/

[1] https://medium.com/a-journey-with-go/go-how-does-the-gorouti...

[2] https://youtu.be/NV46KFV1m-4

It arguably isn’t fully colorblind: https://gavinhoward.com/2022/04/i-believe-zig-has-function-c...

The mistake that article makes (imo) is that "colorblindness" means at compile-time. i.e. you don't have to define both a sync and an async version of a function. Obviously async vs sync have different representations at run time.

Definitions aside I’d say that it seems to be a leaky abstraction.

As someone who has used this (to enable a single function to be called either preemptively or cooperatively by a surrounding VM)... It's not leaky. To be frank, until you've actually done it, it's hard to see.

Section 4 of the article I linked demonstrates how it’s leaky. Admittedly just in special scenarios, but it means that the mechanism isn’t fully transparent.

Actually, I think "colorblind" is good term for this: zig indisputably has function color (as the article demonstrates), but you can't see it.

Here's a working version of the program gavinhoward was trying to write: https://gist.github.com/sharpobject/49bd88416e68606d7812d609...

Something I appreciate about the implementation is that the suspend/resume primitives make it nigh-trivial to write co-routines, which saved me several nanoseconds per frame in my toy Gigatron emulator's VGA decoding implementation and took a fraction of the time to write and debug compared to the traditional struct-based state machine I wrote first.

Not familiar with Zig but doesn’t colourblindness lose you control over the binding points of the computation? This can be key for optimisation.

Reply on news.ycombinator.com