It's nice to be quoted on TWiR.
But is that intended to be an example of a newbie mistake or bad practice? Or the opposite.
I got a chuckle out of the following visualization:
ZiCog's former employer: They copy pasted our code. ZiCog: They used JS. We use Rust. Judge: Case closed.
EDIT: I am not a lawyer. The above is not legal advice. If you are in ZiCog's situation, consult a lawyer.
Except they accused us of having run away with the code for an entire project, which we were picking up from an existing customer. And of not delivering it to them, after we had and they had not paid us or the office rent for months.
I was inspired by the story of Compaq and others clean room reverse engineering the IBM PC BIOS so that they could make PC clones without stealing the original BIOS code. So I was looking to start over with a new language, I had only then discovered Rust and soon decided to bet the farm on it. It's been working very well.
"Case closed". Well, we have not heard back from them... yet.
Luckily my partner's girl friend is a well qualified commercial lawyer
Rust maybe “multi-paradigm general-purpose programming language” but it's also incredibly opinionated and tries very hard to stir you toward “great APIs” (good APIs are easy to use, great APIs are hard to abuse).
I think just maybe not "incredible opinionated" but the last words seemed nice.
Succintly put , this is sometimes overlooked.
Do you want to know what was harder than learning lifetimes? Learning the same lessons through twenty years of making preventable mistakes.
"All applications that can be (re)written in Rust will eventually be (re)written in Rust" - Riemer's law
Posted on Mastodon.
See Atwood's law for context.
Twitter surfaced this and I couldn't help but to nominate this tweet
They go on to say:
i lived in a glorious ivory tower of algorithms and datastructures, absolutely refusing to think about what the fuck was in std::fs, even while i was literally on the team that ostensibly maintained it
now my tower is in ruins, i know what an OpenOptions is, alas, i am no more
i must soothe my burns with the knowledge that i still have absolutely no idea what is in std::net
although even that is ash in my mouth knowing i was also forced to actually write the word "async" like a coward and a fool
Rust really turned me on to the idea that there are actually two places to put data of indeterminate length: space (heap), and time (iterators, write-APIs)
There's a common trope among people unfamiliar with rust where they assume that if you use unsafe at all, then it's just as unsafe as C and rust provided no benefit. Comparing C's approach to safety vs Rust's is like comparing an open world assumption to a closed world assumption in formal logic systems . In C, you publish your api if it's possible to use correctly (open world). In Rust, you publish a safe api if it's im possible to use in correctly (closed world). Rust's key innovation here is that it enables you to build a 'bridge' from open world (unsafe) to a closed world (safe), a seemingly impossible feat that feels like somehow pairwise reducing an uncountable infinity with a countable infinity. Rust's decision to design an analogous closed-world assumption for safe code is extremely powerful, but it seems very hard for old school C programmers to wrap their head around it.
Rust is the language where you get the hangover first.
Unattributed, via RustConf 2021 - Project Update: Lang Team by Niko Matsakis
The biggest failure in Rust‘s communication strategy has been the inability to explain to non-experts that unsafe abstractions are the point, not a sign of failure
By withoutboats at tweet
By micha_38 in the Berline.rs Matrix Chat:
...[T]he fastest and most reliable way to make slow rust code fast is to post it on r/rust saying that it's slower than corresponding Go code, and then watch other people optimizing it.
While talking about API design
I think in general "force the user to think about the extra cases, and be explicit about ignoring them" is definitely idiomatic rust.
I just said something which, in hindsight, might appeal as a quote of the week:
Rust is very much about patching or working around wetware bugs.
(Said in the context of arguing that the orphan rule is about preventing programmer burn-out and that machine analysis has shown that we may be better at it than memory safety, but we're not very good at stable ABIs either.)
I always tell myself that code quickly written just to compile looks like Order 66 executed on Christmas day.
Clones and unwrapping as far as the eye can see.
What you'll find is that when Rust developers are freaking out about "bad performance", the "bad" performance is still usually hundreds of times better than dynamic languages
it's just bad compared to perfect optimized ideal Rust code
Pauan on the future-signals Discord server