TWiR quote of the week

We tend to be conservative with these kinds of things at first. We could and may change this in the future, but once you do it, you can’t go back. It’s better to be conservative, feel where the pain leads you, and improve, then to speculate on things and end up adding bad stuff. – Steve Klabnik, on adding a feature to Rust

1 Like

I like quininer’s ‘quote’ :

cargo build --features post-quantum


@cuviper sums up Rust’s value-add for parallel programming in Parallel problems to showcase Rust features


Josh Triplett on #design (Discord) finding the optimal solution for one of my coming RFCs:

eddyb: cc @centril we found your syntax
JoshTriplett: IMO use replaces path while keeping the meaning, but changing from a noun to a verb, allowing the introduction of “can” which conveys allowance
JoshTriplett: Ah, I see. So, #[cfg(can_has(cheese::burger))] then? :smiley:

1 Like

Turns out that shared ownership is hard when you actually have to, you know, care about it and not just wave your hands and go, “THIS IS PROBABLY FINE” as I do in…erm…other languages. :slight_smile:

(zachlute on IRC, #rust-beginners)


@kornel on the new categorization logic :heart: :cat: :dog: :heart:


A poem, courtesy of @varkor:

Bastion of the Turbofish

Beware travellers, lest you venture into waters callous and unforgiving,
where hope must abandoned, ere it is cruelly torn from you. For here stands
the bastion of the Turbofish: an impenetrable fortress holding unshaking
against those who would dare suggest the supererogation of the Turbofish.

Once I was young and foolish and had the impudence to imagine that I could
shake free from the coils by which that creature had us tightly bound. I
dared to suggest that there was a better way: a brighter future, in which
Rustaceans both new and old could be rid of that vile beast. But alas! In
my foolhardiness my ignorance was unveiled and my dreams were dashed
unforgivingly against the rock of syntactic ambiguity.

This humble program, small and insignificant though it might seem,
demonstrates that to which we had previously cast a blind eye: an ambiguity
in permitting generic arguments to be provided without the consent of the
Great Turbofish. Should you be so naïve as to try to revolt against its
mighty clutches, here shall its wrath be indomitably displayed. This
program must pass for all eternity, fundamentally at odds with an impetuous
rebellion against the Turbofish.

My heart aches in sorrow, for I know I am defeated. Let this be a warning
to all those who come after. Here stands the bastion of the Turbofish.

note: downstream crates may implement trait `std::clone::Clone` for type `&mut _`

rustc, via eddyb


I agree with the goal, I just think it is impossible. Not that this has ever stopped anyone in Rust land

–Ralf Jung


Zeitgeist of Rust: developing load bearing software that will survive us.
– Bryan Cantrill: The Summer of RUST (1:08:10)


.expect("this will work if the computer isn't a coward")

Credit to on Mastodon


Sometimes bad designs will fail faster in Rust

Catherine West @ Rustconf


Rust beginners worrying about lifetimes is like kids worrying about quicksand. Both turn out to be a non-issue in life.

frequentlywrong at a discussion about NLL


interesting, because this also appeared on some podcast

Rust is a Fast Programming Language. Rust programs are therefore “fast,” especially so if you write them with the correct observations to the arcane ley lines of birth and death known as “lifetimes,” and also remember to pass cargo the --release flag.

– Adam Perry in lolbench: automagically and empirically discovering Rust performance regressions


<…> low-level memory-mongling is what C was designed for, and it is good at it. This is a great way to build low-level systems, but a shitty way to engineer software as a whole.

Porting C to Rust


There actually are NOT very many places where the C code’s behavior conflicts with Rust’s borrowing rules. This is both somewhat surprising, because there’s no way this code was written with Rust’s borrowing semantics in mind, and also entirely sensible, since Rust’s borrowing semantics are often quite close to how you actually want your code to behave anyway.

Porting C To Rust


Not a rusty quote, but still nice:

There’s two hard problems in computer engineering: cache invalidation, type naming and off-by-one errors

Arno Lepisk “Avoiding Disasters with Strongly Typed C++”


Sorry, that’s very much not from this week :wink: See for some history


Panic is “pulling over to the side of the road” whereas crash is “running into a telephone pole”.

/u/zzzzYUPYUPphlumph on reddit.