You shouldn't be hating Rust - it's a hope for a better world (and not just IT-wise):

You shouldn't be hating Rust - it's a hope for a better world (and not just IT-wise):
The stronger the type system the greater the chance is that software written using it will be robust.
Rust has a decently strong type system (could be better but it still beats the crap out of the ones used in shitty languages like C/C++/Java/C#), even if Rust itself isn't the end of the road, at leasts it paves it for the future where computers will finally become machines you can rely on instead of buggy fiddly messes they are currently...

>but I can't pass the borrow checker
git gud.
Seriously.
If you can't write a correct Rust program then you can't write a correct program in any language - you just don't know about it.

Attached: rust-social-wide.jpg (2048x1024, 132.89K)

>at leasts it paves it for the future where computers will finally become machines you can rely on instead of buggy fiddly messes they are currently...
You do realize that this is mathematically impossible? Rust won't magically solve the halting problem. Bugs will still exist regardless of how diverse of a team you get.

Yeah... OP's an idiot on that one. A good programming language can reduce the number of bugs significantly, but it will never totally eliminate them.

You're the morons here.
You somehow mistake the existence of a halting problem for the impossibility of writing correct programs.
It does not mean that at all.

*Oh, and by "correct programs" I mean "provably correct programs for all possible inputs".
Such programs are obviously very possible (and even done in practice in some applications).

You realize that languages that allow you to formally prove a program's correctness are explicitly not turing complete, right?

Rust idiots are rediscovering what Haskell has been proposing for over 30 years and they behave like they discovered some magic potion. Get with the times, cunts, you still don’t have higher minded types. Your type inference is still shit. Lack of proper functor/applicative/monad support makes the code look ugly as shit

>higher minded types
True. The moral impropriety of Rust types is a disgrace.

haskell is based but this is a retarded post. nobody using rust could possibly use haskell for their use case. people specifically pick rust for low level work where you don't want to be shitting memory everywhere.

Functors/applicatives/monads are zero cost abstractions. Rust should’ve already implemented them. They can’t shut the fuck about muh Option and Result, but they don’t offer the composition constructs that make them a joy to use

>computers become machines
Computers are machines already, the problem is academic masturbators dreaming up bullshit in their head movies and trying to turn computers into that.

No, they're not possible. The types of programs you describe are FSMs, they're not Turing complete - thus the correct statement that you'll never be able to produce a provably correct program for all possible inputs in a Turing machine.

Getting filtered by the borrow checker makes you a retard, but if you force a retard to use Rust they will get around it, even without unsafe. Usually they will just copy everything and introduce memory leaks, either by accident or out of laziness.
Rust is good for preventing shit like Heartbleed, but that's about it.

Getting filtered by memory management makes you a retard. Memory management is not so difficult that a person would subject themselves to the borrow checker.

So you like doing manual labor like a plumber.

>You shouldn't be hating Rust - it's a hope for a better world (and not just IT-wise):
Just like trannies huh?

You have no idea what're you talking about please shut the fuck up

>a hope for a better world
thats exactly why i hate it

All safety properties (bad things e.g. undefined behaviour, leaking secrets through side channels etc. shall not happen) can be verified using partial correctness logic, which works without losing Turing-completeness.

It's also not a foregone conclusion that writing useful software requires Turing-completeness, since, after all, real computers are finite machines. Of course, software is much easier to write if you don't have to prove that it will halt or respond to each request in finite time, even if it could theoretically be proven.

>Rust should’ve already implemented them.
It can't without HKT (low priority)

>The stronger the type system the greater the chance is that software written using it will be robust
Is there compelling evidence to support this claim?

What do you make of SeL4? Is it trivial or is it not provably correct?

How can removing one source of error (here type error) not lead to a decrease in errors?

SeL4 is trivial. It’s 10k lines, and punts the nontrivial work of building what people expect of an OS to the userspace. However, the verification effort is non-trivial. Plus, showing how to use a small, verified kernel to create a system that can withstand software bugs is brilliant.