5 ms·
Its undefined because it's not guaranteed to happen, that's the whole point, and that's what makes it undesirable. Rust has it right here: don't allow undefined
by arcticbull 8y ago
Its undefined because it's not guaranteed to happen, that's the whole point, and that's what makes it undesirable. Rust has it right here: don't allow undefined behavior and make the programmer specify the behavior they want.
If they want wrapping overflow, fine. If they don't, great. Tell the compiler don't make it guess/assume/optimize/hope. What this article is arguing for IMO is not the concept of behavior that happens to sometimes work and sometimes not depending on the target machine (because thats crazy) but the functionality itself, which is valuable, and should be explicit and defined. The issue is the last-generation languages like C/C++ don't give you mechanisms to express what you want so you're left hoping the compiler figures out what you meant. That's not a world I want to live in anymore, we can do better.
UB is bad, period. Define what you want, make the compiler do it.
- kibwen 8y agoThough note that Rust still has things that are definitely undefined behavior (my favorite: "Transmuting an & to &mut is always UB; No you can't do it; No you're not special" https://doc.rust-lang.org/beta/nomicon/transmutes.html https://doc.rust-lang.org/beta/nomicon/transmutes.html ), it's just that someone has to break out the `unsafe` keyword to get it to happen, and that an error as a result of undefined behavior can always be traced back to an `unsafe` block's invariants being violated somehow.
- arcticbull 8y agoDefinitely, but at least when you see unsafe {} you know all bets are off instead of having to assume all bets are off all the time. I do see what you mean though. The transmute thing is pretty funny imo.
- cwzwarich 8y agoSince any Rust function may use unsafe code, you don't know whether bets are off for any particular function call.
- kibwen 8y agoAny public API using `unsafe` code that can't enforce its own unsafe invariants should (and in practice does) get marked as `unsafe` itself in order to force callers to use `unsafe` when calling that function. Of course it's something that, by definition, the compiler cannot enforce on its own and hence requires social norms and social pressure to enforce, and it's therefore fortunate that the Rust community takes it very seriously.
- Retra 8y agoYeah, in theory. In practice, if someone writes code that is throwing away compiler checks for no reason, you simply don't use it.
- paulddraper 8y agoBut very many pieces of code, even such pedestrian things as data structures require unsafe code. So the attitude of "only unsafe programs have UB by the Rust spec" effectively means "all programs have UB by the Rust spec"
- dbaupp 8y agoAny Python function may use ctypes, any Haskell function may use unsafePerformIO, ..., so all bets are off all the time. I don't think that's a particularly useful point, as is.
- lomnakkus 8y agoNot that this "makes the point", necessarily, but GHC Haskell does have the whole Safe/Unsafe Haskell module inference/guarantee, so it may be a bit easier to avoid unexpectedly unsafe behavior entirely. I have no idea whether any equivalent exists for Rust.
- steveklabnik 8y agoRust requires you to to explicitly mark individual blocks of code as unsafe, and you can only do unsafe operations inside of them.
- obl 8y agoSome UB in C is largely regarded as a bad idea, such as signed overflow. One reason for that is that it's easy to get rid of it, and guess what, we have a bunch of compiler flags just for that. That absolutely does not mean that "UB is bad, period". In fact you praise Rust but only safe Rust has no UB. Actually, if they do end up putting more and more knowledge about the type system invariants in the optimizer, the rules for UB in unsafe code are going to be more complicated than C (think type-based aliasing on steroids). Don't get me wrong, it's good design to nicely package these in unsafe code, but if your language can craft pointers and load/store from them, your spec will have to have UB (or boundcheck all loads and stores).
- DSMan195276 8y ago> the rules for UB in unsafe code are going to be more complicated than C This is one of the biggest issues I have with Rust, personally. The interaction between safe and unsafe Rust is not well defined, making it largely impossible to write 'correct' unsafe Rust that isn't broken in some weird situation, or won't ever get broken in later versions of the compiler. And since the Rust compiler has even more information then the C compiler does, it can theoretically make much crazier optimizations then it is doing right now that could break your code down the line. Like you mentioned, if it goes down that route it'll be like the strict-aliasing situation in C but times 10.
- jacobush 8y agoI wonder if it would help if there were different rules for un-safe Rust and safe Rust? Or from a more pragmatic point of view, if one could compile un-safe Rust similarly to "optimisations off" in C compilers. No aggressive optimisation, only straight forward translation. While Rust code marked safe could be compiled with the most insane optimisations, and still be ... safe. If not, I think people concerned about such things, might opt to write the unsafe parts on C (a known quantity) and the safe parts in Rust.
- steveklabnik 8y agoThat won’t work, because safe rust optimizes around rules unsafe is expected to uphold. Even a “straightforward translation” of the unsafe could still easily break invariants safe code expects. All this stuff is why we’re working so hard on formalizing unsafe! Your parent is right that it’s a bit fuzzy right now, but in the future, we hope that it’ll be way nicer than other unsafe languages. There’s some tooling ideas...
- cperciva 8y agoRust has it right here: don't allow undefined behavior and make the programmer specify the behavior they want. If they want wrapping overflow, fine. If they don't, great. What if I know overflow can't happen (e.g. I have an integer counting from 1 to 10)? How do I say "it doesn't matter how you handle overflow; just do whatever is fastest"?
- deleted 8y ago[deleted]
- tolmasky 8y agoIn a language with a sufficiently advanced type system you can use Peano numbers to specify a type specifying an integer between 0 and 10. These type systems usually are smart enough to have optimized internal representation of said types.
- steveklabnik 8y agoYou can do that in rust, there’s even a package for it. It will destroy your compile times though. In the future we’ll have const generics that let you express it directly without that shenanigans.
- tolmasky 8y agoI would love to have something that would translate a more human readable version that looks like a constraint or range that internally translates to the same functionality of the peano solution. If that's what you're saying Rust intends to have then I'm very excited and continue to be impressed by the progress there.
- steveklabnik 8y agohttps://github.com/rust-lang/rfcs/blob/master/text/2000-const-generics.md https://github.com/rust-lang/rfcs/blob/master/text/2000-cons... is the current accepted design; we plan to go further in the future, but wanted something minimal at first. This is likely to land in nightly by the end of the year and be stable sometime early next year.