Rust vs. go

rust vs. go
Debate!

Other urls found in this thread:

crates.io/crates
github.com/redox-os/redox
github.com/dpc/mioco
rustbyexample.com/std_misc/channels.html
talks.golang.org/2012/splash.article
channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/From-Parallel-to-Concurrent
twitter.com/AnonBabble

Debate!

>go
solution to a common problem
>rust
solution looking for problem

rust > go

Rust, obviously.

Apples.

Differe't languages for different purposes. Delete your thread

Explain

delet yourself

lol no generics

>solution to a common problem
And what problem is that?

Rust no libs
Go many libs
Go figure

>Rust no libs
crates.io/crates

Too much working code.

Barely any useful crates

>lol no generics
It doesnt have exceptions either, its a meme language, stop using meme languages and just use C++

Both are memes. Also yeah, different purposes. In my opinion i'd prefer Go.

Let rust = gay

Comparing Rust to Go is like comparing C++ to Python

rust could get interesting, go is not and will be dead after rob pike gets bored and googlers move to the next meme language

> Go
I'm waiting for dep
> Rust
I'm waiting for const generics and non-lexical borrowk

go is the solution for the problem of people being too dumb to use rust

kek

Nice false-flagging

you are fake news

>apples
Wrong

>eating fucking oranges
>literally such a pleb """fruit""" that they just named it after a color because it isn't worth its own name
end yourself

>non-lexical borrowk
It's called Rc and Mutex.

They're both garbage but Rust at least isn't fucking Go.

Except those are both at least decent.

> Apples
They're ok, I can't eat them though, my throat get's itchy.
> Oranges
It's not even edible! Whenever I try to take a bite I end up with with this nasty skin in my teeth and it squirts this sour stuff everywhere.

>C++
>Decent
>Python
>Decent
Fuck off, rajapajeet

C++ is fucking great, and Python at least works. Pajeets use Java/JS.

>C++ is fucking great
C++ is a hacked together language, a true abomination. It could be much better if it were to get rid of source-level compatibility with C but no
Enjoy 3 stdlibs, 2 arrays, 2 strings, and hundreds of corner cases but no modules

Both are great for their purpose and widely used in serious projects.
Not many others can say the same thing, except for C.

C++ was great because it introduced some low cost abstraction. Which is okay but nowadays C++ is literally two whole different language hosted by a same compiler.

>2 strings
And both of them are wrong.
>2017
>characters are one byte

go is for software engineers
rust is for script kiddies
that's all there is to it

Go is literally for Pajeets to stupid to use Java.
Rust is a nice safe but efficient alternative to C/C++.

More like
>Rust
Solution to a problem that nobody gives a fuck about fixing

Then why do they invent stuff like Address and Thread Sanitizers? People do care, they're just doing it wrong.

LOL

>insert highly region-specific meme here

Orange
>Pulpy
>Delicious
>Comes pre-sliced for easy snacking

Apple
>Are you even fucking trying?

Exceptions are shit, literally hidden execution paths.
Returning an error code is better. Returning a tagged union of the value and an error is ideal.

>O(n) indexing

Docker was written in Go. This one fact almost guarantees that Go will win in almost any "language war".

Yea, no one really cares about race conditions or other safety issues when programming.

nigga why can't apples and orange be compared

>not knowing it's the other way round

>not making your own C parser and using the cool features that modern languages have

>gimmicky container manager
Rust heavy hitters:

redoxOS
dropbox's clustered petabyte filesytem
tor
firefox

/thread

The one in which you can write an OS
github.com/redox-os/redox

training wheels language for retards who feel smart using a stupidly opinionated language

>in Google we hire the best of the best
>except they can't code

>Apple
Many flavours
Easy to eat
>Oranges
Not even the juice is healthy
Binary flavours: disgusting or OK
Not a grapefruit

The one that can implement circular linked lists in a reasonable number of lines.

Rust is pretty much a better OCaml, with a hardcore system focus.

Go is what Java should've been.

No, Go is just C with GC.

Kotlin is what Java should have been.

Kotlin is an ugly piece of shit that fixes nothing because it can't.

I mean, linked lists can have poor memory safety and rust is generic enough that it's like, might as well use some crate.

I can also bet that C++ implements them in fewer lines of code than Go...but does that make it better?

I don't think either reinventing wheels or purely concise syntax is a good measure of any language.

Gofag here
Both have their uses and pitfalls.
Rust is probably the better one. I wish it had something like goroutines and channels but it doesn't really matter.

Pre-1.0 rust had green threads. Also: github.com/dpc/mioco

Rust does have channels.
rustbyexample.com/std_misc/channels.html

which one do you think will be more prominent in malware?

That noise, though.

Go makes compiling for various target platforms really easy but static linking is pretty shitty if you want to distribute malware.

I don't know what kind of advantages rust's safety would grant a malware distributor.

You're an absolute fucking idiot.

fuck google

Rust when you'd use C
C++ for highly-technical softwares (neural network, designing graphic cards, etc)
go for the rest

Why not Rust/C for highly-technical software?

C for OS and Drivers
C++ for performance intensive applications
Go for everything else.

Rust is also statically linked by default. Also, Rust isn't really that portable so to speak since it relies on a few assumptions about the hardware for safety and all that.

>a few assumptions about the hardware for safety and all that
Rust's safety is all done at compile time, it requires no hardware support.

No, but the compiler ensure there is no undefined behavior. For instance, Rust assumes twos complement for signed integers so an overflow will repeat back on itself, while in C and overflow is undefined behavior since there is no assumption about how signed integers are stored.

I'd say they both sought more problems than they solved. At least go is somewhat pleasant to work with though. Rust is just the people's comintern of overwrought ideological design techniques.

...

>Go for everything else.
>if err != nil { return err }
>if err != nil { return err }
>if err != nil { return err }
>if err != nil { return err }
>if err != nil { return err }
>if err != nil { return err }

>C++ for performance intensive applications
its the C++ (((((performance))))) meme
>oooh oooh, its faster bcuz Im mangaging the (((hardware memory))) myself

No, it's faster because it has decades worth of optimizations made for it.

you're retarded

Why is this so different from using try/catch?

...

if err != nil { return err }

Exception handling has no overhead if no exception is thrown and it doesn't require you to manually propagate it.

Source?

Brainlet

talks.golang.org/2012/splash.article
ctrl+f radical

Well, it's a low-level language after all.

>Orange
Juicy
Easy to peel
Event he peels are good for cooking
Strong pleasant smell
>Apple
Literally horse food

Thank you :)

So you people hate Go because its error model uses two more instructions than necessary in the even that no error occurs?

Would you feel better if you found out that the Go compiler locates all err != nil statements and transforms them into zero cost error handling?

no. not having wasteful error handling statements bloating the source is better

channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/From-Parallel-to-Concurrent
The exact quote from is somewhere in this video.

>Would you feel better if you found out that the Go compiler locates all err != nil statements and transforms them into zero cost error handling
No because I'd still have to write all of them myself. I don't need to write a catch in every function leading up to where I actually want to handle the exception.

>tfw you try to fit in with edgy contrarianism but out yourself as a flaming retard instead

Go's error handling doesn't take any more source code than a try/catch
And if it did take marginally more, that wouldn't be anywhere near sufficient to dismiss to the entire language.

You need an if err != nil in EVERY function. With exceptions you need a throw and a catch, only once, or only as many times as there are places where you're handling exceptions.

>that wouldn't be anywhere near sufficient to dismiss to the entire language
It's too simple and that makes it too verbose and hard to read. Even the simplest operations require you to write a for loop.
A reasonable language has "find_first_of(thing, iterable)" instead of "for i, x := range iterable { if x == thing { save the index and break } }"

>>not knowing it's the other way round
>round
>like the orange itself

> Ugly as shit
Here's your (You), buddy.

> Fixes nothing because it can't
Oh right. Adding reified generics, a null aware type system, extension functions, sealed classes, data classes, et cetera, doesn't fix anything wrong with Java. My bad.

Kotlin is a meme language for pajeets that want a swift like language to do mobile apps. Scala is here to stay.

If you have to type that a lot, you're doing it wrong. Errors are values. Start programming.