zig

Another default that Zig got right: every non-void result must be handled. https://github.com/ziglang/zig/issues/219

They are efficient FIFOs (queues). You‘ll find them in many places. I know them from multimedia / audio, where you often have unsynchronized readers and writers. In the audio domain, the reader and weiter are usually allowed to trample over each other. If you‘ve ever gamed on a PC, you might have heard this. When a game freezes, sometimes you hear a short loop of audio playing until the game unfreezes. That‘s a ringbuffer whose writer has stopped, but the async reader is still reading the entire buffer. Zig‘s “There are too many ring buffer implementations in the standard library“ might also be interesting: https://github.com/ziglang/zig/issues/19231

Zig makes it explicit with _ = a; And you would encounter it quite often because unused variable is a compilation error: https://github.com/ziglang/zig/issues/335

Recursion: That's easy, don't. At least, not with a call stack. Instead, use a stack container backed by a bounded allocator, and pop->process->push in a loop. What would have been a stack overflow is now an error.OutOfMemory enum that you can catch and handle as desired. All that said, there is a proposal that addresses making recursive functions more friendly to static analysis [0]. Function pointers: Zig has a proposal for restricted function types [1], which can be used to enforce compile-time constraints on the functions that can be assigned to a function pointer. [0]: https://github.com/ziglang/zig/issues/1006 [1]: https://github.com/ziglang/zig/issues/23367

> First things first, Zig does compile async fns to a state machine: https://github.com/ziglang/zig/issues/23446 Maybe I'm missing something, but that's still a proposal, which also assumes an implementation for the other proposal you linked and that also doesn't exist yet. For now I would refrain from commenting on non-existing functionality. > I still think sans-io at the language level might be the future, but this isn't a complete solution. I'm not sure what about this is really at the language level (only stackless coroutines appear to require language level support, and it's still unclear if it's really possible to implement them). However I do agree that a sans-io, or at least dependency injection for I/O is a great improvement on the library side, and it's something I'd like to see in Rust too.

I suspect the end goal is to have suspend/resume (or some analogue) be userspace standard library functions used to implement Io.Evented. It'll end up being a userspace implementation like you see with many of the C coroutine libraries floating around on GitHub (minicoro, llco, etc). Edit: Looking at the working prototype of Io.Evented, this may not be true actually. Perhaps this is the domain of a 3rd-party library except with stackless coroutines? Another thing you may want to pay attention to, however, are the current proposals for getting evented IO working on WASM -- namely, stackless coroutines as a language feature: https://github.com/ziglang/zig/issues/23446

I think the new async IO is great in simple examples like the one shown in the article. But I’m much less sure how well it will work for more complex I/O like you need in servers. I filed an issue about it here: https://github.com/ziglang/zig/issues/26056

It's sans-io at the language level, I like the concept. So I did a bit of research into how this works in Zig under the hood, in terms of compilation. First things first, Zig does compile async fns to a state machine: https://github.com/ziglang/zig/issues/23446 The compiler decides at compile time which color to compile the function as (potentially both). That's a neat idea, but... https://github.com/ziglang/zig/issues/23367 > It would be checked illegal behavior to make an indirect call through a pointer to a restricted function type when the value of that pointer is not in the set of possible callees that were analyzed during compilation. That's... a pretty nasty trade-off. Object safety in Rust is really annoying for async, and this smells a lot like it. The main difference is that it's vaguely late-bound in a magical way; you might ge

> The article makes it seem like "the plan is set" so I do wonder what that Todo looks like. Is this simply the plan for async IO? There's currently a proposal for stackless coroutines as a language primitive: https://github.com/ziglang/zig/issues/23446

That would only interact with the shell, as `%` is not actually part of the environment variable name, it's just a way to tell the shell you want it to get the value of an environment variable. The environment block itself is a NULL terminated list of NULL terminated WTF-16 strings of the format <key>=<value>, so `=` would be the more interesting thing to try. And indeed, it looks like using `=` as a drive letter breaks things in an interesting way: =:\> cd bar Not enough memory resources are available to process this command. =:\bar> `cd` exits with error code 1, but the directory change still goes through. With a program that dumps the NULL terminated <key>=<value> lines of the environment block, it looks like it does still modify the environment, but in an unexpected way: Before `cd /D =:\`, I had a line that looked like

My favorite of his https://x.com/joelreymont/status/1990981118783352952 > Claude discovered a bug in the Zig compiler and is in the process of fixing it! ...a few minutes later... https://github.com/ziglang/zig/pull/25974 I can see a future job interview scenario: - "What would you say is your biggest professional accomplishment, Joel?" - "Well, I almost single-highhandedly drove Zig away from Github"

I thought people knew andrewk was an ahole? I thought that was his supposed charm? Like Linus. I mean https://github.com/ziglang/zig/pull/24317 wasn't that long ago.

> As a bonus, we look forward to fewer violations (exhibit A, B, C) of our strict no LLM / no AI policy, Hilarious how the offender on "exhibit A" [1] is the same one from the other post that made the frontpage a couple of days ago [2]. [1] https://github.com/ziglang/zig/issues/25974 [2] https://news.ycombinator.com/item?id=46039274

I am not sure if a slow pace is as beneficial as you say. I scrolled through the error handling issue brought up in this comment section ( https://github.com/ziglang/zig/issues/2647#issuecomment-2670... ) and its clear that only thing that happened there was communication on the issue was hindered. I come from C++ side and our "ISO C++ committee" language development process leaves a lot to be desired. Now look at error handling that they did passed in C++23 ( std::expected ). It raises some questions on how slow you can be while still appearing to be moving forward. Disclaimer: I would like to see Zig and other new languages to become a viable alternatives to C++ in Gamedev. But I understand that it might happen way after me retiring =)