TWiR quote of the week

[2e71828]

Slightly OT here, but should that compile error say something about self-referential structs?

[alice]

Figuring out the exact conditions is probably difficult, but I think it would be a good idea.

[TomP]

Data ownership design patterns? Feasible or not?

There's no magic to how we solved the memory management issues. clone() is your friend when conversing with the borrow checker. Don't put references in your structs. Don't share mutable data; use a channel to send changes to its owner. Don't worry about performance until you have a performance problem. You can probably infer the last one from the first three.

Sage advice for anyone programming in Rust: first get it working correctly, then measure, then tune performance only if necessary.

[jhpratt]

@josh

Sometimes you don't want the code to compile. The compiler's job is often to tell you that your code doesn't compile, rather than trying to find some meaning that allows compiling your code.

from IRLO

[aDotInTheVoid]

You want to be looking into languages that tell you not "programming is so easy with me" but "programming is actually fiendishly hard but I'm going to try my best to help you get through it in one piece."

Bodil Stokke on twitter

[jonstodle]

Rust has a curse (it has many, but this one is critical): inefficient code is generally visible. Experienced developers hate to notice that their code is inefficient. They will recoil at seeing Arc<RefCell<T>> , but won't bat an eye at using Python.

by ekuber

[Yandros]

@kornel

Rust's difficulty raises exponentially with layers of abstraction.

The whole post is worth reading, I'd say

• for those wanting to discuss about it / challenge that assertion, the quote of the tweek thread is not for that. Instead, take advantage of there being a dedicated thread for it.

[blonk]

Unfortunately it's from the survey, so I don't know who to attribute it to, but this made me chuckle:

[...] clippy is for people who find a certain emptiness inside when they finally get code through the compiler.

[aDotInTheVoid]

Just because Rust allows you to write super cool non-allocating zero-copy algorithms safely, doesn’t mean every algorithm you write should be super cool, zero-copy and non-allocating.

trentj on URLO

[josh]

And it's true that a lot of stuff requires a "sufficiently smart compiler" but really it's 2020, if your compiler isn't serving you breakfast in bed you need to be upping your expectations.

-- Jubilee on the Rust Zulip

[ssokolow]

Historically, C has been the best fit for these applications just because it so lean: by providing essentially nothing other than the portable assembler that is the language itself, it avoids the implicit assumptions (and girth) of a complicated runtime. But the nothing that C provides reflects history more than minimalism; it is not an elegant nothing, but rather an ill-considered nothing

-- Bryan Cantrill on what no_std is competing with

[mark-i-m]

Alternative title: mediocre C++ is arguably worse than mediocre rust.

I’d agree with that? I think the power and danger of C++ is that it assumes the programmer knows best. Rust assumes the programmer is wrong if it looks dangerous. So.. yes?

By sesuximo in https://news.ycombinator.com/item?id=24817594

[pepp_cz]

Think of it like this: When Rust passes control to C it's like you jumping into a pit full of vipers in the hope that none of them bytes you. I might put up a sign "unsafe, vipers in pit".

ZiCog in Does Rust offer C interop? - #4 by ZiCog

[yoshuawuyts]

We need all that knowledge of what the problem space looks like to evaluate if a simple API is good enough, but we do not necessarily need all that knowledge reflected directly in the API surface.

Ralf Jung on the Safer Transmute RFC

---

To me this feels like a core insight on effective API design: map out the problem space, survey existing approaches, create a minimal solution. Then iterate from there.

[ZiCog]

At least let's please keep one single language that doesn't allow the perpetually-reinforced sloppiness.

H2CO3 here:

How to make rust usable in schools

First, this is completely subjective. I found Rust completely painless to learn. The secret? Years of C++ and a bit of interest in FP before I had heard of Rust. Once again, when someone complains that "Thing X is hard to do in Rust", it's not the fault of Rust. It is instead the problem that is hard in general – and indeed, finite-precision numbers are not fun to deal with if our mathematically-trained brains expect integers to be enumerably infinite. (And fallible type conversions in genera…

[josh]

I was writing some code today and had to pass a closure with an arg I didn't need: |_| .

I thought "That looks kind of like a TIE fighter, we should adopt the habit of calling them that." But then I realized, no, a TIE fighter would be |o| .

Instead, I think it more closely resembles an Imperial shuttle as it is landing. And do you know what class those shuttles are?

Lambda.

George Lucas was truly a visionary... on /r/rust

[nikolai]

Like other languages @rustlang does have footguns. The difference is that we keep ours locked up in the unsafe.

Ted Mielczarek on Twitter.

[aDotInTheVoid]

There are no bad programmers, only insufficiently advanced compilers

Esteban Kuber on Twitter

[edomaur]

I see a very sharp knife; but this knife is completely and utterly shrouded and encased in tamper-proof, child-proof, thief-proof hardened and sealed plastic shells. Yes shells as in the plural of shell. These shells are even adult-proof too, where the adult is a generic engineer trained generally in other languages only.

Levi Lovelock in hist blog : Rust from a Gopher - Lessons 3 & 4 - LevPaul88's Place

[ssokolow]

I personally feel that ownership semantics is a handrail on the design space that will guide you to a clear and simple design. If you come from an OOP background, this will feel limiting, but it's not a bug, it's a feature.

-- llogiq @ https://www.reddit.com/r/rust/comments/jocevb/the_fatal_flaw_of_ownership_semantics/gb7hmc8/