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.
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
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.
(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.)
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
And even if you could fix all of rustc's soundness holes, or otherwise prevent user code from exploiting them, a soundness bug in any third-party library can also make it possible for malicious crates to trigger arbitrary behavior from safe code.
This is why we need to emphasize that while Rust's static analyses are very good at limiting accidental vulnerabilties in non-malicious code, they are not a sandbox system that can place meaningful limits on malicious code.