Rust vs Go

...

...

u havin a giggle m8?

>>>/out/

Acme actually is pretty good if you learn to use it. But how some stuff are done is utterly autistic, e.g Delete key inserting a litereral delete character instead of deleting a character.

>not controlled by a (((corporation)))

Any language is shit until it has a reflexive programming environment, like Pharo does. Smalltalk fucking sucks unfortunately

Why are 9fags so fucking weird

python has already won

everything approved by cat-v is featureless tbh

features are harmful

Jai will crush them both

...

...

So I can write kernel modules in python now?

...

Only in Lua, on NetBSD.

Yes. github.com/avielw/kplugs

Sample Rust code:
let mut ;;>x890 [map[]] as bool{}::func ()
Sample Go code:
func is_go_nice() bool { return true}

fn is_rust_nice() -> bool { true}fn does_rust_have_generics() -> bool { true}

implicit return was a mistake

It's not implicit, the lack of a semicolon makes it a return statement.

there is very little implicit stuff in rust. one reason why it is so verbose is because rust explicitly makes a lot of stuff explicit.

rust in a nutshell

what is implicit typing? can you provide an example?

It's like if you write var a = 4, var b = 4.0, then the compiler automatically infers a to be an int and b to be a float. The language is still statically typed, because a and b can't change their types, but you don't have to explicitly declare the type.

thats type inference you mouthbreather

that is very offensive

Where is the type? Is it explicitly declared? No? Then it is implicit. Now fuck off.

read a book, LARPer

docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/implicitly-typed-local-variables

They're the same thing.

I feel like Go is the next Pajeet Language.

All you need to know about Rust in one picture

Pajeets plague languages with a certification system and strong corporate backing. So probably no.

If you're unwrapping then you're doing it wrong.

Having to match Ok(x) => {}, Err(e) => {} on literally every variable is even worse. They should just add exceptions at that point.

This is what monadic bind is for, you're not supposed to check everything on every turn.

Look it up, it's good shit. Some people call it "railway oriented programming".

Oh boy another "which poisonous identity politics cult will win" thread

That's what we have the '?' operator for, it passes the error up to the stack so that you can handle it wherever you want, except without the whole, blow up the stack on the way, thing that exceptions have.

D is better than both, garbage collector is optional

*.unwrap()s dick*

this is horse shit.
D is worthless without GC which makes it not qualified as a C replacement, and GC implementation is shit, so it might be not even better than Java performance-wise.

Except almost all libraries depend on GC

basically, at least read about "try" macro before shitposting

these codes are not even close to being equivalent, and the first one — I'm not sure if it is even correct

well done user

also, Go can't go without GC, so it has nothing to say in the areas where this matters (hard-realtime tasks for example)

you don't need to turn GC off if you're Google scale. Nice try, smallfry, but you'll always be small with that attitude.

At least it's not run by commie trannies.

I already have. The Rust Handbook, to be more specific, unlike you.

wiki.c2.com/?ImplicitTyping

Faggot.

read a book then hang yourself, moron

go:
if err != nil { return err}

rust:
this_might_fail()?

literally like java but without generics

of course the "just dont write memory unsafe c/c++ code" cult

use std::io::{self,Write};fn line_flush(line:&str){ let mut stdout = io::stdout(); let mut handle = stdout.lock(); write!(handle,"{}",line); handle.flush().unwrap();}fn parse_input(x:String) -> f32{ x.trim().parse::().unwrap()/2.0}fn main(){ let stdin = io::stdin(); let mut x = String::new(); let mut y = String::new(); line_flush("Enter a new float number: "); stdin.read_line(&mut x); line_flush("Enter a new float number: "); stdin.read_line(&mut y); println!("{},{}",parse_input(x),parse_input(y));}

i made a better one:
use std::io::{self, BufRead};fn main() { let stdin = io::stdin(); let mut stdin = stdin.lock(); let mut input = String::new(); for _ in 0..2 { input.clear(); stdin.read_line(&mut input).expect("reading from stdin failed"); let number: f64 = input.parse().expect("input is not a floating point number"); println!("{}", number / 2.0); }}

Because everyone hates Rustcucks, even other cucks.

Not an argument
brainfuck is also not run by them, will you do your next project in brainfuck?

Being run by commie trannies automatically excludes a language so D or brainfuck are thus likely to be a better choice. His argument is valid, tranny.

I'd rather use a tranny language than a language used by a bunch of racist bigots

...

You can't be racist against whites

weak bait, 0/10 apply yourself

Is there a language run by racist bigots? Asking for a friend.

geekfeminism.wikia.com/wiki/Ceylon_code_of_conduct

Urbit/Hoon/Nock.

You won't get one.

Too many hungry neckbeards thirsting and putting that pussy on the pedastel.

And with meat flaps comes SJWism, the ultimate test of whether you can cut through the bullshit.

Welcome to programming and cuckputer science - autism edition.

Keep your heads high, fellow Anons.

We're all gonna make it.

...

Fuck you.

I enjoy reading properly spaced text and not a wall-of-spiel.

kill yourself. if you want huge empty space between lines consider editing the css line-height property.

> being this much of a cuck

If it spites Rustcucks, I don't see why not. Might be fun.

not

an

argument

Nobody would even know about it, because you can't do it. calm down.

rustcucks are here to help you: github.com/Wilfred/bfc

let mut stdout = io::stdout(); let mut handle = stdout.lock();

Oh my god are you kidding me

what is the problem? give some details and i will help you out.

He's upset that he has to lock stdin by hand instead of just letting libc do it for him.

you actually dont have to do it yourself.
my version works just fine if you remove the let mut stdin = stdin.lock() part.

Properly spaced is two spaces after each period, not two linebreaks you fucktard.

Hi, Stallman.

Go could win, but it has to overcome it's autism first.

I was starting to advocate Rust unironically, since it seemed right academically.
I read the full docs 3-4 times, understood the generals of the language, and decided to apply myself.

I tried doing the simplest thing, taking a filename from the cli (using clap) and then hashing it, and printing the output to the console.

This took me the better part of two days, with zero progress.
EVERYTHING is extraordinarily implicit. There are so many hidden pitfalls, errors, and traps that you can't possibly plan ahead for.
If Rust wants any chance at succeeding, they're going to have to make their language easier to use.

On the other hand, I just picked up Go last week for shits and giggles, and ended up becoming a halfway mediocre programmer in 3 days.
If only they weren't so stupid (eg., owned by Google), they would have a legitimate chance.

Explicit return was a mistake. It's a much less natural way to think about and structure functions.

Incorrect, I'm afraid.
rustbyexample.com/fn.html

no. quite the opposite.

there is literally nothing implicit going on there. not even type inference
oh i see you are retarded

*inhales*
HA
HA
HA
HA
HAAAA

...

this

let pwnage = [0; 1];unsafe { pwnage.get_unchecked(); }

rust is full of SJWs and created by a ultra-sjw

go is created by a pro-woman SJW

Why?

All I have found is a weak signaling for t-shirt sellers like this
Which is sad of course, but not really comparable to Rust faggotory.
Rob Pike seemed to be a right leaning libertarian for me before.

Wouldn't surprise me. I imagine if you are dealing with the big Alphabet you have to pick your poison when it comes to virtue signaling. Celebrating chicks who use your language is far from the end of the world.

Small compromises like this are how they corrupt your mind.
Never surrender, never accept even the slightest whiff of degeneracy - remember, there should be NO gender-based propaganda or discrimination, none whatsoever.

(unless if benefits men, of course. Then it's the rightful retribution for years of injustice wrought on the industry by blue-haired braindead harpies.)

I'd argue it is dangerous to one's sanity to allow small compromises across many non actors like this to all add up to one amorphous monster. The reality of the situation is not so dire, though I agree there needs to be continued pushback against propaganda tactics like this.

Either way the comparison is between Rust and Go when there should really be no comparison. Rust is completely contaminated with cuckoldry.

That's the entire point, they need something piss easy so their army of pajeets won't be able to screw shit up every second line of code.

...

Rust will go down in history as an utter joke, and probably Go too.

Plan9 was meant to be run basically like a thin client with all the storage and processing elsewhere.
This shit is why it frustrates me that the people with the best design philosophy are complete fuckwits about politics and user freedom, and vice versa.

thin client is cancer m8