zig-okredis VS zls

> I don't really understand your crusade.

Accuracy is important in the marketplace of ideas, and especially in programming. Software is too buggy already, and it would only add more bugs to have programmers not understand the languages they use.

> I made this same observation in the past, it never satisfied you.

Yes, you made that same observation, and I appreciate that. But as @kbd so unintentionally demonstrated, people still believe that Zig is colorless. I want to dispel that notion completely.

I think you are not adding to the problem, and that is great. But the notion is still there.

> Your blog post is full of wrong information. I tried to explain to you what was wrong when you first posted it (so you can refer to those comments, if you want), but you keep seeing this as some kind of philosophical debate, and I have no interest in having this debate.

Here is all of the comments you made on Hacker News on the comments [1] about my blog post.

> That's exactly it. It just enables code reuse. You still have to think about how your application will behave, but you won't have to use an async-flavored reimplementaion of another library. Case in point: zig-okredis works in both sync and async applicatons, and I don't have to maintain two codebases.

> https://github.com/kristoff-it/zig-okredis

> I thought using "colorblind" in the title of my original blogpost would be a clear enough hint to the reader that the colors still exist, but I guess you can never be too explicit.

and

> That's how it works in Zig. Calling an async function like this will also await it.

The closest thing to "explain[ing] to [me] what was wrong when [I] first posted it" is probably that first comment, which was in reply to

> I may be totally wrong with this assumption, but the way I understoo[d] Zig's color-less async support is that the compiler either creates a "red" or "blue" function body from the same source code based on how the function is called (so on the language level, function coloring doesn't matter, but it does in compiler output).

> The compiler still needs to stamp out colored function bodies because the generated code for a function with async support needs to look different - the compiler needs to turn the code into a state machine instead of a simple sequence).

> It's a bit unfortunate that red and blue functions appear to have a different "ABI signature", but I guess that's needed to pass an additional context pointer into a function with async support (which would otherwise be the implicit stack pointer).

(Original comment at [2] by flohofwoe.)

So if anybody explained anything, it's flohofwoe.

But flohofwoe's comment goes directly against the the language reference, so it's hard for me to believe.

The language reference says that sync functions are turned async if they call async functions. This implies virality of async on functions, which implies that many functions are definitely async-only.

If the compiler does something different, which it would have to if it actually makes two different versions of each function, then the language reference is wrong. Like I said, accuracy matters, so I would also like to see changes in the Zig language reference about this if that's the case.

> As I said to you already in the past, I just write software with Zig async and it works.

Yes, you write working software in Zig async, but you understand it better than most. People who go to the language reference and write based on that may not be able to write working software with Zig async as easily as you.

[1]: https://news.ycombinator.com/item?id=30965805

[2]: https://news.ycombinator.com/item?id=30967070

There is no official documentation but the standard library provides definitions for the exchange format and an incomplete set of function for exchanging messages in Client.zig and Server.zig. You can find examples of the zig compile server in action in my PR for ZLS and a showcase of hot-code-swapping by kubkon. The code that implements the ZCS in the zig codebase can be found here.

Same experience here, I did file a bug about it too: https://github.com/zigtools/zls/issues/1139

Welcome to the word of new languages, I think rust just got an intellij plugin late last year and its been in 1.0 since 2015 (not to mention the years of hype around it). When it comes to "non standard" languages (meaning not the industries current go to for a given niche), it helps to assume there's no "It's just works" type editor support. Luckily most languages, even new ones have LSP servers including zig, and editors like VSCode make it pretty simple to use them.

For the people who come in the future and want to know how to do it, here is the code as of today (at some point it will be in ZLS repository - github.com/zigtools/zls - and you should take a look there too to see more up-to-date code).

Commands: git clone --recurse-submodules https://github.com/zigtools/zls cd zls zig build -Drelease-safe

> Building is slow. It takes about ~3 seconds minimum which is frustratingly slow when I'm fighting basic syntax errors. I wish there was a fast zig check.

> Lack of zig-analyzer makes learning hard.

> zig fmt src/main.zig is nice. Wish it automatically ran on all files.

I also did (well, "am doing", can only work a bit each day and am plugging through day 7 right now) AdventOfCode in Zig this year.

These points here didn't resonate with me at all. I wonder if the author knew about or tried ZLS[0]. I had it on and integrated with my VSCode and it would check a lot of things as I went and format on save. I think I followed something like this[1] to set it up.

[0] https://github.com/zigtools/zls

cd $HOME/.local/zls && curl -L https://github.com/zigtools/zls/releases/download/0.9.0/x86_64-macos.tar.xz | tar -xJ --strip-components=1 -C .