upvote

points

by cowlevel13 hours ago |
comments
upvoteby insanitybit13 hours ago|
next
[-]
lol do you think that cve-rs was required? there is literally an l-unsound tag on rustc's github, this isn't some embarrassing or secret thing.

Safe rust is safe, granting `unsafe` and compiler errors. This isn't a secret.

reply
upvoteby psychoslave13 hours ago|
parent|
[-]
What's l- here? Literal?
reply
upvoteby pas13 hours ago|
parent|
[-]
"I" stands for "issue"

https://github.com/rust-lang/rust/labels?q=unsound

reply
upvoteby insanitybit12 hours ago|
parent|
[-]
lol I was writing `l` because I thought it was `labeled-unsound` for like a fucking decade
reply
upvoteby high_na_euv13 hours ago|
prev|
next
[-]
in compare to c and cpp? it is
reply
upvoteby cowlevel13 hours ago|
parent|
[-]
And in absolute terms?
reply
upvoteby sunshowers9 hours ago|
parent|
next
[-]
All memory safety on von Neumann architectures is specified with respect to a TCB. For Rust, the TCB includes the compiler. The TCB can have bugs. This doesn't invalidate the memory safety promise, given that it is made with respect to the TCB.

In contrast, memory-unsafe languages don't even try to have a TCB relative to which memory safety is specified. That's the main difference.

reply
upvoteby qweqwe1413 hours ago|
parent|
prev|
next
[-]
Literally nothing can be anything in absolute terms, what's your point? The fact is that Rust is miles better than any other language in terms of memory safety & performance ratio. That's all that matters.
reply
upvoteby bcjdjsndon9 hours ago|
parent|
[-]
[flagged]
reply
upvoteby qweqwe146 hours ago|
parent|
[-]
The entire industry right now seems to think otherwise :)
reply
upvoteby cmrdporcupine11 hours ago|
parent|
prev|
next
[-]
"People still die in cars despite airbags and seatbelts so I don't see the point in wearing a seatbelt."
reply
upvoteby high_na_euv12 hours ago|
parent|
prev|
[-]
cmon, it is time move on.

it has been discussed bilion times

reply
upvoteby david-gpu13 hours ago|
prev|
[-]
Let us not conflate a bug in an implementation (rustc) with a defect in the language (Rust).
reply
upvoteby mrkeen13 hours ago|
parent|
next
[-]
AFAIK there isn't a language spec. Rustc is the language for now.
reply
upvoteby afdbcreid13 hours ago|
parent|
next
[-]
But bugfixes are also allowed. So the fair conclusion is that the implementation is broken, but the language is not - because it's possible to fix, and it's possible for all known soundness issues (including the cve-rs one). For this one specifically, I've heard people are already working on a fix.
reply
upvoteby cowlevel12 hours ago|
parent|
[-]
[flagged]
reply
upvoteby david-gpu12 hours ago|
parent|
prev|
[-]
My understanding is that it is work in progress, via Ferrocene.
reply
upvoteby Georgelemental8 hours ago|
parent|
next
[-]
Ferrocene is not a separate implementation of the compiler. It's the same Rustc, just a few versions behind and with a bunch of regulatory approvals attached. There is ongoing work on fixing all the unsoundnesses, happening as part of the main compiler development: https://goals.rust-lang.org/2026/roadmap-project-zero.html
reply
upvoteby beanjuiceII12 hours ago|
parent|
prev|
[-]
Ferrocene has his same flaw
reply
upvoteby david-gpu12 hours ago|
parent|
[-]
If that's the case then I was wrong.
reply
upvoteby cowlevel13 hours ago|
parent|
prev|
[-]
Which clause of the language specification is being violated?
reply
upvoteby lkey12 hours ago|
parent|
[-]
Lifetimes can be effectively erased via covariant assignment. It's in the title. Even a beginner could understand these assignments are not in spec? Are you just being contrary to be contrary?
reply
upvoteby csande1712 hours ago|
parent|
next
[-]
If that's the definition you're using, then C is also a safe programming language. In fact, C is even safer, because it actually does have a specification that lists all the invariants that the programmer has to uphold themselves because the compiler doesn't check them.
reply
upvoteby aw16211076 hours ago|
parent|
[-]
> In fact, C is even safer, because it actually does have a specification that lists all the invariants that the programmer has to uphold themselves because the compiler doesn't check them.

The difference is that the C spec intentionally frees the compiler from upholding those invariants. In this case the Rust compiler is failing to catch something it is required to catch.

A more accurate analogy would be a C compiler incorrectly failing to reject an assignment through a pointer to const without a cast. The spec requires that such a thing be rejected, so it's a compiler bug.

reply
upvoteby cowlevel12 hours ago|
parent|
prev|
[-]
So point to the spec
reply
upvoteby Ukv12 hours ago|
parent|
next
[-]
https://public-docs.ferrocene.dev/main/specification/types-a...

Specifically the `q.0 = Some(&l);` violating 4.15.2:40 ("An assignment expression requires that the type of its value operand is a subtype of the type of its assignee operand.")

reply
upvoteby cowlevel11 hours ago|
parent|
[-]
That's a pretty basic property of any language. Why does the rust compiler fail to enforce it in this case?
reply
upvoteby ninkendo11 hours ago|
parent|
[-]
> Why does the rust compiler fail to enforce it in this case?

A bug. The one linked, that we're all talking about.

Feel free to share a link to any software that has zero bugs.

reply
upvoteby beanjuiceII12 hours ago|
parent|
prev|
[-]
this is probably a great opportunity for rust to get one, if they want to be taken seriously
reply
upvoteby uniqueusername712 hours ago|
parent|
[-]
I totally understand that people have favourite languages and that rust, like any language and any ecosystem around that language, has idiosyncrasies that are not for everyone, but how would one ever come to the genuine conclusion that rust is not being taken seriously? By whom?
reply