[jacquesm]

This is all true, but even if you don't care about reproducible builds that doesn't mean that nobody cares about reproducible builds. And the people that do care about such things care about them very much. To the point that if you don't offer it to them that they'll go somewhere else.

[lamontcg]

I didn't say not to try to get to reproducible builds, though, but not to treat Dtolnay like he's a criminal.

There is a very real problem that he was trying to solve, but the right way to do it will require core language support. And his heart is certainly in the right place, since "slow build times" is probably the #1 complaint about Rust.

If you actually polled most Rust users they probably care about their build times more than they care about this issue, particularly if you designed the survey impartially and just asked them to stack rank priorities. They probably all would prefer "both" being the right answer though.

Where the criticism really needs to be leveled is on the core language design (although I appreciate that their job is also extremely tough).

[And the one good thing to come out of this shitshow will probably be getting people focused on solving this issue the right way]

[jacquesm]

It's funny how opposed the 'Go' and 'Rust' eco systems are, the 'Go' people optimized for compile speed from day 1 but have trouble making things safe, the 'Rust' people optimized for safety from day 1 but have trouble making things fast.

Maybe they could learn a trick or two from each other?

[_gabe_]

I don’t program in Go, but this is the first I’ve heard of it being unsafe. I thought Go was a GC language implemented via the Go runtime and properly handles memory safety (memory corruption and OOB access). Are you using a different definition of safety here or is there something else that I’m not aware of?

[kibwen]

"Maps are not safe for concurrent use: it’s not defined what happens when you read and write to them simultaneously."

https://go.dev/blog/maps

[_gabe_]

This is completely tangential to language “safety” as it’s commonly referred to when discussing languages like Rust and C or C++. Typically, I’ve only heard safety used to mean memory corruption, out of bounds memory access, and undefined behavior are not allowed, or throw runtime exceptions when they happen.

Java’s standard HashMap isn’t thread safe, it has ConcurrentHashMap[0] for this reason. And I’ve never heard somebody refer to Java as an unsafe language. Lemire wrote a blog article arguing Java is unsafe for similar reasons that it seems you’re using here, and I think the comments section has some great discussion about whether this conflation of language safety makes sense or not[1].

And one final point: a lot of the world lives on software segregated across several different machines, operating asynchronously on the same task, usually trying to retrieve some data in some central data store on yet another machine. Rust is great for locking down a single monolithic system, but even Rust can’t catch data races, deadlocks, and corruption that occurs when you’re dealing with a massively distributed system. See this article that talks about how Rust doesn’t prevent all data races, and why it’s probably infeasible to do that[2]. And I doubt anyone here is about to call Rust unsafe :)

This conflation of language often confuses me and I hope as an industry we can disambiguate things like this. Memory safety is distinct from thread safety for a reason, and by all reasonable standards Go is as safe as a modern language is expected to be. (Obviously better thread safety is a goal to be lauded, but as an industry, it seems like we’re still trying stuff out and seeing what sticks in regards to that).

[0]: https://docs.oracle.com/javase/6/docs/api/java/util/concurre...

[1]: https://lemire.me/blog/2019/03/28/java-is-not-a-safe-languag...

[2]: https://doc.rust-lang.org/nomicon/races.html

[phamilton]

> Memory safety is distinct from thread safety

From [2] you linked

> a race condition can't violate memory safety in a Rust program on its own.

From golang FAQ on maps not being atomic:

> uncontrolled map access can crash the program

This may be one very narrow case (or a more common theme), but at least in this case the thread safety becomes a memory safety concern in golang.

[Ygg2]

If maintainer didn't pledge themselves to obeying reproducible builds, you can't truly expect them to.

Otherwise you get into stupid situations like: https://xkcd.com/1172/ (your optimization is killing children!)

In FOSS there is the principle of four Fs:

- Fix it

- Fork it

- Fund it

- Fuck it/off