Is there any reason to dislike this language other than an irrational distaste for hipsterdom or the "SJW" bogeyman?

Mind showing me the leaks in sel4 then?

>mem leaks are an integral part of C
lol

>Actually better than previous versions of firefox.
Call me back when they fuck off webextensions and bring back the old plugin framework so that all my plugins actually work again.

That's not a rust problem.

Why is Jow Forums so much fucking retarded they can't even follow a straight line dialog?.

What would be the more promising language to learn between Rust and OCaml? Rust obviously isn't anywhere near as prominent in industry at the moment but it is the trendy one and is a bit more low-level, meaning it has the potential to reach much greater levels of adoption.

In a perfect world, OCaml. In real world, Rust where performance is critical.

How would you implement a linked list in pseudocode

Attached: 1_LORRgjX9DCW3_h4RCY6JIQ.jpg (1500x988, 1.06M)

If performance us critical then why is everything jvm based

I like OCaml better, but Rust is being adopted quickly enough that I expect it to be far more relevant in industry in the near future

why isn't OCaml more popular ;_;

Rust kinda reminds me of 1996 Apple
When Gil Amelio was running the show
The product sucks
The fanboys go around the web
Helplessly trying to convert people to their dying religion

The big difference is, Rust has no Steve Jobs
Brendan Eich certainly isn't coming back to save them
And if they weren't fucked enough
Oracle just rolled out GraalVM+Truffle
Making it super easy to roll your own languages
And programmers will
Because it's easy
And what's left of Rust hype
will drown in the noise
of all the new languages
that aren't going anywhere either
Rust will be relegated to just another JVM language by 2020

>performance isn't critical in fintech
>performance isn't critical in virtualization
>performance isn't critical in data analytics
>performance isn't critical in servers

Attached: Csg1rzFXgAAWR9G.jpg (799x1200, 134K)

>Brendan Eich
Belongs to hell. He's the creator of basedtrash JS that's killing CS

meme constructs for non-cs people to feel smart about using when they don't know how to implement them and it's useless to do anyway

hugbox: the language

>Memory leaks
u wot? Rust goes out of its way to prevent you from accidentally leaking memory. You're certainly much less likely to leak memory using rust than any other equally low level language.
>Can't even write a linked list without unsafe
You can write a singly linked list in safe Rust just fine. A doubly linked list is inherently unsafe, as it requires resources with multiple handles that can be used to modify the resource from two different sources at once. As such, Rust requires you declare a small portion of it unsafe. I don't know how you could possibly see this as an issue, since in most other languages your entire program is treated the same as rust treats unsafe code.
>Garbage IDE choices
I'm sorry your favorite 12GB Java IDE doesn't have Rust integration user. Meanwhile the RLS allows real editors like vim and VSCode to do instant code-checking via lightweight plugins.
>The only major project written in rust (Firefox Quantum) is in an accelerating death spiral
Quantum is responsible for putting Firefox back in the browser wars. You've been living under a rock if you haven't seen all the praise it gets from even average users for being noticeably faster. Mozilla and the majority of Firefox users consider it a massive success.

>first of all why are you writing a foundational data structure and why are you using a foundational data structure
Is this guy for real?

Why

No TECO support for Rust. Fuck em

>foundational data structure
deprecated*
There's no reason to use linked list any more.

If you're writing a linked list from scratch you're an undergrad CS student and therefore have no valid opinion

>linked list
>foundational
Just because we teach it to CS freshmen doesn't mean it's actually useful for anything or the basis of anything important.

Rust is an OCaml dialect, they just don't tell you.

The biggest difference is that they added a bunch of imperative programming specific things so that it is easier to make run fast. The syntax suffer a bit from that, but all the core ideas of Ocaml are still there.

I rather use an actual ML.

Why the fuck would you need other reasons? There's no sense in tolerating such genuinely socio-cancerous behavior when alternatives that don't contribute to the downfall of civilized society exist.

>sml stands for standard meta language
>ml in ocaml stands for machine language

Make me think

Same fag

>happens very rarely. Whereaas mem leaks are an integral part of C.
*p = malloc();

free(p);

was that so hard??????

>lol, what is RedoxOS
A dead project?
OP, Rust is a meme. The SJW bullshit is just a result of it being a worthless language, thus attracting the worst kind of people.
>happens very rarely. Whereaas mem leaks are an integral part of C.
Then you have these faggots who also turn people away from Rust with their retarded ignorance.

>Just because we teach it to CS freshmen doesn't mean it's actually useful for anything or the basis of anything important.
Linked list is immensely useful and is usually embedded into a complex data structure.

Face it, Rust is only useful if you're developing canonical shit or relying on "big daddy" to write you "unsafe code" which Rust can't fucking test.

Meanwhile you can write "unsafe code" in C and have a formal tool test your code in every possible case.

>more low level
>only compiles to LLVM IR
>depends on libc
>fearless bullshitery

lol
If you want low level, there's Go
They reimplemented Assembly for all supported processors
It's Go, all the way down to the metal
Rust is just a bad joke at this point

wow, totally BTFO with that 2 lines of hello world tier code, you are 1337 haxor now
There's a reason RAII killed C.

>Linked list is immensely useful and is usually embedded into a complex data structure.
Which is why you don't have to reinvent the wheel that's already in the fuckken standard, asswipe.

>Go reimplemented Assembly
what?

>replying to gotards

>They reimplemented Assembly
Now implement generics

Don't what me
They did it
The only thing below Go is machine code

youtube.com/watch?v=KINIAgRpkDA

nope

fpbp

Attached: 1518199099507.jpg (480x472, 46K)

Its a language that cant even optimize out multiplication/division by 1 or addition/subtraction of 0.

proof?

godbolt.org/g/UkWFn4

Fake news?

Attached: Screenshot from 2018-04-25 15-16-25.png (2434x678, 109K)

onions

Not that simple with composite connected instances you fucking Rust nigger.

>flogging the dead horse

Seriously fuck you, you're the exact reason we have problems with security because faggots like you demand shitty backwards compatibility for your waifu plugins

Seriously fuck you, you're the exact reason we have problems with security because faggots like you demand rewriting everything every two weeks.

Ummmmmmm just use a framework then when the framework gets rewritten your project still works..????

I'm not even knowledgeable about Rust and I call bullshit on this.

The whole point of it is to take care of memory so you don't have memory leaks, and from what I hear from people who do use it the language is actually solid that way.

>foundational data structure
How's CS 101?

> Failed syntax
> Locked into LLVM
> Too much FP autism
> No major framework written in Rust (No boost, No Qt... Not even an respectable IDE)
> Retarded evangelism
> unsafe block

>nobody writes their own linked lists so nobody should be able to write their own linked lists
>oh yeah ignore all of those library developers :^) they're not important
This is why you will always be a poo in loo.

Only C cucks writes linked list because C doesn't have any standard containers LOL. I bet you don't rewrite printf() because it's already in the standard.

Now suck my cock, faggot.

Ownership and Borrowing.

Compilation Time.

seconded

>you don't need linked lists
>data structures are bad, become a code monkey by memorizing rust stupid syntax
I didn't hate rust before, I hate it now after this post

>all the bugs are the result of the infamous "memory leak"
>ignore all the extremely complex projects written in c that don't have memory leaks and are extremely resilient
>ignore the fact that most bugs are the results of logic errors that can crop up in any language
>spread lies that rust fixes all bugs
WTF RUST

>You're certainly much less likely to leak memory using rust than any other equally low level language
If you think that memory leaks is what's hard about systems/low-level programming I don't want you to do systems/low-level programming
It's just simple accounting, keep or return a reference to what you allocate, make sure you deallocate when are done with it, I don't know why you rust-cultists are making such a fuss about memory leaks
>A doubly linked list is inherently unsafe
If this meme language that makes the programmer jump through hoops for the snake-oil of no-memory-leaks can't implement such a basic data structure as a doubly linked list and has to turn of the "safety" constructs then I'm sorry to say but this is a meme construct

Language itself seems reasonable but I hate the ecosystem. It's like if C was managed by nodejs people.

neat

Forced code formatting, like complaining about struct names not using camelcase. Wouldn't use this pile of shit if I was paid. I want the security features, but I want my code to retain the beauty of C code, and I want to be able to make up my own formatting, thank you very much.

Attached: 1523536563099.png (825x523, 438K)

This
What happened to choice?
Old languages, like C and even Java, don't force a style on you
Is Python to blame for removing the choice for code formatting?

very weird syntax decisions
different syntax for functions and lambdas, implicit captures
borrow checker broken on few edge cases
low portability of compiler toolchain (not llvm part)
cargo is madness
crates.io is shittiest package catalog ever made
tooling is nowhere near Go's guru despite the language heading for deterministic lifetimes

anyway, type system is ok and I like the interfaces for things like operators, contagious ones for copy vs move, deep copy, async safety etc.
I just with there would be OCaml clone that would compile into actually C++-level fast code

And as a result you can't even implement a linked list safely, resulting in memory leaks because rust is a pile of shit.

Give me one actually legit reason to switch to Rust over C++.

>data structures are bad
Didn't day that. Linked lists are bad.
>a code monkey by memorizing rust stupid syntax
Didn't say that either
>I didn't hate rust before, I hate it now after this post
I literally give 0 fucks.

I don't hate any language. They are all feats of human engineering and should be respected. Including Rust.
What people (here at least) hate about Rust is the zealotry of its users. They think Rust should be THE next language you learn and use. When pragmatically speaking it shouldn't be.
I mean, anyone is free to make it their next language if they want to, but for practical purposes you should learn a good portion of these before using Rust (in no particular order):
>C
>C++
>Haskell
>Python
>R
>Scala
>Java
>Lisp
>Lua
>Ruby
>Javascript
>SQL
Rust doesn't really solve any issues, it frankly is reinventing the wheel. It just tries to be super safe low level code. Which, while admirable, doesn't really fit any use case. You're going to have to use unsafe code blocks in Rust for certain things anyways, so might as well use a safe, scalable language (like Scala, Haskell) and then use C for the unsafe parts instead.
Use the best tool for the job, you don't need a swiss army knife of languages to get the "best of both worlds" of safety and low level.
To be fair, Rust isn't completely reinventing the wheel. Go for example brings absolutely nothing new to the table. But the use case for Rust is rather small.

Rust has a progressive CoC that you can shove into your pussy

package management, standard build system, range based containers, language level sum-types (std::visit is a disaster), move semantics (done right), procedural hygienic macros etc

I forgot to mention, it has training wheels so pajeet can code alongside you.

The syntax, my dudes. Only c++ has worse syntax than rust. It's SO FUCKING UGLY.

Make it human readable and don't change every convention there ever was.
Mozilla really just changed everything for the sake of changing. Make it C-like like literally every fucking language ever released and don't invent your own bullshit

C++ has the prettiest syntax in the world though.

Yeah I love breaking function headers onto three lines because they're too long for an 80 col terminal.

>C++ syntax
>ugly
Fuck off niglet
>80 col terminal
It's not 1982 anymore.

80-100 cols is what fits twice on a 1080p screen you twat.

The distaste for hipsterdom is not irrational and "SJW" is not a bogeyman,if these two reasons are not enough the fact that it's meme language #325 and it's shilled like the perfect language second to none should do it.

Not that the """sjw""" bullshit about Rust is even true, but if it was, how the hell would it affect you as a user of the language?

Ah yeah, my bad.

I completely forgot how intuitive std::cout actually is. Which languages would even call it something stupid and meaningless like print. None probably

>using std::cout as an example
>not mentioning mad initialization syntax rules
>or plain stupid APIs in STL

Just took hello world as an example. That's where people experience the ugliness of the language for the first time.

>in rust writing a linked list is something that can result in a memory leak
>meanwhile in c++ writing literally anything can result in a memory leak
>this makes rust bad

>Not that the """sjw""" bullshit about Rust is even true, but if it was, how the hell would it affect you as a user of the language?
Rust shills are always gas lighting.
archive.is/BtDaA

Attached: Screenshot_20180425_075047.png (626x1089, 83K)

What makes rust bad is that it doesn't offer much benefit over C++ and it doesn't offer *any* benefit over C since your code will be sprinkled with unsafe blocks as soon as you want to do something useful.
I'm still waiting for anyone to find memory leak in sel4, as well as anyone proving his Rust fizzbuzz doesn't have memory leak.

Holy fuck, I love comrade Steve even more now. Brb, gonna learn rust

cland will get RTS soon thanks to apple

>anyone proving his Rust fizzbuzz doesn't have memory leak
How do you even leak memory from a program that doesn't involve dynamic allocation?

It offers an enormous benefit over C++. The standard library is coherent. The type system is sane. Generics don't spit out two screens worth of error messages when you fuck up. Macros are better. There's an actual fucking package manager.
There are no good free tools to statically verify C++ code.

>your code will be sprinkled with unsafe blocks as soon as you want to do something useful
If I remember correctly rustc has just over 1% unsafe code and most of it are llvm bindings. If you get a memory related bug you know exactly where to look.

>sel4
Nobody wants to write C. Especially not the statically verifiable subset of C.

its just an abstraction layer like a lot of modern languages, nothing wrong with some abstraction but creating entirely language for it and then shilling it for every project is retarded, it lowers the quality of code and promotes bad habits and encourages bad incapable programmers to stay in the field and move onto something more appropriate like "african philosophy"

The devs are a bunch of smut fucks that didnt even know Ada while trying to take a part of the market dominated by it. Just that should tell you about the quality of the language.

>encourages bad incapable programmers to stay in the field
It literally weeds out bad programmers and sends them back to languages like Java and C++ because they can't figure out lifetimes archive.is/H8hEA