Executes as fast as C while written as elegant and safe as Ruby

>not without using unsafe blocks which makes it POINTLESS

don't expect to be taken seriously when you sow your ignorance as a point of view

>reddit spacing
don't expect to be taken seriously

>can be used anywhere from embedded systems

[citation_needed]

Attached: 1559582976388.jpg (381x499, 57K)

Didn't you hear? Ada is trying to be Rust by adopting the ownership model, lol.

>that logo tho

Attached: thA52SGFWA.jpg (420x420, 20K)

>i've spent hours just figuring out how I can bubble up errors to the main function
How is it difficult? All you do is putting a question mark after calling a function that returns a Result type

fn main() {
if let Err(e) = run() {
eprintln!("{}", e)
}
}

fn run() -> Result {
let s = std::fs::read_to_string("afile")?;
println!("{}", s);
Ok(())
}

That's for a single function. Now imagine you're writing a CLI tool. There's hundreds of function calls throughout the code that can return some variation of Error (but not necessarily derive it). You've got to get all of those errors up to the main function and have a huge fucking match statement to handle every scenario. You're going to have to create some huge fucking error type and use ? everywhere which will look hideous. Trust me, I've tried all this before and eventually just gave up with Rust. It's a fucking nightmare. I don't give a shit if a file operation can fail, I don't want to have to call fucking unwrap, if it fails then just fucking kill the program.

Well, you only propagate errors to main if you want it to end the program. If you want to handle the error, you do it right away. There is std::process::exit but that would result in way more builerplate for no reason.

Tfw you're not creating your custom error type and impling From trait on these other error types to convert it to your type. Or just use the failure crate

>I don't want to have to call fucking unwrap, if it fails then just fucking kill the program.

that's what unwrap does, retard, you can also use map_err() or or_else() for clean error conversion or handling

No one is going to use your faggot language, OP.

rust-lang.org/production/users
enjoy your NEETdom, poorfag

Less than 5% of those companies will exist in 10 years.

just like all startups that use every other language

no shit faggot, I want to EXIT not PANIC. I was writing Rust for over a year, I know my shit, and I know the fucking language is a pile of SHIT and a waste of time. FUCK trannies and fuck Mozilla.

Which was my point, you fucking shitter. A list of shitty startups and a few decently established companies doesn't mean shit.
All of you faggots spinning your wheels for some (((investment capital))) company so they can dump it after the IPO are just gold-plated wagecucks
Who else /codes for the gubmint/ here?

>I was writing Rust for over a year, I know my shit
doubt it, if you really knew, you wouldn't have asked such a retarded question, NEET

C89 is the way to go

stay mad

cope tranny, your language is braindead

>tranny
the only argument I'd expect for a low IQ NEET, if you really knew who actually work on Rust's core, you would not even have mentioned this retarded argument

Hey I'm wearing that exact one, weird

>ada is so good that its copying rust now
yea, you read it right

Attached: 1559700847191.png (1600x900, 232K)

>elegant and safe as Ruby
I would not say Rust is particularly elegant, just more consistent than C++. Also, it's a hell of a lot safer than Ruby. Ruby allows you to do some really fucking stupid shit.

well, im using it
thats more than enough desu

>I don't give a shit if a file operation can fail, I don't want to have to call fucking unwrap, if it fails then just fucking kill the program.
>But why does it make me handle the error, how do I ignore it? This language is making me feel stoopid! Fuck mozilla REEEEEE

>I don't give a shit if a file operation can fail

this alone should make you ignore that retard

Leftist trash.

Ada developers are boomers working for defense contractors. They don't spend their time optimizing some retarded Internet benchmark.

Trannies are pushing hard, not surprises, since 90% of Jow Forums are trannies...

I prefer go. It's faster then rust

lol no generics

CRIPPLE FIGHT!

Attached: c.jpg (474x355, 20K)

medium.com/luosrobotics/why-rust-is-the-future-of-robotics-81d7fb68fe37

Attached: Screenshot_2019-03-01 g - 1 33 0 is out - Technology - 4chan.png (1066x809, 282K)

Benchmarks suggest otherwise.

basedest comment so far

>I prefer go. It's faster then rust

Attached: 1554758154807.jpg (971x565, 139K)

>elegant as ruby
>no nulls
yeah no. also,
>bloated executable size
>community declares war on any project that wont drop everything and rewrite in rust
even fucking gofags dont do this

>getting this triggered by trannies

Attached: file.png (400x506, 190K)

I don't have a use case for it at work, and at home I want programming to be enjoyable and not have to think too hard up-front about architecture.
I respect the hell out what the language is going for, but I also am kind of dumbfounded at the kind of fanatical haters it seems to have attracted. I have lost count of the number of obvious false flag "rust fans" that I've seen trying to bait people into arguments. You people need a fucking life.

>Ruby
>elegant and safe

AAAAAAAAAAAAAAAAAAAAAHAHAHAHAHHAHA

The syntax is fucking crap - the Rails and webdev scum who tried to fix C++ did not even knew that much smarter people have spend decades polishing syntactic forms of functional languages such as SML or Miranda or Haskell.

Even messy Scala has everything better.

Once Scala will be ported to LLVM (a Titanic task since it needs a new runtime instead of fucking JVM) no one will look back at this amateurs shitfest

brainlet.

type-traits of Rust (which are Ruby dev's type-classes) is a much better way of doing OOP properly - traits are composable you fucking degenerate

My God, that code is such an eyesore. How can any sane person like this garbage?

> Box

What the fuck am I reading?

Rails devs have never seen any better - SML, Ocaml, Miranda, Haskell, Scala

Being better than PHP which is just an anal porn of programming, is enough to them

>all of ruby is rails
fuck off

Ada still does malloc() and free()

It's only age if you never allocate memory dynamically. In other words, it's only safe when you know exactly how much RAM you're going to use

Rust is nowhere near as elegant as ruby, nor is ruby particularly safe bring dynamically typed and full of magic.

The rest I reasonably agree with, but God tier package management is a strong agree.

You still didn't answer my questions last time you posted this thread:

When the fuck are they going to make Rust not so hopelessly tied to cargo?
When the fuck are they going to give Rust a stable ABI?
When the fuck are they going to make Rust actually work properly with dynamic linking?
How the fuck did they expect to be taken seriously as a system's language without these things?
Why are there so many Rust shills, yet so few people actually using Rust?

Attached: 1560312447857.png (274x301, 16K)

>When the fuck are they going to make Rust not so hopelessly tied to cargo?
even though this is a retarded question, it's not, you can just use rustc fuckery as much as you want
>When the fuck are they going to give Rust a stable ABI?
it's stable enough
>When the fuck are they going to make Rust actually work properly with dynamic linking?
invalid question
>How the fuck did they expect to be taken seriously as a system's language without these things?
retarded question
>Why are there so many Rust shills, yet so few people actually using Rust?
invalid and retarded question, shills cannot be applied in this case, this is a FOSS project and a programming language, shills shill for commercial shit because they get paid for it just like Brave and DDG threads, also not a few people are using it, you're just delusional

>even though this is a retarded question, it's not, you can just use rustc fuckery as much as you want
Have you seriously tried to use Rust outside of cargo? Just try to integrate Rust into another build system and another language, and tell me that they didn't deliberately make it a pain in the ass on purpose.
No, trying to cram another language isn't cargo's god-awful build.rs is not an acceptable solution.
>it's stable enough
It's straight up unstable, and they make no guarantees for it. You cannot link together Rust compiled with different versions of the compiler.
>invalid question
No it's fucking not. Forced static linking is a straight up proprietary cuck thing to do. Sure, you _technically_ can do dynamic linking, but due to the broken ABI, and them making is as hard as fucking possible to do, literally nobody does it.
This kind of retardation completely fucks with the way distros work, and mandates fucking huge amounts of recompiling and bloat when things change.
>retarded question
No it's not. Imagine I want to write a library that can be used from any language. Do you know how needlessly hard Rust makes that?
I'm not dealing with any of that shit; I'll just stick with C then.
>invalid and retarded question, shills cannot be applied in this case, this is a FOSS project and a programming language, shills shill for commercial shit because they get paid for it just like Brave and DDG threads, also not a few people are using it, you're just delusional
I have observed many open source projects that I am directly and indirectly involved with. All of the C projects see significantly more contributors, while almost nobody ever makes drive-by contributions for Rust projects.
Yet you always have fuckfaces such as yourself creating issues in our bug trackers and posting in our IRC shilling your shitty language, but none of them actually seem to use it.

Rust as a language could've been fine, but the whole thing has been tainted by a cancerous ecosystem.

Attached: 1556988399929.png (270x360, 66K)

enjoy your segfaults and 10000000000000000 lines of spaghetty shitfuckery just to get anything simple done, faggot

btw, I wrote in C,C++,Python, Typescript, Go, JS ES+6 and probably many others for a few weeks max, and I am telling you Rust is the finest language I've ever dealt with

They are planning a stable ABI, but it will come later when a lot of the questions are resolved

Nice strawman, fuckface.
It appears that you are too mentally deficient to even address a single one of my points.

>enjoy your segfaults and 10000000000000000 lines of spaghetty shitfuckery just to get anything simple done, faggot
this is your brain on rust.

whats a package manager? whats a package?

I'm a different poster, but a lot of this is in the works. They didn't do it at first because they didn't need it for Firefox, or plugins for Ruby or PHP

But of course there are other use cases

>static linking means the code is closed source
Where the fuck do these idiots come from?

Fuck off lefty.

Translation from reddirtlish: It will never happen.

I think rust is shit and find rustniggers obnoxious, but there is nothing static linking.

nothing wrong with static linking*

I didn't say that, idiot. It's just that static linking is only really desirable to proprietary fags.
They don't want to make use of different libraries and possibly have to recompile their code if any library changes. They want to keep it all under wraps and control it themselves.
It's an extremely selfish thing to enforce.

Now imagine a distro like debian, with like 20,000 packges or whatever the fuck it's at currently. Imagine if everything was statically linked, and then libc was updated.
You would have to recompile almost fucking everything. Do you know how long that would take?
Do you think that most people have multiple data-centres worth of computing power to throw at such stupid shit?
Static linking does not scale, and only makes sense if you're only focusing on a single program.

Attached: 1393203971183.png (340x370, 136K)

So, you don't like it?

rust is so goddamn ugly and this is coming from a sepples programmer

>static linking is only really desirable to proprietary fags
dynamic linking is totally irrelevant in 2019 unless in embedded systems maybe, get a job, cfag

Good job not addressing any of my points.
I guess you got blown the fuck out and have absolutely no arguments.

Dynamic linking has its own problems, like binary compatibility, limited optimisation, and the performance cost of making calls to dynamic libraries.

>>Now imagine a distro like debian, with like 20,000 packges or whatever the fuck it's at currently. Imagine if everything was statically linked, and then libc was updated.
And nothing will change. Everything will still work just fine.

you're asking nonquestions with non arguments and then accusing whoever exposes you as brainlet. typical NEET cfag

It's an important security update. Everything needs to be updated to use the new version.
But even if it wasn't important, then you're now tracking N^M packages, and you need to keep track of what dependency version that everything is compiled against, and makes bug-reporting and reproducing a fucking nightmare.

>Now imagine a distro like debian, with like 20,000 packges or whatever the fuck it's at currently. Imagine if everything was statically linked, and then libc was updated.
>You would have to recompile almost fucking everything. Do you know how long that would take?
You then have to guarantee that the updated library didn't break anything in those 20,000 packages as a side effect, which is actually more work. Where as with static linking each program can be rebuilt when it is guaranteed to be compatible, or opt to stay at a previous version if there is a regression.

How often do you get "important security updates" in the fucking libc? A rhetorical question.
>and you need to keep track of what dependency version that everything is compiled against, and makes bug-reporting and reproducing a fucking nightmare.
If only we could use computers for that, oh wait.

Libraries normally take their own ABI stability quite seriously. It's largely a solved issue.
If I library makes an incompatible change (usually is a new major version), you may have two versions of the library during a transition period.
e.g. debian has libssl1.1 and libssl1.0.2

>It's just that static linking is only really desirable to proprietary fags.
Or people that want performance

ok?

so the acceptable alternative is to potentially break many packages when an update occurs because the authors never tested their code with the new version before it was pushed out?

build and package management systems are designed to handle tracking dependencies and the better ones also try to automatically resolve version conflicts when this become complicated.

Often enough that you can't constantly throw literally years worth of compute time at the problem.
There are many more "important" libraries than just libc.

You are really undermining your whole anti-rust argument with that static-linking phobia.
Static linking is not a real issue.

>when your linux install count is higher than your lines of code written

This. Actually dynamic linking is totally harmful. Dynamic linking was invented back when RAM was so restricted, it's totally irrelevant and introduces lots of unneeded problems.

That's a pretty naive assumption. The transition period can be years between different distros and operating systems, and some platforms may never be updated.
The ABI is only part of compatibility, unspecified aspects, like performance or side effects, can also change which may break your program and prevent you from updating in the short term or ever.

The point is that Rust/cargo forces you to statically link everything.
For a language that plays in the same space as C, that's just not fucking acceptable.

Cargo is trash, but not because of static links.
It's trash because it enables retarded webnigger mentality of "don't write it yourself, just use a library". And that is how you end up with completely idiotic shit like "is-even".

This. Rust actually executes faster than C in most cases since it got many based 0-cost optimizations like based iter()

It's fine, we have the space to statically link everything and doing so provides real performance benefits.
Dynamic libraries require the linker and interpreter to do alot of extra work at runtime to lookup the necessary symbols and load them as needed. Using dynamic libraries also prevents some optimisations at compile time.
For most applications and libraries there is no need to use dynamic linking. The big exception being for when you actively want to replace a standard library with your own at runtime, that is a very niche use which most applications never need.

please GTFO, I am done with your autistic nonsense.

Take your meds, tranny.

Yes, I agree with the retarded micro-dependency faggotry.
But it seems a lot of people really don't understand the advantages of dynamic linking, despite the shortcomings it has.
There is a reason that basically every major Linux distro does it, and even distros like Arch don't even supply static libraries at all.

Attached: 1375773299400.jpg (425x419, 19K)

>and even distros like Arch don't even supply static libraries at all.
I fucking hate this, it makes working with Haskell a pain in the ass. You are forced to use Stack because the provided libraries are rarely compatible with anything you want.