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."
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.
The whole post is worth reading, I'd say
- for those wanting to discuss about it / challenge that assertion, the
quote of the tweekthread is not for that. Instead, take advantage of there being a dedicated thread for it.
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.
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.
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.
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
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?
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".
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.
At least let's please keep one single language that doesn't allow the perpetually-reinforced sloppiness.
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
Instead, I think it more closely resembles an Imperial shuttle as it is landing. And do you know what class those shuttles are?
George Lucas was truly a visionary... on /r/rust
Like other languages @rustlang does have footguns. The difference is that we keep ours locked up in the unsafe.
Ted Mielczarek on Twitter.
There are no bad programmers, only insufficiently advanced compilers
Esteban Kuber on Twitter
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 : https://levpaul.com/posts/rust-lesson-3-and-4/
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.
In a way [Arc and RefCell] are allowing you to escape the single ownership principle, so I don't feel calling them escape hatches is a problem.
Raw pointers on the other hand... they aren't anything like hatches at all. More like the three ghosts of memory unsafety past, present and future, willing to haunt you and your users if you give in...
(Sorry for putting up two in rapid succession, but llogiq is being particularly poetic today.)
If other compilers are insufficiently advanced, rustc must be called insufferably advanced.
Macros are not compiler magic. They are compiler science.
When I'm programming, I prefer to do my own swearing. I don't want the compiler telling me "Did you mean $#&@foo instead? (line 56)."