News for hackers. Stuff that matters.
Re:Why I rewrote my Rust keyboard firmware in Zig: consisten... by kristoff_it on Sunday March 07, 2021 @06:06AM (#26374924)
Some context on the issues you pointed (all true, to be clear):

> * no (official) package manager yet, though this is aparently being worked on

It's the next item on the roadmap as soon as the self-hosted compiler is good enough.

> * documentation is often incomplete and lacking

The language reference is good, but for the stdlib it's best to just read the source code. For other miscellaneous learning materials:

https://ziglearn.org/

https://github.com/ratfactor/ziglings

https://www.youtube.com/c/ZigSHOWTIME

> * error handling with inferred error sets and `try` is very nice! But for now errors can't hold any data, they are just identifiers, which is often insufficient for good error reporting or handling.

It's still under debate and I'm personally in the camp that errors should not have a payload, so I would avoid assuming that it's definitely the preferable choice. We already have a couple of existing patterns for when diagnostics are needed. That said proposals about adding support for error payloads are still open, so who knows.

https://github.com/ziglang/zig/issues/2647

https://github.com/ziglang/zig/issues/7812

Existing pattern: https://github.com/ziglang/zig/issues/2647#issuecomment-5898...

> * No closures! (big gotcha)

It's possible to create closures already (by declaring a struct type with a method (the closure) and instantiating it immediately after), but it's a clunky solution. We also have an open proposal in this space:

https://github.com/ziglang/zig/issues/6965

Re:Why I rewrote my Rust keyboard firmware in Zig: consisten... by the_duke on Sunday March 07, 2021 @12:32PM (#26377784)
The new compiler is very innovative and a distinguishing feature, but I would recommend giving a higher priority to package management.

A package manager is more or less expected by developers now, and I bet you will see a lot more adoption once it's easy to publish and consume libraries with an official packager manager and online repository.

Re:Why I rewrote my Rust keyboard firmware in Zig: consisten... by gwenzek on Sunday March 07, 2021 @05:12PM (#26380278)
IIUC the line of thoughts is that the current compiler is too slow, and that it doesn't show on a small project. But if you imagine a big project with 100 dependencies, you'll be really slowed done. The new compiler is faster (I think there are benchmarks in the repo) and can compile debug builds without going through LLVM.
Re:Why I rewrote my Rust keyboard firmware in Zig: consisten... by coder543 on Sunday March 07, 2021 @10:08AM (#26376368)
> It's still under debate and I'm personally in the camp that errors should not have a payload, so I would avoid assuming that it's definitely the preferable choice.

How can you argue that not having access to string index where the JSON was unparseable is better than having access to it? I read through issues/2647, and I read through the "existing pattern", and it just seems obvious to me that containing the error information in the error is better than trying to hack it through side channels.

If A -> B, and B returns an error through a side channel, then A can use it and "what's so bad about that?"

But this doesn't seem to scale very well.

If A is refactored to use an intermediate function X, then it just doesn't work. A -> X -> C would mean that...

X cannot use Zig's normal error handling syntax to automatically propagate this error that A is better equipped to handle, unless we're going to further stipulate that A must pass this Diagnostics struct into X which then must pass it into B.

If we now assume that X calls into two fallible functions, B and C, and each of them provide their own diagnostics structs, then X will have to take in two "out" arguments that provide the diagnostics, and every single caller of X will have to provide those two values.

You see how this goes. It just doesn't seem scalable.

Why not take the current design to its logical conclusion of simply having every function return a Boolean indicating whether it succeeded or not, and then require the caller to look into some "out" argument to determine what the error was? Obviously, that would be extremely annoying.

A tagged error union containing the diagnostic error values is just a minor evolution of the current design that brings huge wins for language ergonomics.

For errors that don't need to carry a value, there is no additional cost: they compile and work exactly as they do today.

For errors that carry a value, the size of the error struct is only the size of the largest error value (plus the tag, of course), not the product of all possible error values, so the global error set will never grow to be enormous unless you have some very weird error type. In which case, you can solve this problem by fixing that error type.

So, I'm not deeply versed in Zig, but I have personally argued in favor of Zig's async design, which seems exceptionally interesting. I had not realized until now how limiting the error system implementation was, but I had superficially appreciated how much less verbose it was than Rust's where you tend to hand write these error enums, or use a bunch of code gen. However, errors benefit tremendously from having the ability to supply payloads.

No one is required to act on the payloads within the errors, but no one is able to if they don't exist.

Re:Why I rewrote my Rust keyboard firmware in Zig: consisten... by kristoff_it on Sunday March 07, 2021 @11:27AM (#26377164)
The problem is for all the situations where the error payload isn't needed. You now need to carry around the extra syntactic complexity and/or the extra wasted memory (unless you have a strategy to elide all of this stuff when error payloads are not needed).

I think it's not trivial to find a good alternative to status quo.

Re:Why I rewrote my Rust keyboard firmware in Zig: consisten... by the_duke on Sunday March 07, 2021 @12:25PM (#26377702)
There are so many situations where an error payload is either mandatory for properly handling the error, or required to get somewhat decent error output...

Side channels are not really a feasible implementation option.

So you have to resort to maintaining the logical information on intermediate levels, returning a result sum type, or stick to good old C paradigms and use a output param. Which negates all value that error sets offer.

I understand that it's not trivial to implement, but for me it's a sort of must to avoid ending up with messy APIs.

Re:Why I rewrote my Rust keyboard firmware in Zig: consisten... by dilap on Sunday March 07, 2021 @05:02PM (#26380205)
People are lazy, though. I think if errors can't take payloads, it's inevitable you'll end up with many libraries that don't return error payload information when you wish they did. This will trickle out into software using the libraries, where the end-user will get errors that don't include as much useful info as you'd like. So to my mind, not supporting error payloads in a first class way is contrary to Zig's goal of enabling perfect software. :-)
Re:Why I rewrote my Rust keyboard firmware in Zig: consisten... by coder543 on Sunday March 07, 2021 @11:40AM (#26377295)
“wasted memory”... this stuff exists on the stack, right? And we’re talking on the order of like 64 bytes or less in common, practical scenarios?

I believe the solution has been clearly presented to those who are listening, and the downsides are so much smaller than the status quo.

If people on the language team are unwilling to provide developers with the tools to make more robust software because of something like 64 bytes of stack memory... I find that pretty shocking. And yes, I mean that it is extremely difficult to diagnose and fix issues in production software when you only get back a static error value that lacks the dynamic error context that a payload would provide. I’ve been there, done that. Do not want that again.

Such a strong viewpoint (avoiding such error payloads) could at least focus more on the technical aspects of how best to implement the elision of unused error payloads instead of just broadly opposing the concept, since it should be obvious how beneficial those payloads are, and the only question is how to remove them for developers who literally cannot spare dozens of bytes of stack memory. (Which I find hard to believe outside of AVR or PIC microcontrollers, which is probably not the best use case to be optimizing for in a new language.)

Elision is an optimization that can be added later. It’s not obvious that it can’t be done, and there’s no clear reason that it has to be solved first... I just don’t think anyone would actually care enough to implement it once they see how nonexistent the negative impacts are, but it would be a cool optimization.

But, maybe everyone who upvoted the apparently most upvoted GitHub issue on the Zig repo (including myself) is just completely wrong and this obvious solution is actually secretly terrible. It’s entirely possible.

Your comment has not really done anything to help me believe that I’m wrong, though, unfortunately.

But, as I’m basically “no one” in this context, my opinion probably doesn’t really matter.

Re:Why I rewrote my Rust keyboard firmware in Zig: consisten... by dnautics on Sunday March 07, 2021 @01:53PM (#26378561)
It's not that the "obvious solution" is so terrible, it's that the workaround (not needed in 99% of cases) is really easy and arguably good architectural practice. You can emit an error/ok union and have the error return the structured information.

Note that this isn't like go's "if err = nil" monstrosity, either.

Re:Why I rewrote my Rust keyboard firmware in Zig: consisten... by coder543 on Sunday March 07, 2021 @01:58PM (#26378606)
> You can emit an error/ok union and have the error return the structured information.

I already addressed how you’re apparently giving up all of the benefits of Zig’s error handling system to do this. That level of convention breaking isn’t a good sign for anything. The current convention really is that bad, from my point of view.

The obvious solution’s extremely tiny overhead could “easily” be avoided in the almost non-existent cases where it matters.

I want robust software by default, not software where I have to use side channel hacks to get the information I need by default... but maybe that’s just me. (And everyone else who upvoted that GitHub issue)

Of course Zig programmers would be unlikely to see the issue here — naturally the people left are the ones who don’t see the problem. People like myself who know from past experience how problematic not having error context is are likely to just avoid Zig until it meets our minimum requirements.

That’s not a problem for existing Zig users — it works for them — but it is annoying to people like me who think Zig otherwise has a number of interesting aspects.

Re:Why I rewrote my Rust keyboard firmware in Zig: consisten... by dnautics on Sunday March 07, 2021 @02:55PM (#26379162)
You're missing the point. Let me give a direct analogy: In erlang there is a fantastic error system, but sometimes you want to emit an ok/error tuple instead. There is a generally sane heuristic of when you do and don't want to use the error pathways, it's a part of making good engineering choices. Generally speaking it's the case where when you want structured errors you use the tuple.

It's possible that erlang developers are merely internalizing sone pain, but it's also a robust system that people have been developing highly reliable and broadly used (e.g. rabbitMQ) systems architectures in, so the choice can't be all that bad.

Re:Why I rewrote my Rust keyboard firmware in Zig: consisten... by ericbarrett on Sunday March 07, 2021 @01:15PM (#26378154)
Languages should be careful eliding error payloads—it's a good way to end up with every library rolling their equivalent to C's errno.
Re:Why I rewrote my Rust keyboard firmware in Zig: consisten... by coder543 on Sunday March 07, 2021 @01:59PM (#26378624)
Eliding would be done by the compiler where the values aren’t used. That’s whole meaning of the word “elide” in a language context.

From the developer’s point of view, the values would always be there, just unused. The compiler would just make them disappear at compile time if unused.

Re:Why I rewrote my Rust keyboard firmware in Zig: consisten... by ericbarrett on Sunday March 07, 2021 @02:08PM (#26378733)
> You now need to carry around the extra syntactic complexity and/or the extra wasted memory

This quote is from your GP post, and I read this as arguing against having the mechanism for getting this payload in the language (and hence the compiler itself), so my language was intended. Am I misunderstanding?

Re:Why I rewrote my Rust keyboard firmware in Zig: consisten... by coder543 on Sunday March 07, 2021 @02:11PM (#26378753)
Ah. I think I see what you were saying now. The word “elide” has different connotations to me than the word “omit”. Zig’s omission of error context is something I agree is problematic.

(This could just be a quirk of my own vocabulary)

Re:Why I rewrote my Rust keyboard firmware in Zig: consisten... by dnautics on Sunday March 07, 2021 @01:48PM (#26378513)
For those specialized cases, just have your function emit an error/ok type union and early exit with the error information.
Re:Why I rewrote my Rust keyboard firmware in Zig: consisten... by coder543 on Sunday March 07, 2021 @01:56PM (#26378584)
If the standard library doesn’t do follow that convention, then it doesn’t matter what I do in my code. I won’t get the information I need from the standard library, and third party libraries are unlikely to follow this ad hoc convention. I’m certainly not willing to rewrite the entire world to follow this ad hoc convention.
Re:Why I rewrote my Rust keyboard firmware in Zig: consisten... by dnautics on Sunday March 07, 2021 @03:04PM (#26379255)
You make a good point that the standard library could make better use of this pattern to show it off, but the language was designed with this sort of thing as an affordance and there even is a (rough) example in the docs: https://ziglang.org/documentation/master/#Tagged-union

You wouldn't have to rewrite the world, but the language is young and maybe more effort could go into making using this pattern more idiomatic and encourage library writers to do it more often.