[skohan]

It can just be limiting in terms of ergonomics. Like I've implemented a couple of ECS's and what you want to do is dispatch a bunch of threads over big swaths of structured memory. One of the main things the borrow checker doesn't want you to do is use the same memory on multiple threads. You can do that in rust, and people have, but you have to put a lot of effort into convincing the borrow checker that what you're doing is ok, or else find ways to side-step the borrow checker.

So basically rust imposes a lot of limitations on how you can structure your program relative to something like Zig or C.

[Ygg2]

> So basically rust imposes a lot of limitations on how you can structure your program relative to something like Zig or C.

I don't see it imposing that much of a limit. If there is code you know is correct and Rust can't reason about it, do it in unsafe block.

And ECS is not just possible in Rust, but due to mutability guarantees you can make your ECS schedule systems in such way to maximize multi threading. See Bevy ECS.

[skohan]

Using unsafe blocks would fall into the category of "sidestepping the borrow checker". Again, it's possible to do it, but if you're going to do everything in unsafe rust why not just use an unsafe language in the first place?

And how does rust allow you to "maximize multi-threading" over what's possible in other languages? Anything you can express in rust can be expressed in C or Zig as well. The only difference is the implementation you reach will come with static guarantees about memory ownership (so long as you don't use unsafe). So the set of all rust programs is a essentially a subset of all C/Zig programs.

[Ygg2]

> Using unsafe blocks would fall into the category of "sidestepping the borrow checker".

I kinda want to end this assumption. Unsafe only allows few things.

- access to raw pointers.

- implement or accessing unsafe functions (e.g. C FFI)

- implementing or accessing unsafe trait

- access to unsafe union

- mutate global variables.

You can't bypass borrow checker, and you wouldn't do everything in unsafe. If you write everything in unsafe you are definitely doing stuff very, very wrong.

Rust unsafe is a surgeon's equivalent of a scar. Some scars need to happen, and you can tuck them out of sight if you are clever. However if after an operation you look like a map of scars, it means your surgeon is lacking.

No language can prevent you from abusing it, but in Rust it's apparent when you do it.

> And how does rust allow you to "maximize multi-threading" over what's possible in other languages?

Bevy newbie here so take it with a grain of salt. Because Bevy knows when and how Resources are related it systems can freely run in parallel if two resources are unrelated and mutable, or related and immutable.

> Anything you can express in rust can be expressed in C or Zig as well.

Point of a good programming languagues isn't to enable writting programs that can do anything but to aid programmers in writing error-free programs.

Why do you think we use punctuation and spaces? I remember a talk[1] where he noted spaces/punctuation became a thing only when Christian monks started transcribing written words, as a way of error correction. This was how written word looked before:

Withoutspacesitsveryeasytomakierrorsandnotnoticeitinfactdidyounoticeitwhenimadeabunchrightnowassumingthispartdidntcauseheadacheforyouineithercasewrongcodeinrustlooksjustaswrongasthisparagraph

[1] EDIT: Found the talk https://www.youtube.com/watch?v=_EANG8ZZbRs&t=1418s

[skohan]

Thank you for the thoughtful response!

A few thoughts:

> You can't bypass borrow checker, and you wouldn't do everything in unsafe.

Isn't unsafe still bypassing the borrow checker, in the sense that you're mostly using it because you're doing something the borrow checker does not otherwise allow?

> Because Bevy knows when and how Resources are related it systems can freely run in parallel if two resources are unrelated and mutable, or related and immutable.

But again, I don't understand how that is a unique benefit of Rust. It's completely possible to implement something in C which allows multiple threads to run over unrelated memory locations, or the same immutable memory location. As a programmer you have more options for how to achieve this when not restricted by the borrow checker. Most of the ECS systems in existence solve exactly this problem, and probably most of them are implemented in C++.

> Point of a good programming languagues isn't to enable writting programs that can do anything but to aid programmers in writing error-free programs.

I mean, I think it can't be taken for granted that preventing errors should be the top priority of every programming language. It's probably a priority of most languages, but there's no reason it has to take the number one spot.

I would argue the universal priority of programming languages is to enable the programmer to deliver user value through their program. Rust's thesis is that memory safety issues are such an obstacle to delivering user value that the language should prioritize safety at the expense of a certain amount of pain for the programmer. Languages like Zig and Jai prioritize programmer velocity and relegate safety to optional static analysis tools.

Python is another example: it's very easy to write an incorrect Python program, but the barrier to entry is so low that it enables non-programmers like scientists to do very interesting things by copying a few lines off the internet into a notebook.

There's no one best set of tradeoffs. But as I said from the beginning, if one of the main tasks you are doing is manual memory management, as domains like game dev and HPC require a lot of, you might want to choose a language which prioritizes explicit memory management.

[Ygg2]

> Isn't unsafe still bypassing the borrow checker, in the sense that you're mostly using it because you're doing something the borrow checker does not otherwise allow?

Not really. But using raw pointers and converting to/from memory addresses isn't something borrow checker can check.

It's a borrow checker not address verifier.

E.g. you can take raw pointer, and set two mutable variables to point to it and borrow checker can't know they point to same address.

> But again, I don't understand how that is a unique benefit of Rust.

It's statically enforced by the compiler using Rust's type system.

As far as I know Zig can't say well these two functions can run in parallel because they are at compile time guaranteed to never access same resources and it's impossible to bypass it (outside unsafe). And their content is thread-safe based on the type they satisfy.

> I mean, I think it can't be taken for granted that preventing errors should be the top priority of every programming language.

Douglas Crockford made a good case that every language should on some level try to prevent errors.

> Python is another example: it's very easy to write an incorrect Python program

Python is also older than Java, but even Python is memory safe (GC). Zig and new batch of better C aren't. In that way we definitely regressed.

> I would argue the universal priority of programming languages is to enable the programmer to deliver user value through their program.

If that is truly the case we'd be all programming in Excel and Access. Anything can deliver value, question is - can it be maintained, and at what cost.

In lieu of that a language that makes a set of errors nigh impossible is better than a fast one where those errors are trivial to cause.

[skohan]

> E.g. you can take raw pointer, and set two mutable variables to point to it and borrow checker can't know they point to same address.

That sounds an awful lot like bypassing the borrow checker.

> As far as I know Zig can't say well these two functions can run in parallel because they are at compile time guaranteed to never access same resources and it's impossible to bypass it (outside unsafe). And their content is thread-safe based on the type they satisfy.

Yeah but that's the point. Rust has one way of guaranteeing that two pieces of code don't mutate the same memory at compile time, but that's not the only way to write a correct program which guarantees that. Rust is going to force you to write your program in a certain way to achieve this. There are many other approaches you may be able to use in an unrestricted language which reach a correct and potentially more performant result which are correct, but which rustc cannot verify are correct.

> Douglas Crockford made a good case that every language should on some level try to prevent errors.

That's one opinion. There are many who disagree.

> Python is also older than Java, but even Python is memory safe (GC). Zig and new batch of better C aren't. In that way we definitely regressed.

That's not even an argument. It takes it for granted that lack of memory safety in a systems language is "a regression". That's not an established consensus.

> If that is truly the case we'd be all programming in Excel and Access.

How exactly do you come to the conclusion that Excel and Access are better at delivering value than other programming languages?

> Anything can deliver value, question is - can it be maintained, and at what cost.

Yeah exactly. The point is which language can deliver the most user value in your desired use-case at the least cost. For something like an operating system, where reliability is paramount, it may be a good tradeoff to use something like Rust which is unergonomic and slow to compile because the safety and correctness tools contribute to your use-case directly.

For something like a web front-end project, you're probably not going to choose Rust since it's going to be hard to find enough programmers who are willing or able to get over the Rust learning curve, and Rust's USP's don't do a lot for you.

For something like game-dev, where 30% of what you're doing is thinking about memory layouts, Rust's tradeoffs are actively working against you, and you might appreciate the faster code/build/run loop offered by something like Zig.