ITT: explain what you have against Rust WITHOUT (and this is going to be extremely difficult for some of you):

ITT: explain what you have against Rust WITHOUT (and this is going to be extremely difficult for some of you):

>SJW / feminists / nu-males, etc...
>the community
>meme language

and go

Other urls found in this thread:

aturon.github.io/blog/2016/08/11/futures/
katecpp.github.io/rustlang/
cantrip.org/rust-vs-c .html
spin.atomicobject.com/2016/04/26/swift-long-compile-time/
quora.com/Concurrency-computer-science-Should-I-use-Go-Erlang-or-Elixir-for-a-mobile-app-backend
doc.rust-lang.org/stable/book/
rustbyexample.com/
twitter.com/SFWRedditImages

are these not enough reasons?

no

corroded language

Too young.

I love the ideas behind it and the feature set but it's too ML-ish for my taste

It's not Haskell.

I don't have anything particularly against it, but I don't really enjoy writing in it for some of the same reasons I don't really like Java.

The language enforces tons of rules and restrictions, which is understandable because it's doing so to guarantee safety, but it's annoying. There's nothing unique about the language other than that set of restrictions meant to stop you from shooting yourself in the foot, and it annoyingly gets in the way when I know what I intend to do with something better than the compiler does.

You can get the same effect by slapping a whole bunch of restrictions onto a C compiler.

unsafe {

}

No community compared to other languages.

It doesn't yet have a "secure" flag for generating code that zeroises a variable on destruction but also applies that to all intermediates or temporary copies. Partly because LLVM doesn't have that capability yet.

So I have to use assembly to handle things which won't play sensitive data onto the stack (nothing I can do about CPU-internal register renaming).

It's no worse than any other high level language in that regard however.

Syntax is a bit meh.

I'll use it.

Then why bother with rust at all?

You're like those people who respond to complaints about Go's lack of generics with a recommendation to use interface{} everywhere and basically bypass the type system entirely. Why are you using a language if you have to work around its major design choices?

Psh, everyone on Sup Forums knows that the only programming languages acceptable to learn are C, Lisp, Algol, and Haskell. Basically, if your programming language doesn't require a PhD in math, soldering cpu buses, and was made after 1975 it's a "meme language" and not worth your time.

Don't tell me you've ACTUALLY been taking advice from Sup Forums have you user? They're memeing you, that's why they hate rust. For the maymays

nothing really. i just dont understand why everyone has to make their own language now.

memory management is kek

just use GCs, it's not 1970 anymore

NOOO WHAT ARE YOU SAYING!

Gcs are worst evil in this world you might as well use java! And performance, man, even highest end computers cant handle average programs with gc, dont get me started on vms and huge ram overhead.

Use your gc language on an embedded device or real time system like a missile guidance system

Those areas use C or C++ nobody uses rust for that. If you need embedded you use C otherwise might as well make it easy for yourself and use language with GC unless you do AAA games then there is C++

Why not just use C instead?

>Those areas use C or C++ nobody uses rust for that.
Yet.

Rust WILL be used when it's ready, as it's way safer than C/C++ and just as fast.

All the libraries are written for C/C++ and I don't want my code to pay FFI overhead.

Langauges are just Tools..

20 years ago everybody builded Frameworks, but nowadays people are often tired of the shit you find in the "industry languages".

Also it's a kind of Evolution, it's not like new languages do things completely different. There's a lot of repition especially at the syntax.

The differneces are more about the language features (what you can do and - even more important - what you CAN'T do).

If you are a Develloper with some years of Java and C experience you will pick up Go in a few days to weeks..

That's also the reason why modern langauges often complete so much (i.e. Rust and Swift): they are designd for very specific purposes, not "one size fits all"-langauges like Java or C++.

The missile knows where it is at all times. It knows this because it knows where it isn't. By subtracting where it is from where it isn't, or where it isn't from where it is (whichever is greater), it obtains a difference, or deviation. The guidance subsystem uses deviations to generate corrective commands to drive the missile from a position where it is to a position where it isn't, and arriving at a position where it wasn't, it now is. Consequently, the position where it is, is now the position that it wasn't, and it follows that the position that it was, is now the position that it isn't.
In the event that the position that it is in is not the position that it wasn't, the system has acquired a variation, the variation being the difference between where the missile is, and where it wasn't. If variation is considered to be a significant factor, it too may be corrected by the GEA. However, the missile must also know where it was.

The missile guidance computer scenario works as follows. Because a variation has modified some of the information the missile has obtained, it is not sure just where it is. However, it is sure where it isn't, within reason, and it knows where it was. It now subtracts where it should be from where it wasn't, or vice-versa, and by differentiating this from the algebraic sum of where it shouldn't be, and where it was, it is able to obtain the deviation and its variation, which is called error.

There's no overhead from Rust/C FFI.

>yet
okay maybe in future but till then there is no reason is there?

just RAII shit out of everything in C++ and its pretty safe or use c++14

I have seen this pasta before..

>just RAII shit out of everything in C++ and its pretty safe
C++fags, everyone.

Well it adresses unsafety issue somewhat doesnt it?
Besides for low level embedded stuff u need to use unsafe in rust anyhow so no point in using it, might as well use C if you hate C++

No easily usable cross-platform GUI library
QtQuick does not count

You're not fooling anyone, Rust semantics are different from C, this isn't like C++ where exactly the same code will compile.

even if there is no function call overhead there is data type transformation overhead so you in fact do have overhead.

Because making JavaScript framework was cool two years ago

Having an SJW community behind it is enough reason to not use it.

>make an awesome framework/library in rust
>"OH WOW user'S SUCCESS IS DUE TO THE AMAZING LANGUAGE MADE BY SJWs! SEE GUISE? SJWs ARE THE COOL KIDS IN TOWN :^)"
nope, fuck yourselves

>and go
Go is just fine. I don't see why people compare them.

Yep i agree Go is great at what it does and actually has a purpose and great standard library. Sane syntax, fast compile and its speedy enough. While rust barely has any libraries and if you want something proper u have to compile C as well...

>Boycott X because bigots use it!
>Boycott Y because SJWs use it!
You people are no different from SJWs.

aturon.github.io/blog/2016/08/11/futures/

What other languages have zero-cost futures?

Seriously. I have never seen a group of people get more triggered than those that are afraid of "SJWs"

c++ ??

But Go is boring. It's like the overlap of the most common langauges. Sure, it has an easy syntax, but it has no powerfull features. It's basically "C for Pajeets". Mark my words, Google will attract even more low cost devellopers with Go.

Rust on the other hand has some real interesting features and concepts. People really put some effort in to think about a way to make C a better langauge.

Futures are a meme.

Really? Find me a C++ concurrency library that does no allocations.

great argument bro

>get a runtime error which is clearly linked to memory unsafety
>debug 10,000 lines of code in unsafe{ } instead of the 100,000 lines of code youur whole project contains
and 10% unsafe ist something I would only very rarely expect any project to have, unless it's something like computer graphics where you can't easily avoid dangling pointers without performance loss

Okay maybe boring and easy but there is nothing wrong with that. Let me give u an example i use dwm and i wanted to have random wallpaper every hour so as good guy i wrote it in C and added random image downloading as well with curl. It took me quite a bit to fix all quirks and parsing returned html was a pain so i basically used some dirty hack. I decided to check out GO couple of days ago and rewrote that program within 20 minutes of first touching the language and its shorter with no hacks and easily extendible. Compiled binary is bit too large but there is no cpu usage at all which is all that matters.
I think of GO as compiled python with sane syntax, i hate python so much.... Its good general purpose language.

While rust its like not as bloated little C++ brother with not as weird but still weird syntax and significant learning curve but not as high. It provides memory safety but lacks libraries. I really cant see it being used anywhere other than some nieche.

or no reason why not just use c++14 for safety if C is unsafe

I'm not saying Go is bad.

I just want to point out that you can't really compare those two. Go is like "hey, let's make a simple langauge without bells and whistles that anyone can use." Rust is like "hey, lets spend some years to think about the best possible way to create a langauge that could replace C".

It's just a differnt design purpose.

aah okay, why rust over C++14?

1. Safety
2. If you prefer functional style to OOP

>hey, lets spend some years to think about the best possible way to create a langauge that could replace C
Well, they failed. Maybe they should have tried improving C instead.

1) You do get safety with RAII
2) You can whack up some functional kind of c++
okay i agree with 2)

Good point

It has a weird syntax. The if or switch clause described in the book felt alien, I could never really get into it. I've tried.

Also can I now declare a python-esque dictionary on compile time? I wanted some sort of O(1) access to known values in something that wasn't a bunch of variables.

Productivity. Not that it matters in the fields where Rust should be used (crypto, high performance, ...) but that's what I personally have against it. I'd rather write my code quickly and refactor a bit later than having to care about traits, ownership, etc.

Thatt's pattern matching, from functional languages. Look it up.

Well' Im not a C++ guy, so just two liks:

>katecpp.github.io/rustlang/

>cantrip.org/rust-vs-c .html

At the end of the day, it just a matter of what you like. If you are super familiar with C++ and like the way C++ does things - hey, good for you!

But if you would like a small and more readable language, maybe you should look into Rust.

Lots of overhead, without any real revolutionary changes. Literally the same as C with snippets and a dash of static analysis. It's not great, it's not bad, who gives a shit. Consistency is more important, so let's stop with all the new dumb languages. Okay?

So can I use that with strings to find regex?

Different concept. Look up functional pattern matching.

Nothing. Haven't tried it yet, so don't have an opinion.

How does Swift compare to Rust? Swift has its own safety features too.

swift is garbagio bro

Immature.

I'm okay with Rust's size and overhead for the most part but I don't understand linking in jemalloc by default. System allocators are good for 99% of the people programming and people not fine with it will use their own custom allocators.

There's also the fact that the syntax is way too verbose at times and trying to use it like C with unsafe is worse than using C itself with how much undefined behavior is involved.

That being said, it's still an impressive language.

So conclusion is that while rust provides some benefits over C it lacks libraries and has to bind to unsafe code for pretty much anything.It doesnt provide anyhing over C++14 which is one of most used languages with bunch load of libraries except personal taste of syntax.

Why?

Its useless for anything outside of OSX and apple sphere

Supposedly, you can get the exact same benefits in C++ with static analysis.

>just as fast
(citation needed)

I have nothing against Rust, I think it is a fine language.

No. Look up borrow checking.

Yes. It will take time but I only see Rust displacing C++ if the proposed Core Guidelines are very deficient in scope which is not the case.

Even if it's 'good enough', people won't switch.

how borrow checking more memory safe than std::unique_ptr ?

just is bro

[citation needed]

spin.atomicobject.com/2016/04/26/swift-long-compile-time/

People also forget that Rust makes concurrency easier and safer than c++ (no data races).

>but it has no powerfull features.
go fuck_yourself()

>inb4 haskell/literallywho/malbolge also have an equivalent to goroutines and channels
But none of these are as convenient to use.

ur butt isn't convenient to use but it sure gets rammed by beefy bara men all day

That's out of date. It's fixed.

Yes, but this doesn't invalidate my argument.

seriously swift?
Lets just use ruby for embedded systems!
in what way is it better than java or c# or whatever?

>You do get safety with RAII
You don't.
Unless you don't get raped by the compiler with checks, it isn't safe.
RAII in C++ is a comfort feature, not a security one.

explain?

uniqe_ptr = something

when do i get memory leak?

>There's also the fact that the syntax is way too verbose at times
This is the big thing for me. I don't want my code to look like
.unwrap().unwrap().unwrap().unwrap().unwrap()

Rust doesn't have anything like C unions.

You forgot about assembly.

Rust is a language for nigger cattle.

>But none of these are as convenient to use.

Go? Serisouly?

>Not extensible.
>A crash (unhandled panic) of goroutine crashes the entire system. A whole system may halt due to an individual bug.
>There is shared memory in Go. Hence, if one goroutine crashes, even if you catch the panic, it might leave some permanent in-memory junk i.e. corrupt data that will compromise other parts of the system.
>It's impossible to unconditionally terminate a goroutine. You can do something manually, but this amounts to sending a message "please kill yourself", and hoping this will happen. If due to some bug, you have a goroutine that ends up in a tight CPU bound loop, you can't possibly stop it, and it will waste your resources forever.

Rather use Elixir, it is superior in every single way:
-> It's purely functional
-> Super nice syntax
-> amazingly scalable
-> the most fault-tolerant langaue you'll find (since it's running an Erlang VM)
-> up to 10x faster than Go:
>quora.com/Concurrency-computer-science-Should-I-use-Go-Erlang-or-Elixir-for-a-mobile-app-backend


Elixir is love, Elixir is life..

>up to 10x faster than Go

Sorry, didn't read that correctly..

It was up to 10 times faster than Ruby, but still twice as fast as Go.

1)Does it have as many learning resources and libraries?
2)It requires learning new paradigm which is much slower hence its more expensive ($man hours > cpu hours)
3)Is it as productive? refer to 2)

Good! Reverse SJWs will save the White race.

but seriously it looks like neat language i want it to have good learningresources
what IDE you use for it?

Get off Sup Forums Terry

Isn't the community one of the most important parts of a programming language?

If you forget to do that or have some other asswhipe smuggle a new or malloc into the companies codebase. Or if you somehow fuck up the custom deleter you need all the time, because you need C libraries half the time, because C++ isn't great for libraries.

isnt that also true for rust?

Well Rust can't be any better than C++, so I'm sure the same mistakes are possible in Rust as in C++.

1) doc.rust-lang.org/stable/book/
rustbyexample.com/

I was talking about elixir haha