Do you apply the same reasoning for software that use javascript, the JVM, the CLR or some other kind of VM?

These are server CPUs, not something you wanna put in your laptop or desktop.

What? You can easily escape from it if there are better alternatives you can use.

So there is no general escape hatch.

Pointing at one language and saying it is not easy to code like it is another language is a pointless argument.

I’m not arguing that it is easier to code in C# than in Rust, just that this particular escape hatch is possible in C# and not in Rust. It’s just an observation.

They all differ for good reasons and as long as you can solve similar problems in both, even if in different ways then what does it matter that you cannot do it in the same way?

It does not really matter, but does it have to?

This is a kind of stupid example, but imagine you have to implement some external trait (e.g. in order to work with some dependency) with the following shape:

trait Foo {
    fn foo(&self, i: usize) -> &Bar;
}

Which is not too unreasonable, for example it’s very similar to the stdlib’s Index. In order to implement this trait you must return a reference, you can’t return e.g. a Cow or an Arc. The fact that it takes a parameter means there might not even be one single value it has to return, so you can’t even cache that inside of self with e.g. LazyLock.

Of course I’m not saying I would try to reach for an escape hatch if I had to do something like this. I would first try to see if this is an intrinsic problem in my code, or if maybe I can change the crate I’m working with to be more permissible. That is, I would try to look for proper solutions first, though Cow might not always work for that.

You dont write code like this in rust.

I perfectly agree, that would be horrible code! I would generally try to restructure my code, making it better fit the actual lifetimes of the data I’m working with. The point in the article is that you can’t really escape from this. I’m not arguing this is a real problem, and I don’t think the article is neither, just pointing out that this is something you can easily do in C# and not in Rust. It’s just a difference between the two languages.

I can agree that the example function is not the best usecase. But the point still stand that there’s no realistic escape hatch from lifetimes and memory management in Rust.

Cow does not work when you are actually required to return a reference, e.g. if you’re working with some other crate that requires that. Cow also has some more strict requirements on reborrows (i.e. you can reborrow a &'short &'long T to a &'long T, but you can only reborrow a &'short Cow<'long, T> to a &'short T).

LazyLock can solve very specific issues like static, but is not a general escape hatch. Again, the example is not the best to showcase this, but imagine if you have to perform this operation for an unknown amount of runtime values. LazyLock will only work for the very first one.

It’s a very different kind of borrow checking than Rust’s. For example there’s no mutability xor sharing checking, because mutability cannot invalidate memory (there’s still a GC in C# after all!). As such, Rust’s NLL (which are available in the 2015 edition too btw) don’t really make sense in C#.

(Note that I’m not the article author)

In this example, you could have just made a constant with value 0 and returned a reference to that. It would also have a 'static lifetime and there would be no leaking.

I believe the intention was to demonstrate something that works with runtime values too, and a constant 0 does not.

Btw you can just write &0 to do what you proposed, there’s no need for an explicit constant/static.

write only medium

I guess you meant “write once”?

Anyway, this won’t prevent attacks that somehow swap the CD being read, or the backend logic for where to read the data from.

You cited Git as an example, but in Git it’s possible to e.g. force-push a branch and if someone later fetches it with no previous knowledge they will get the original version.

The problem is the “with non previous knowledge” and is the reason this isn’t a storage issue. The way you would solve this in git would be to fetch a specific commit, i.e. you need to already know the hash of the data you want.

For the Wayback Machine this could be as simple as embedding that hash in the url. That way when someone tries to fetch that url in the future they know what to expect and can verify the website data matches the hash.

This won’t however work if you don’t already have such hash or you don’t trust the source of it, and I don’t think there’s something that will ever work in those cases.

Lots of major companies like Microsoft and IBM also contribute to Linux, it doesn’t make them saints nor even necessarily compare to what they get for using the volunteer dev work inside Linux.

Most of those companies actually contribute to the kernel or to foundational software used on servers, but few contribute to the userspace for desktop consumers on the level that Valve does.

No, macros can see only the tokens you give them. They have no notion of the fact that crate::functions is a module, that PluginFunction is a trait and that functions_map is a variable. Not even the compiler may know those informations when the macro is expanded.

If you really really want to do this, you can use something like inventory. Note that inventory uses a special linker section to do this, which some consider a hack. This is also not supported on WASM if you want to target it.

CEO bonuses should be awarded 10 years after their mandate

Would it makes sense to provide a “share nothing” runtime implementation that can be injected at startup?

Isn’t this tokio::task::spawn_local?

The reputation loss is probably worse than whatever fine they end up paying

Time to pull a Meta/X and change name

Unfortunately some things will IMO always remain a natural monopoly. For example good luck trying to convince developers to write their apps for all those different operating systems.

Luckily Apple strictly controls the App Store and will never allow apps to abuse this, right? Right?

Your parent comment was mentioning the fact that their store still does not support user reviews, which should be one of the most basic features.

compile rust 0.7 in scala

Not sure if there was another rewrite, but AFAIK (and the article agrees with me) rustc was originally written in Ocaml

Epic chose not to try and compete with Steam on that front

Forget competing, they lack even the basics.