That would make society better, I agree, but I don't see how that would lead to a reduction in theft, or crime in general.

> And if you are still worried about theft in the mean time, you could try looking at wage thefts […]

I'm not worried about wage theft, no. I am worried about theft of my personal property, though. And I notice that you haven't proposed any credible path to reducing it, beyond an incredibly generic "make society better", whatever that means and however you want to achieve that.

Phew, good to hear. Here I thought it would be a hard and complex problem, with lots of unknown unknowns, difficult political compromises, a generation-spanning efforts and many potential solutions with uncertain outcomes, partially contradicting each other.

Instead, we just have to make society better. So, what's step 1?

You're just splitting hairs and trying to weasel around the fact that yes, you really can create any lifetime you want using unsafe.

> Not sure what you meant by this example since it doesn't compile.

That's because the crappy HN formatting ate some of the characters. Here's the original version:

https://play.rust-lang.org/?version=stable&mode=debug&editio...

> What you probably meant is […]

If you know what I meant, then what's up with your snarky comment about "So much for effectively disabling stuff"? In your playground link, you did effectively disable the borrow checker in safe parts of the code. Next thing you're moving the goalpost, now it's not about external, static analysis tools: "run this with UBSAN, ASAN, and other C tools". I don't think you're arguing in good faith here. Goodbye.

> Does bun actually do anything insane like that in its unsafe blocks?

Who knows? At 10k unreviewed uses of unsafe, I'd guess there are quite a few incorrect ones. LLMs don't produce perfect code (neither do humans), so there's a high probability that at least some of those create UB.

No, you're wrong: You can create any lifetime. Proof:

    fn oof<'desired>(x: &u32) -> &'desired u32 {
        let ptr = x as *const u32;
        unsafe { &*ptr }
    }

> You don't disable anything.

I said "effectively disable". For example:

fn trust_me_bro<'a>(x: mut u32) -> &'a mut u32 { unsafe { &mut x } }

    fn main() {
        let mut x = 1_u32;
        let reference_a = &mut x;
        let reference_b = trust_me_bro(reference_a);
        *reference_b = 2;  -- Whoops
        println!("reference_a: {reference_a}  reference_b: {reference_b}");
    }

It isn't necessary, because settings timeouts or other resource restrictions works way better to prevent DoS.

It isn't sufficient, because even if you can prove that a program will halt at some point, this alone doesn't tell you how long it will take. What good does it do to know that the program will run for 10 years before it halts? By that time, service will already have been denied. Even turning hash table lookups from O(1) to O(n) (still very much terminating!) can result in a DoS.

Baseless speculation

> probably is somewhat of a loss leader for small-batch users

Wrong. AMD/Xilinx doesn't sell devices directly to customers, they sell them to distributors in huge quantities. Those distributors then sell them to "small-batch users", and they're not involved with AMD/Xilinx free-tier software at all.

> they’re running at around -10% profit on small sales to try and drive subscription revenue multipliers

More baseless speculation

I think you're conflating qualia with free will. These are very different concepts, and the experience of qualia has nothing at all to do with "violating causality".

> So there should be no reason we cannot reduce these phenomena to actual quantifiable and there for Computable elements.

As long as we have practically no idea how qualia arise, or even what exactly they are, your claim has no base to stand on.

[1] Or "qualia", to be precise.

[2] For example, the existence of qualia might require certain carbon-based structures which aren't present in silicon-based devices.

This is like a user of conventional software complaining that "it crashes", without a single bit of detail, like what they did before the crash, if there was any error message, whether the program froze or completely disappeared, etc.

To my understanding, you couldn't do this, no. The US is a net oil exporter, but many of its refineries are tuned for processing oil with a chemical composition that isn't found in the US, or not found in sufficient quantity. So the US has to both import and export oil, it can't just replace imports with exports.