News for hackers. Stuff that matters.
Re:Zig's Incremental Compilation Internals by pron on Tuesday July 28, 2026 @02:33PM (#49088033)
> it promotes an "us vs them" mindset, instead of a "we're all trying to improve memory safety" mindset

But you did the same thing when, on the spectrum that ranges from C to ATS, with Zig, Rust, and Java somewhere in the middle (though all closer to C than to ATS), you declared the exact compromise that Rust makes "table stakes"! [1]

Zig improves on C's memory safety when it comes to spatial safety, possibly the more impactful kind, so it, too, could be part of the "we're all trying to improve memory safety", yet you exclude it.

You're trying to draw some hard line that passes exactly between Rust and Zig on the C to ATS spectrum, and I'm trying to say that that line isn't there (your attempt at a definition of delineating safe and unsafe code also applies to C). Obviously, C, Zig, Rust, Java, and ATS all make very different tradeoffs, all of which may be more or less attractive to different people and in different circumstances, but there is no sharp line, at least not one that is meaningful enough to be "table stakes". Your personal inclinations place a premium on the things Rust offers and Zig doesn't while mine are the opposite, but I make no claim to universality.

I'm happy to accept that not everyone shares my aesthetics and can understand why some people prefer Rust, but those claims to or hints at universality annoy me (as they did when they were made by Haskellers, and I actually find Haskell's aesthetics quite pleasing), as they are simply unsupported. I've spent a lot of time studying formal methods and software correctness in general (https://pron.github.io) and if there's one thing we know in that field is that things are never that simple (and, bringing this back to this posts topic, even something like incremental compilation can contribute to program correctness).

(Now, you may argue that you're only talking about "memory safety" and not correctness in general, but what gives memory safety value is that violations are causes of many dangerous vulnerabilities; but once, say, Java eliminates all of them, 100% of bugs/vulnerability - which are still numerous - will be caused by other problems, all potentially avoidable with ATS, so why isn't ATS table stakes? Of course, the answer is cost, but all the languages on the spectrum differ in their costs.)

[1]: I assume that you meant Rust's compromise, because you implied that Zig doesn't pass that bar but Rust does.

Re:Zig's Incremental Compilation Internals by steveklabnik on Tuesday July 28, 2026 @02:46PM (#49088193)
> But you did the same thing when,

I do not go around posting "omg Rust is SO MUCH BETTER than zig or fil-c, which are TRASH." I talk about engineering tradeoffs, and what matters to me personally. I do not say "if you use Zig, you are a bad person." I am not saying that any comparison is bad. I am saying that the way that the comparison is presented is bad. That is different.

> you declared the exact compromise that Rust makes "table stakes"

Table stakes for me.

> Zig improves on C's memory safety when it comes to spatial safety,

I agree that it's an improvement on C!

> yet you excluded it.

I said that it is not pursuing a design that I personally find compelling enough to use to write software. That doesn't mean that I think it's worthless. This whole thing started off with me talking about how much I respect the Zig project! Yet you're trying to turn this into something where I'm talking shit. I presented a specific technical tradeoff that is important to me. That is very different.

> You're trying to draw some hard line on a spectrum that passes exactly between Rust and Zig, and I'm trying to say that that line isn't there (your attempt at a definition of delineating safe and unsafe code also applies to C)

I don't believe you've shown that. And my "attempt" does apply to C: it fails the bar, because it does not delineate between a safe subset and an unsafe superset.

> you may argue that you're only talking about "memory safety" and not correctness in general,

I am in fact talking about "memory safety" and have been this whole time, yes.

> what gives memory safety value is that violations are causes of many dangerous vulnerabilities; but once, say, Java eliminates all of them, 100% of bugs/vulnerability - which are still numerous - will be caused by other problems, all potentially avoidable with ATS, so why isn't ATS table stakes?

This is just an entirely different question. Yes, there are other forms of safety that are important too. That's just not what we're talking about here.

Re:Zig's Incremental Compilation Internals by pron on Tuesday July 28, 2026 @03:04PM (#49088422)
> Table stakes for me.

Ok, so if you meant "table stakes" as an expression of a personal preference and suitability to the programs you write without making an unsupported universal claim such as "this leads to better correctness" or "the price is almost always worth it" then we're good :)

> Yes, there are other forms of safety that are important too.

The thing is that they can be at least equally important, and some affordances for memory safety could potentially _harm_ them. To me, Rust offers little safety in the programs I want to write in a low-level language, but the price it charges in language complexity and implicitness ends up in a negative balance (I can't prove it, of course; as I said, software correctness is very complicated, and some of the greatest researchers in the field were proven wrong on how to best achieve it).

Re:Zig's Incremental Compilation Internals by eaurouge on Wednesday July 29, 2026 @03:39AM (#49094486)
> I do not go around posting "omg Rust is SO MUCH BETTER than zig or fil-c, which are TRASH."

> While I still don't plan to write software in it, given that I believe memory safety is table stakes

What exactly am I missing? You know you don't have to hijack Zig threads (repeatedly) with your thoughts on memory safety, right?

Re:Zig's Incremental Compilation Internals by steveklabnik on Wednesday July 29, 2026 @11:59AM (#49099214)
> What exactly am I missing?

My point in bringing this up is to strengthen my compliment. Even though I disagree with aspects of Zig's design, the stuff talked about in this post is excellent.

Re:Zig's Incremental Compilation Internals by mbrock on Wednesday July 29, 2026 @07:00AM (#49095826)
> I do not go around posting "omg Rust is SO MUCH BETTER than zig or fil-c, which are TRASH." I talk about engineering tradeoffs, and what matters to me personally. I do not say "if you use Zig, you are a bad person." I am not saying that any comparison is bad. I am saying that the way that the comparison is presented is bad. That is different.

Oh, who is saying things like that? Do you mean to imply that this kind of vitriol is characteristic of the Fil-C project?

Re:Zig's Incremental Compilation Internals by steveklabnik on Wednesday July 29, 2026 @11:59AM (#49099206)
Yes, this kind of rhetoric comes out of the project itself and its supporters, regularly.
Re:Zig's Incremental Compilation Internals by mbrock on Wednesday July 29, 2026 @12:11PM (#49099382)
Not really. I mean if you want to make that claim, use actual quotes.
Re:Zig's Incremental Compilation Internals by hexane360 on Wednesday July 29, 2026 @05:10PM (#49103131)
https://codeberg.org/ziglang/zig/issues/36237

>introduce an actually memory safe (unlike borrow checking) compilation mode inspired by Fil-C

Re:Zig's Incremental Compilation Internals by pizlonator on Wednesday July 29, 2026 @09:32AM (#49097296)
Steve, be reasonable.

I never said Fil-C is “so much better” (let alone with all caps) than anything.

I never called Rust “trash”.

I think you’re taking this all too personally

Re:Zig's Incremental Compilation Internals by steveklabnik on Wednesday July 29, 2026 @11:58AM (#49099202)
I will let others be the judge by reading what you've written.
Re:Zig's Incremental Compilation Internals by iczero on Wednesday July 29, 2026 @05:18PM (#49103222)
https://news.ycombinator.com/item?id=49097320

You think this is reasonable? I have also seen strange people on twitter support Fil-C while claiming that Rust is a language for [slur]s. I suppose by your "reasoning" that these people directly represent you and your project?

Re:Zig's Incremental Compilation Internals by Maxatar on Tuesday July 28, 2026 @02:41PM (#49088151)
There's a distinction between claiming something is objectively better, which is what Fil-C claims with respect to its "idea" about memory safety compared to Rust... and claiming a personal preference for one approach versus another approach, which is what OP is saying about their own personal preference about how Zig reduces errors compared to how Rust reduces errors.

It is absolutely possible that one language might actually have an objectively better approach to memory safety than another, and in such cases it is usually possible to argue for this using sound technical or empirical arguments. But the way the author of Fil-C presents their arguments it often comes across in a kind of antagonistic manner, like he has a chip on his shoulder.

Re:Zig's Incremental Compilation Internals by pron on Tuesday July 28, 2026 @03:05PM (#49088448)
> But the way the author of Fil-C presents their arguments it often comes across in a kind of antagonistic manner, like he has a chip on his shoulder.

You may well be right. I've yet to learn about it, but I'm planning to.

Re:Zig's Incremental Compilation Internals by pizlonator on Wednesday July 29, 2026 @09:59AM (#49097642)
I never claimed that Fil-C is objectively better than Rust.

As a long time PL researcher, I can, should, and will point out interesting corner cases of languages. Including in Fil-C or Rust

Re:Zig's Incremental Compilation Internals by iczero on Wednesday July 29, 2026 @05:56PM (#49103605)
Here is someone providing real criticism of Rust: https://news.ycombinator.com/item?id=49101733

Here is you claiming "Facts" on a troll post claiming to "criticize" Rust: https://x.com/filpizlo/status/2081765923757903940

Re:Zig's Incremental Compilation Internals by jibal on Tuesday July 28, 2026 @07:53PM (#49091591)
> But you did the same thing

So your defense is a tu quoque fallacy? Note that "the same thing" is an admission.