Find one (1) flaw without resorting to "SJW"

>>58428899
MUH JERBS!

logo looks ugly

>>58428899
>that jagged edge on the top
ewwww

If that represents the programming language, I wouldn't go near it.

it's shit

SJ...

>>58428899
There is none, but it's still in beta

It doesnt do anything any other language cant do, its a meme you dip

Syntax

File: 1475015335905.jpg (114KB, 800x967px) Image search: [Google]

114KB, 800x967px

>>58428899
>Find one (1) flaw
5 years from now, C++ will still be around and will have a healthy ecosystem around it, Rust will be become a footnote. Also, Mozilla is dying and that's not a good thing.

tl;dr: stick with C++. C++ will always win. It's been winning for the last 30 years and will continue to do so. Number of C++ codebases is huge and you'll always have a job if you know C++ really well. You'll also always going to be able to hire people to work on your C++ project. Good luck finding Rust developers.

> Memory safety is overrated for most projects. Security is much more related to project guidelines and tooling than a "tough analyzer" embedded on compiller. The related tooling exists for C/C++ but it's obscure for newcomers.
> Ugly Syntax. D solves the problem with much more elegance here.
> "WE MUST REWRITE THAT IN RUST"... That shit must end.
> Still young.
> "System Programming" with a 6 week release schedule is a very retarded approach.
> Lack of mature tooling.
> No killer app yet.
> Backed by mozilla.

>>58428899
Its not c++
It is not noticeable, i didnt even know what rust was for tech until the thread talked about code

>>58429108
Nico is pretty cute.

>>58428899
it doesnt excite or interest me because there are no problems I currently have that it can solve that I can't already do with other languages that are also more portable on a wide variety of platforms new and old that I like to use

>>58428899
I keep seeing this everyday.

What is it supposed to replace OP?

SJWs

>horrible compatibility with C
>slow af compile times
>immutable by default.
the only times I have trouble with variables getting mistakenly written to, is if there is a buffer overrun somewhere, but buffer overuns don't happen in rust since it has runtime bounds checking.
>runtime bounds checking in a systems language
>made by SJWs
shit

>>58428899
PC Culture

>>58430487
>>horrible compatibility with C
What
Literally type unsafe { and you can use C functions pretty much as is.

>>58430330
C/C++.

It's pointlessly reinventing the wheel under a cult like goal of obtaining "safety". It's basically a safe space for bad coders.

It's over engineered and not garbage collected

>>58430487
Think of it as less of an actual systems language and more like a language written for browsers keeping their history of C++ in mind

File: stop using this language you shitters.png (46KB, 1389x394px) Image search: [Google]

46KB, 1389x394px

>>58431696
>just drive better bro

File: 517uUENWVEL._SX382_BO1_204_203_200_.jpg (38KB, 384x499px) Image search: [Google]

38KB, 384x499px

>>58428899
It's irrelevant

>>58429210
> Memory safety is overrated for most projects. Security is much more related to project guidelines and tooling than a "tough analyzer" embedded on compiller. The related tooling exists for C/C++ but it's obscure for newcomers.
Except it's not just for runtime. It also increases development speed as you don't get memory errors during development.
> Ugly Syntax. D solves the problem with much more elegance here.
I like the syntax except for rarities. But isn't D also slower?
> "WE MUST REWRITE THAT IN RUST"... That shit must end.
Probably
> Still young.
Agreed
> "System Programming" with a 6 week release schedule is a very retarded approach.
It doesn't break backwards compatibility only adds features.
> Lack of mature tooling.
I agree
> No killer app yet.
Rust itself is written in Rust. Servo looks like it'll be the killer app.
> Backed by mozilla.
That's a good thing. They listen to the community more than others.

>>58430487
Sounds like bait but

>horrible compatibility with C
That's just plain wrong
>slow af compile times
This is actually correct
>immutable by default.
That's a good thing.
>runtime bounds checking in a systems language
It doesn't do bounds checking if the compiler can prove your code won't go out of bounds. Besides the idiomatic way is to use iterators which doesn't do checks.
>made by SJWs
You're an idiot

>>58429108
True but the same could be said of PHP.

>>58429108
C++ is the reason we have shitty concurrency and mutithreaded application to this day.

>>58432269
PHP came out at a time when the web scripting was in its infancy and it offered a simple syntax that was familiar to C programmers.

It was easy to setup for web hosting companies and it spread. It was also pushed by many large companies.

Who's pushing Rust? Mozilla. Mozilla is dying. Rust is not a default programming language for any platform so it will never gain wide acceptance.

If you like Rust syntax so much, learn Swift since it's extremely similar yet it has a future and you can make an easy living with it. Who's hiring Rust devs? No one.

Rust's a fucking meme language.

>>58432338
Rust is being picked up by companies other than Mozilla as well tho. AFAIK Dropbox replaced rebuilt a part of their system with Rust. I also remember reading something about Facebook writing a Mercurial service for themselves in Rust.

>If you like Rust syntax so much, learn Swift since it's extremely similar

Rust is not its syntax. It's safer and faster than Swift. Also AFAIK Swift currently only has an ecosystem around iOS/macOS. I haven't checked but Rust might have a set of libraries that covers wider use cases. It's also has a wider support for different platforms and architectures.

>PHP came out at a time when the web scripting was in its infancy and it offered a simple syntax that was familiar to C programmers.

Same could be said about C++. Having a similar syntax to C and being pretty much compatible with it helped. It's still used even though it's messy and has a ton of pitfalls. Exactly like PHP.

>>58432140
>it is unethical to have complete control over your hardware

The sad thing is this person genuinely believes this.

>>58432567
Rust will never become popular. Quit deluding yourself. C++11/C++14 already do a lot of things that Rust does and C++ will only get better. These few small startups that use Rust are few and far in-between. There's more startups using Swift or Go. Apple & Google backing their languages means those languages have the future.

> It's safer and faster than Swift.
That's pretty much nonsense.

>Also AFAIK Swift currently only has an ecosystem around iOS/macOS.
IBM is pushing Swift heavily into enterprise. Just last week I got some pamphlet from IBM telling me that our company should start using some Swift tool they developed.

>Same could be said about C++.
Yeah, but Rust is not compatible with C. And syntax is vastly different too.

Rust has no future.

No programs worth a fuck that use it have been released.

>>58428899
Sjw

>>58428899
>Find one (1) flaw without resorting to "SJW"
Found the flaw

>>58428899
static borrow checking addresses a real issue with C++ but doesn't feel like exactly the right syntax and semantics to explicitly handle reference lifetimes.

>>58428899
But the game is pretty good 8/10

>>58432627
>>>58432567
>Rust will never become popular. Quit deluding yourself. C++11/C++14 already do a lot of things that Rust does and C++ will only get better.

Even C++11 is not widely used yet. It's also held back by legacy C++ devs and code. Mixed coding conventions are terrible.

>> It's safer and faster than Swift.
>That's pretty much nonsense.

Rust doesn't have GC while Swift has GC in the form of ARC. Rust's safety rules make it safer to do hard things like concurrency. You also can't do things like mutating vectors while iterating over them.

>>Same could be said about C++.
>Yeah, but Rust is not compatible with C. And syntax is vastly different too.

Being syntax compatible with C would be a bad thing. You can interface with C in Rust or the other way around without too much effort.

>>58433086
ARC is not rally a GC in a regular sense. It's deterministic and all the releases are done at the compile time. And you can also disable it.

>Being syntax compatible with C would be a bad thing.
Then don't compare it with C++ and say how it's in the same boat as early C++.

If you want an indication of how poorly Rust is doing, just look at job postings. Of all these new languages, Swift has the biggest number of postings, followed by Go. Rust doesn't even show up on most job sites.

>>58432256
>Except it's not just for runtime. It also increases development speed as you don't get memory errors during development.
This is hilarious. Are Rust coders so incompetent that they can't write anything without getting memory errors?

I never get memory errors, I know exactly how to handle most situations including multithreaded delayed deallocation, circular dependencies.

>>58428899

Horrible C++ inspired syntax, with obligatory braces everywhere and Long<Chains<Of<Stupid<Angles>>>>. And the turbofish operator, wtf.

I understand why they went with that, but a ML-style syntax would've been so much nicer.

The module system is also a clusterfuck, and still is inferior to SML/Ocaml's one.

In other words, less C++, more ML. A modern ML-like language with safe concurrency, zero cost abstractions and RTAII would've been perfect.

Ah, and multidimensional arrays are still worse than fricking Fortran 95.

Also cultural marxism.

>>58428899
Still not as fast as C

>>58431620
now try to export your rust to be usable from C.

>>58428899
strings are fucked

>>58432571
It's not YOUR hardware.
If you sell me software, it's going to run on MY hardware. I don't want you to be allowed to just fuck my shit up senpai.

>>58433153
>ARC is not rally a GC in a regular sense. It's deterministic and all the releases are done at the compile time. And you can also disable it.

You don't know anything about this do you? Reference counting is done at runtime you dum dum.

>Then don't compare it with C++ and say how it's in the same boat as early C++.

I was comparing C++'s adoption to PHP's. Not Rust's to C++'s.

>>58428899
Seeing how Mozilla is killing off Firefox within the next year or two (add-on system will be destroyed so why use Firefox anymore?), I'm really afraid to touch anything made by Mozilla right now. I'm sure that a few years from now they'll kill off Rust and put on their biggest trollface ever.

Okay, that's probably not going to happen, but I'm still afraid. So I'm going to wait 5-6 years and if Rust's still around then, maybe I will learn it.

>>58435270
This is "no true Scotsman" argument at its finest. You're acting like C/C++ applications having memory errors or Java applications getting null pointer exceptions is some rarity. It's not.

>>58435361
https://doc.rust-lang.org/reference.html#extern-functions

Just use extern "C", like in C++.

The main issue is this.

Nobody cares.

>search thread
>nobody mentions python as best language
Rust can fuck of with their tranny sjw code shit

>>58428899
Not portable.

>>58428899
cucks

>>58432567
>C++ messy
That's the biggest of all memes

>>58435270
>I never get memory errors
I too only write FizzBuzz applications

>>58435270
>this is what ctards believe
Pajeet, plugging your ears does not make errors go away.

>>58428899
Compiler is slow, not optimising enough and not parallelised enough.
Not enough good high performance libraries. Go's net/http is still 16 times faster than Hyper.
Many libraries rely on the nightly compiler.

>>58435876
>Go's net/http
And that means a lot considering how slow it was considered compared to other non standard library routers. Maybe it changed after 1.6.

>>58432140
>analogies
Flagged for garbage collection.

>>58428899
Look how shitty designed all the event loop and networking libraries are. It's not a coincidence. Rust traits force you to make this mess. This will reach Java-levels of madness once people start bulding bigger things.

Want to start a web server? In every language it's basically

function get(request):
    return http.response(200, "hello")

http.run(get)

In Rust it's implementing generic shit called BeforeMiddleware, AfterMiddleware, MiddlewareMiddleware, Service, Handler, Token, Future... and oh you need a state? This will be another 10k lines.

>>58428899

May endanger structural integrity of things made our of metal

>>58435887
1.7 brought in a new optimising compiler backend for x86_64, which made Go programs generally 20-35% faster.

No clue why ServeMux is even there though. It's both slow and limited.

The reason the server itself is fast is because it integrates with the runtime and goroutines on a low level. Meanwhile Hyper blocks on requests.

>>58436111
I can't understand your post, can you please break it out into 4 boilerplate posts instead?

>>58436111
I thought you were exaggerating at first. Turns out this is an HTTP Hello World! in Rust https://github.com/hyperium/hyper/blob/master/examples/hello.rs

>>58429054
Well it's a fucking Turing-complete language I suppose?

Why are there so many anti-rust shills? It's one thing to dislike a language and have reasons to, it's another to constantly post made-up reasons at every opportunity. Is google that desperate or what?

>>58428899

> Hitting trees with rocks

>>58436645
Remember, this is 4chan, home of spergs and degenerates.
If you actually expect knowlegde of any topic beside weeb memery and autism bucks form completion you are better off elsewhere.

>>58436645
>why do people who dislike Rust post the flaws they see in the language in a thread where that specifically is requested
A real brain buster.
>made-up
Is it also surprising to you that people who only have cursory knowledge of the language are not familiar with it?

>>58435408
How so?

>>58435607
how can a code be tranny sjw?

>>58436730
multiple inheritance

>>58436764
Rust isn't OOP, it doesn't have inheritance.

>>58436780
(Is joke)

>>58428899
Favors imperative style over functional.

>>58436800
It's a thread about flaws, not bonuses, you dumbass.

>>58430581
I agree, faggots who post on r/pcmasterrace should be cookie banned.

File: boost.png (404KB, 1004x1000px) Image search: [Google]

404KB, 1004x1000px

>>58435808
??

>>58432140
>All the performance benefits ever derived from writing everything in C has been more than erased, by orders of magnitude, by the damage caused from even simple innocent mistakes.

[citation
fucking
needed]

>>58436199
>>58436111

Depends on what you're using. With rocket.rs it's Python's Flask like:

#![feature(plugin)]
#![plugin(rocket_codegen)]

extern crate rocket;

#[get("/hello/<name>/<age>")]
fn hello(name: &str, age: u8) -> String {
    format!("Hello, {} year old named {}!", age, name)
}

fn main() {
    rocket::ignite().mount("/", routes![hello]).launch();
}

>>58435607
>comparing rust to python
My Little Anon Can't Be This Retarded

File: 1407845744325.jpg (108KB, 500x500px)

108KB, 500x500px

>>58436904
>Rocket is designed to be performant. At this time, its performance is bottlenecked by the Hyper HTTP library.
>requires nightly compiler

>>58436855
It's
>reddit
anon. On reddit, things become facts simply by having a slight majority agree with them.

>>58436971
That's actually hackernews, but same difference.

>>58432913
>doesn't feel like exactly the right syntax and semantics to explicitly handle reference lifetimes.

They've spent ages fucking with the syntax and it still feels a bit awkward in places for how the language is supposed to be used. At least a while ago the easiest way to default-initialize something resembling an array on the heap was to create a vector using the vec! macro and then eject its storage into a boxed slice, or something.

I think unstable finally supports syntax like "box [1337; length]".

>>58437255
I'm not following nightly but that vec![ ; ].into_boxed_slice() thing is very dumb. But I'm sure one could easily write that into a macro. They should standardize that.

Also printing to stderr. Everyone seems to define a eprintln macro. That should be standardized as well imo.

>>58432140
Bullshit.

Guy talks like there is something better.
But there is none.
There is no better language for micro controllers, for single boards, for embedded development, for kernels/OS, etc.

There is just none.
https://stackoverflow.com/questions/580292/what-languages-are-windows-mac-os-x-and-linux-written-in

>>58437255
>easiest way to default-initialize something resembling an array on the heap

do you mean the equivalent of

new Foo[sz]

or allocating something like

std::array<Foo, sz>

on the heap or what?

>>58437734
Not that guy but that's it

>>58437734
Like

some_sort_of_ptr<Foo[]>(new Foo[sz])

so that every item is initialized with a copy of a specific Foo. The language has some rather nice syntax for arrays and slices, but the most obvious way to do this passes the array through the stack, which isn't going to work for a large enough sz.

As stated above you can do something like

vec![INITIAL_FOO_VALUE; sz].into_boxed_slice()

to get a boxed array-ish thing but needing a vector macro to allocate an array on the heap seems a bit unpolished.

>>58437918
I'm sure the vector related bits get optimized down to a malloc.

>>58437616
The thing is that C is about 80% close to being an ideal language for OS/embedded development, but it's so entrenched that nothing will ever be able to muscle it out. Clearly nothing with GC or even exception handling will ever be suitable, but language writers don't want to make C 1.5 when they can wank over new esoteric abstractions.

That said, the following shortcomings could be improved upon at no runtime cost:
> macro/preprocessor system
> compilation and link model needing to re-scan everything for every object file because of macro system
> lack of namespaces (except for the 2nd one for structs because you can't be trusted to not make bloated copies)
> harmfully shallow type system, especially regarding array->ptr decay
> in-band terminated C strings instead of char arrays
> unary prefix operators for de/referencing operators
> pass by value semantics instead of pass by const reference, with ABI-dependent copy optimization for primitives/tiny structs

File: rust-alt-logo.png (245KB, 3000x3000px)

245KB, 3000x3000px

>>58428899
The community

>>58437990
>>58437616
I don't want to be THAT guy but I fail to see how Rust isn't suitable in that area

>>58432571
Languages should be safe by default, and unsafe by request. It's unethical to write unnecessarily unsafe code because it puts a lot of people at risk without good reason.
Note: I dont necessarily think Rust is the optimal solution

>needing a whole new language for muh safety
>not just using C++ with asan/tsan/etc.
lmaoing @ your life

>>58438250
So writing compilers and drivers in arsembler is genocide, got it

It's more verbose than C/++.

Why use a let keyword and then still declare a variable type later? That seems like a meaningless waste of syntax.

>>58438125
rust is:
> too unstable
> far larger a language than embedded programmers want to deal with
> overly concerned with object lifetimes when a lot of embedded stuff just needs static allocation anyway
> prefers math-inspired notation instead of imperative style ("return" allowed but scorned, no semicolons, etc.)
> plagued by a horrendous signal:noise ratio in the community

also, Rust does continue pass by value instead of by const reference, which would have greatly alleviated its cumbersome function declaration and calling notation.

>>58437949
Yeah, so I figured, but having to chant over-verbose spells (that compile into nothing) to write safe code around the language's weaknesses just reeks of modern C++.

At least it's getting fixed.

>>58428899
It's not fun to use. I'm waiting for Jon blows language to appear, but I fear he might do the same mistakes as the D devs.

File: 1471284975981.jpg (19KB, 300x300px) Image search: [Google]

19KB, 300x300px

>>58428899
This is (((Steve Klabnik))) a Communist, antifa and SJW asshole who pushes Rust.

Fuck Rust.

If you use Rust, KYS.

>>58435462
>I was comparing C++'s adoption to PHP's. Not Rust's to C++'s.
Rust's dead you motherfucking shithead.

Ugly syntax
/thread

>>58438449
>a Communist
fuck you, comrade

File: bwbXZUi.gif (1MB, 234x234px) Image search: [Google]

1MB, 234x234px

>>58438449

> Nose

>>58438358
> too unstable
[citation needed]

> far larger a language than embedded programmers want to deal with

That implies embedded programmers are idiots.

> overly concerned with object lifetimes when a lot of embedded stuff just needs static allocation anyway

"object lifetimes" are not some magical thing with runtime costs. It's not different than C.

> prefers math-inspired notation instead of imperative style ("return" allowed but scorned, no semicolons, etc.)

What does that have to with embedded systems? It's just syntax.

> plagued by a horrendous signal:noise ratio in the community

Rust has better signal noise ratio than most IMO. With C/C++/Java when you search for something you get terrible CS101 level stackoverflow questions/answers.

>also, Rust does continue pass by value instead of by const reference, which would have greatly alleviated its cumbersome function declaration and calling notation.

I literally have no idea what you mean. Rust's function declaration/calling notation is no different than most languages. I don't understand what you mean by "pass by value". Ownership/borrowing works with references. Copy types are passed by value

>>58435270
>trusting programmers
I'd rather trust a thoroughly tested compiler and runtime system designed to catch memory errors

>>58438125
First and foremost Rust is not a major language (yet?).
And, I doubt it will ever become one - thanks to Mozilla.

No big company picked up Rust, which is also a scary thing.
I mean, you have Scala, you have Go, even F#.
Companies jumped the bandwagon as soon as they could.
Rust? No one gives a flying fuck about it.

Samsung/Mozilla writes Servo (meanwhile you only see very limited efforts on their Github page), and that's it.

For me, as a normal developer guy, I find it "weird".
- It tries to be C, but tries to be also "safe".
- It promotes concurrency, but not the way I think it should promote it (see below).
- There is no IDE / "all-in-one" pack that I can start and just learn/code.
- The whole language - to me which is totally subjective - is "alien". Even "Go" is easy to pickup, but Rust? Feels like learning Ruby again, or trying to fix my colleague's Perl script.
...

>>58438615
>thanks to Mozilla

What do you mean by this? Mozilla doesn't own Rust, it just sponsors it, i.e. pay some People to work full-time on Rust. The project itself is open-source.

>>58438483
...knows

>>58438615

>I mean, you have Scala, you have Go, even F#.

Which big companies jumped on Scala and F# bandwagons, let alone in their first years?

>No big company picked up Rust, which is also a scary thing.
>Rust? No one gives a flying fuck about it.

Keep in mind Rust is only over 1 year old. Organizations running Rust in production:

https://www.rust-lang.org/en-US/friends.html


>- It tries to be C, but tries to be also "safe".

you imply being safe without the cost is somewhat bad

>- There is no IDE / "all-in-one" pack that I can start and just learn/code.

I agree. It's not as terrible you make it out to be. There are decent plugins for major editors but there's no magical IDE thing yet. It's still new so those things are on their way. See https://areweideyet.com/

>- It promotes concurrency, but not the way I think it should promote it (see below).

Safe and low overhead? With easy to use libraries like rayon and crossbeam?

>>58438674
>What do you mean by this? Mozilla doesn't own Rust, it just sponsors it, i.e. pay some People to work full-time on Rust. The project itself is open-source.
you write on 4chan like someone who came here yesterday from plebbit. there's a dead-giveaway in your posts.

you're also a fucking shill for this Rust shit.

just GTFO

File: 1480679288377.jpg (55KB, 500x492px) Image search: [Google]

55KB, 500x492px

>>58438731
>more shilling

>>58438733
>Provide counter-argument
>Lol shill
fuck off

>>58438776
We have these Rust shill threads every week or so.

No one fucking uses that shit.

It's just some lonely Mozilla faggot who's tasked with "evangelizing" this piece of shit language that's making these shit threads.

This shit should be banned for violating Global Rule against spam.

>>58438497
>I don't understand what you mean by "pass by value".

If you don't know what pass/call-by-value/copy vs. pass/call-by-(const-)ref, you don't belong in this thread, friendo.

The above argument presumably means that function parameter decorators would be less of an ugly fucking mess if they were default non-owning const references, with added notation only for being mutable, sharable, etc.

Traditionally, calling by value makes things look consistent inside function implementations (params and local declaration both default to non-const), but it's pants-on-head retarded for Rust, where locals need explicit 'mut' annotations anyway.

>>58438842
>If you don't know what pass/call-by-value/copy vs. pass/call-by-(const-)ref, you don't belong in this thread, friendo.

I know what "pass by value" is. I asked what that guy meant by "Rust does continue pass by value instead of by const reference". I later explained how Rust does pass by reference.

>>58432163
No one here is smart enough to read a book, faggot.

>>58438842
>>58438880
>>58438731
samefag spammer.

>>58438674
Sponsor = the people who fund the project, keep it alive and healthy.
There is no open source project that big - that is written only by only contributors.

The current devs are as far as I know - all Mozilla/Samsung employee.
So yeah. Mozilla does have a lot of power in the project.

>>58438731
> let alone in their first years?
Quite plenty. I am not paid by any company though, to gather links and shit for you.
But it's no wonder. Scala proved itself, and F# has Microsoft behind.

> /jews.html

Most of those are pretty minor thing.
> company A
> Satya Nutella, one of our poo devs wrote a Hello World in Rust!

> Safe and low overhead? With easy to use libraries like rayon and crossbeam?
I don't want C2.
I want a new language that does something better.
So Rust says it's all about safe, fast parallelism.
Good.

Now give me the tools.
And fuck libraries, this ain't python.
import my ass.

The Rust team should write a core library that does things GOOD, properly.
The core Java/C# libs are a good example.

>>58439280
>Quite plenty.

Thanks for that amazing list.

>I don't want C2.
>I want a new language that does something better.

>Now give me the tools.
>And fuck libraries, this ain't python.
>import my ass.

This sounds like "I want a bloated standard library".

>The Rust team should write a core library that does things GOOD, properly.

They do write them. They also provide other very useful libraries as crates.

>>58428899
no unions

>>58440171
Rust has enums which are better anyways ya silly goof.

>>58440234
Really makes me hmm..

>>58429017
>>58429028
>>58429054
>>58429081
>>58429210
>>58430337
>>58430581
>>58432094
>>58432163
>>58432338
Proof /g/ is full of 15 year olds who only know "hello world in C++ " and skim hacker news

>>58428899
types are too high level
when I make an integer I have no idea what it looks like in memory

>>58440307
Thanks for the contribution.

>>58440328
Please don't feed the retard

>>58440307
>and skim hacker news
fuck off back to that censored shithole and meme that Rust crap there.

>>58428899
In accordance with federal law, someone makes a Rust thread.

>>58428899

1. Overly complicated, it's basically C++.
2. Gets nowhere, changes too often, takes way to long to get traction.
3. Target group is 95% C or C++ developers, yet they don't try to get them on their side.
4. Mozilla
5. SJW (I don't know what you expected?)

File: 38d.jpg (50KB, 600x604px)

50KB, 600x604px

>>58440313
>size is literally specified in the name (i32, f64, etc.)
>no idea what it looks like in memory

it's boring as fuck

>>58440461
I thought specifying the size was optional

rust is so bad that it actually makes me appreciate c++ lmao

>Additionally, there is a theory being bandied about in so-called Alt-Right social media circles that the whole thing is an elaborate hoax created and disseminated within the international intelligence community by 4chan, a loose network of internet trolls.

>>58428899
Tries to do everything

>>58440491
Specifying the *type* is optional if the compiler can make an inference about it.

>>58441745
yeah, I don't like that

>>58441762
Why? You afraid the compiler can optimize it better than you can?

>>58441791
I just don't like that it's advertised as a systems programming language but sometimes I don't know what my variables look like in memory

>>58441869
If the compiler can infer a type, so can you.
Also, IDE crutches exist as well.

Java-style excess verbosity is more about shuffling work between interchangeable Pajeets than helping seasoned devs familiar with a codebase.

>>58441869
You know that C primitive types are different sizes on different systems, right? They only guarantee a minimum size.

You also know that the C compiler is free to reorder and add padding to any variable or struct you make, right?

Syntax looks like a plucked chicken.

>>58442063
I guess that's a fair point.

>>58440171
I think it's supported somewhere in nightly. Anyway why would you want unions when you have sum types?

>>58440431
The rust standard is literally smaller than the C89 standard. At least pretend to have an argument instead of posting bullshit.

>>58441869
>"I'm a CS babbie who learned C and thinks premature optimizations make me superior" the post

>>58429210
>accusing a programming language made by and for browser engineers of overrating memory safety
>hating on the only major tech company that's a non-profit (inb4 corporation) that is actually doing it for you instead of just selling your data

how?

>>58428899
A rusty gear is a horrid design choice for almost anything.

>>58443377
More like CE/EE babbies.

>>58428899
The main problem with Rust is not the language, but the implementation. Look at the inconsistent standard library. Some things are clearly written by C programmers and are well designed. Some reek of classical OOP with gigantic structs and interfaces. Some are done by webdev trash and this applies to most third party libraries. The compiler is a terrible joke of unoptimised code itself. Rust may have its troubles as a language, but the ecosystem is terribly inefficient at this point. This is unacceptable for a systems programing language. Not that I would expect a community of mostly web developer code artisan SJWs to write good efficient code.

> Look at the inconsistent standard library.

I'm looking at it. What's inconsistent?

> Some things are clearly written by C programmers and are well designed.

What's well designed?

> Some reek of classical OOP with gigantic structs and interfaces.

Like what? What's wrong with classical OOP?

> The compiler is a terrible joke of unoptimised code itself.

Slow to compile? Or produces slow code?

> Rust may have its troubles as a language, but the ecosystem is terribly inefficient at this point.

The ecosystem is definitely not inefficient.

> Not that I would expect a community of mostly web developer code artisan SJWs to write good efficient code.
> Developing a web browser = webdev

>>58445112
Rust seems to attract webfags more than it does native devs who already know C or C++ well

Probably why almost every rustfag can't shut up about "muh safety" like they've never had to deal with pointers or anything before

>>58444990

lots of ad hominem but no actual evidence. Any examples you care to show there, genius?

>>58446642
oh the irony

>>58446642
>>58444990
butthurt much?

>>58432140
>quoting the cancer that is HN unironically
kys

File: Screenshot from 2016-12-30 11-51-19.png (98KB, 564x966px) Image search: [Google]

98KB, 564x966px

>rust

>>58446942
Do you even know what you're looking at? Do you even know how to read in the first place? Are you a bot?

>>58446956
template definitions

>>58446983
No. Implementation of the function for each of the listed type. IntoIterator is basically

public class IntoIterator {
 ...
}

And that's not what your pic is showing. What your pic is showing is:

public class Option implements IntoIterator {
 ...
}
public class Result implements IntoIterator {
 ...
}
...

>>58437255
What is Box::new([1, 2, 3])?
>>58438615
>Samsung and Mozilla aren't big companies

>>58447085
>What is Box::new([1, 2, 3])?
An expression that constructs a three-element array on the stack and then copies its contents into a new box.

>>58441869
C++ has auto. It's the similar but more capable. For example the type of HashMap is inferred to be HashMap<&str, &str> by the .insert() lines following it:

let mut book_reviews = HashMap::new();
book_reviews.insert("Adventures of Huckleberry Finn",    "My favorite book.");

This line by itself won't compile without .insert() because there's no information for inferringKey and Value types.

let mut book_reviews = HashMap::new();

. But this will compile

let mut book_reviews: HashMap<&str, &str> = HashMap::new();

.

>>58447085
>What is Box::new([1, 2, 3])?

Yeah but you can't do

 Box::new([0; arr_size]) 

unless you use vec! because arr_size is a variable.

>>58447312
That's because you're trying to create a dynamic array on the stack. You can't do that. The size of your stack frame must be known at compile time.

There's nothing wrong with vec!

It's too modern.

>>58429210
>Memory safety is overrated

This is why sepples fags need to be round up and shot desu.

Fuck you

>>58438449
>Communist
Well I guess it's time to learn Rust.

Having just graduated with a CS degree and having gone through the job searching process, I see no use in Rust because I've never heard of it.

Why take the time to learn this language if no one else uses it? I have never seen knowledge of Rust listed as a required or preferred skill. The best programming language is the one that is the industry standard/one that everyone knows and gets the job done.

>>58448180
You know what? I'll even give y'all a break. I just did an Indeed job search for "rust programmer" and it came up with all of six job openings. Sounds popular to me...

>>58447894
Box is heap not stack ultimately but of course it's against the rules and Box::new() is a regular function.

The original complaint was the hoops you need to jump through to get a heap allocated array. As much as I love Rust it looks dumb:

 vec!([0; arr_size]).into_boxed_slice() 

>>58448145
shalom comrade!

>>58438497
Do you know what an embedded system is?

>>58448244
Do you? If so, can you enlighten us to why Rust is unsuitable?

>>58432163
Nobody except the government uses that shit.

>>58436125
Underrated post.

>>58428899
oh look, another D 2.0 thread

>>58432256
>They listen to the community more than others
Fucking this. People here like to give Mozilla a lot of crap, but they are one of the few organizations that listen to the community and seem to enjoy the things they do.
The other options are full of neocons that will cut projects the first moment they are not profitable enough or will try to monetize your data in one way or another.

>>58449024
>D 2.0 bigger longer uncut

File: 1483823915676.png (461KB, 1150x1500px)

461KB, 1150x1500px

I want some of the "Waaaah SJW" fucksticks to explain to me how Rust even being a SJW language affects what code I can write with it??

>>58448217
No clue why you would want to do that. Though you could do &vec![0; arr_size] instead.

>>58449272
Is that why they do forced signed addons that has been broken day 1, want to kill their entire plugin echosystem, and added forced telemetry, tracking ads, drm, and botnet pocket despite the community's voted goal was privacy?

>>58450401
In practice, it means you can't contribute to rust (by pointing out issues and bugs) unless you have 0 social media presence whatsoever (even under different names, they'll find out and blacklist you).
It also means that developer time is wasted on sjw garbage (like feminising the dining philosophers problem) rather than making the language actually good.
In theory, it could also mean that the language starts forbidding operations or variable names on purely sjw grounds. Imagine if you were no longer allowed to use any word that even remotely resembled a racist expression so you had to modify all your abbreviations and shortnames for extra-explicit things to even be able to have to program try to compile.

>>58451399
>In theory, it could also mean that the language starts forbidding operations or variable names on purely sjw grounds. Imagine if you were no longer allowed to use any word that even remotely resembled a racist expression so you had to modify all your abbreviations and shortnames for extra-explicit things to even be able to have to program try to compile.

This is what /pol/ really believes

>>58432256
>But isn't D also slower
For non garbage collected types and using gdc it can be faster than C++ but otherwise it is slightly slower

>>58451399
Honestly anon, I would recommend you anonymously challenge it to demonstrate how retarded it is to let a language be controlled by Jews
Why not put a PR in just to bait their shit out

>>58446942
The only thing unacceptable about that are the macro-generated trait implementations for arrays and tuples, as these are due to currently lacking integer generics and variadics respectively.

>>58451399
Source: Your Ass

>>58448180
>>58448206

That's a problem that any new language has:
No one knows $lang -> no company wants to hire a $lang dev since they are hard to find -> no on wants to learn $lang since no company asks for a $lang dev -> goto step 1

it exists

Rust is webscale as fuck

error[E0310]: the parameter type `Client` may not live long enough
   --> <censored path>/ipc.rs
    |
100 |         handle.spawn(fut);
    |                ^^^^^
    |
    = help: consider adding an explicit lifetime bound `Client: 'static`...
note: ...so that the type `futures::MapErr<futures::Map<futures::sink::SendAll<futures::stream::SplitSink<futures::stream::AndThen<tokio_core::io::Framed<Client, ipc::LenDelimited<protobuf::Message::Message>>, fn(tokio_core::io::EasyBuf) -> std::result::Result<protobuf::Message::Message, std::io::Error> {ipc::decode_msg}, std::result::Result<protobuf::Message::Message, std::io::Error>>>, futures::stream::Map<futures::stream::SplitStream<futures::stream::AndThen<tokio_core::io::Framed<Client, ipc::LenDelimited<protobuf::Message::Message>>, fn(tokio_core::io::EasyBuf) -> std::result::Result<protobuf::Message::Message, std::io::Error> {ipc::decode_msg}, std::result::Result<protobuf::Message::Message, std::io::Error>>>, H>>, fn((futures::stream::SplitSink<futures::stream::AndThen<tokio_core::io::Framed<Client, ipc::LenDelimited<protobuf::Message::Message>>, fn(tokio_core::io::EasyBuf) -> std::result::Result<protobuf::Message::Message, std::io::Error> {ipc::decode_msg}, std::result::Result<protobuf::Message::Message, std::io::Error>>>, futures::stream::Map<futures::stream::SplitStream<futures::stream::AndThen<tokio_core::io::Framed<Client, ipc::LenDelimited<protobuf::Message::Message>>, fn(tokio_core::io::EasyBuf) -> std::result::Result<protobuf::Message::Message, std::io::Error> {ipc::decode_msg}, std::result::Result<protobuf::Message::Message, std::io::Error>>>, H>)) {std::mem::drop::

cont...

>>58452513

<(futures::stream::SplitSink<futures::stream::AndThen<tokio_core::io::Framed<Client, ipc::LenDelimited<protobuf::Message::Message>>, fn(tokio_core::io::EasyBuf) -> std::result::Result<protobuf::Message::Message, std::io::Error> {ipc::decode_msg}, std::result::Result<protobuf::Message::Message, std::io::Error>>>, futures::stream::Map<futures::stream::SplitStream<futures::stream::AndThen<tokio_core::io::Framed<Client, ipc::LenDelimited<protobuf::Message::Message>>, fn(tokio_core::io::EasyBuf) -> std::result::Result<protobuf::Message::Message, std::io::Error> {ipc::decode_msg}, std::result::Result<protobuf::Message::Message, std::io::Error>>>, H>)>}>, EH>` will meet its required lifetime bounds

>>58449272
lmao hello mozilla

>>58448984
No one uses rust. So what's the point again?

>>58429108
why is the tl:dr longer than the actual text?

>>58453737
Because anon didn't go to college

>>58438283
>not understanding the difference between "N test invocations didn't fail" and "no invocation can fail"

>>58447284
>inferring from variable amount of context

how is that a good idea

File: rust.png (165KB, 2000x2562px)

165KB, 2000x2562px

>rust
get the fuck out of /g/

>>58453737
it's a trick to get you to read something.

see, you read it and it worked.

The Rust ecosystem isn't mature enough to be used by businesses.
Diesel (ORM) and Clippy (static analysis) require a nightly compiler to build. IIRC that'll be fixed in Rust 1.15, but it's still an issue. Hyper (HTTP support) is basically being rewritten to use Tokio (async I/O).
As much as I like Rust, I can't recommend it right now. Maybe next year.

>>58454115
Kill yourself out of the genepool

>>58454727
same i can tell about you and all mozillafags

>>58432140
lol someone can't program in C

>>58451687
>>58452380

https://github.com/rust-lang/rust-buildbot/issues/2

>>58454792
Kek, that's new to me

>>58454792
>>58454822

And absolutely nothing of consequence happened: https://github.com/rust-lang/rust-buildbot

Look at the folder names.

>>58454792
>>58454882
Fucking this, people like that are the loudest minority. Rust being an open source project means that the sane part of the community will have everyone else in check.

>>58448932
You're dealing with storage and memory in the MEGABYTES AND KILOBYTES RANGE and a uC in the TENS OR HUNDREDS OF HERTZ. C is too fat sometimes. You try loading a runtime with overhead on a 8051 or a Atmel or a PIC.

>>58435887
The thing with net/http is that it's meant to be pretty fast in all but the edgiest of edge cases. Third party servers are faster 80-95% of the time, but there are many situations in which they are not.

It doesn't even matter 99% of the time because databases and rendering templates is going to dwarf the actual server time anyways unless you're building the simplest of REST APIs

>>58455034
What overhead does Rust have?

>>58455211
Unwinding by default on panic instead of aborting is one thing i can think of

>>58454882

> steveklabnik commented on 16 Dec 2014
> Very, very +1
> (and primary/replica is my preferred, but just anything other than master/slave)

Just a taste for the kind of people you're dealing with.

Googling showed there is some effort to make Rust usable on embedded stuff:

http://www.rust-embedded.org/
https://zinc.rs/

>>58455285
>getting this triggered by a guy's political opinions
I'd rather deal with him than with spergs like you

>>58455333

Socjus are the ones who get triggered and try to doxx and ruin your life if they don't like how you think. And Mozilla has prior history on this (see the Javascript guy).

I couldn't care less about what a developer thinks, looks or eats. In the internet nobody knows if you're a dog. Only technical chops should matter. But I still have to protect myself.

>>58428899
It's not C++.

File: d0o7qa9j.png (87KB, 600x600px)

87KB, 600x600px

>>58428899
The logo looks terrible. The mounting holes of the gear touch the letter R.

>>58455309
>https://zinc.rs/
Did you even look at that?
By adding so much abstraction, it's the exact opposite what C-devs need.

>>58451399
>>58451687
Several projects have wasted time blacklisting things like "blacklist/whitelist" while their project masters remove "master/slave" terminology, this is a waste of time and needlessly confusing, there's no reason to go against established standards like that, it only causes confusion and often breaks shit which wastes more time.

>>58455333
>I'd rather talk about politics than technology
This is the problem, you people aren't software people you are political people, there's no need for you all to be on /g/, github, or anything else that has to do with software, there's plenty of places to discuss politics and social issues, it doesn't have to be github.

>>58428899
> name that reminds people of old, broken machinery

>>58455309
>Embedded programming
>Runtime safety checks

Rust is compile time checks you idiot

>>58433086
>concurrency is so hard to do man
"concurrency" is more than just having an occasional function run on a separate thread. Good concurrency divides the whole program into groups of related functionality, and then provides safe (sync) interactions between the groups when absolutely necessary.

If you just stop and think a little about the structure of the final product, it's not hard to multithread something. Any attempts to make multithreading easier generally end up creating more of a clusterfuck and limiting your options. Even C#, which is pretty nice to multithread, generally leaves it up to the programmer to make sensible decisions, although I recognize C and C# are whole different ball games.

>>58438562
You mean a thoroughly tested compiler and runtime system written by programmers? You realize the software that we hear about failing in huge ways is thoroughly tested as well, right? I'd bet you everything I own that someone will find a way to exploit something about Rust in just as fatal a way. Ultimately there are no perfect safety mechanisms, because the safety mechanisms themselves can be vulnerable. There's nothing at the machine code level stopping buffer overflows or stack smashing or anything else.

The really dangerous stuff is not the above, though. The most dangerous exploits use nuances in systems. Take for example the ability to abuse nonces. Writing the code in a safe language would have done fuck-all to prevent that.

>>58454822
It's not even remotely the only case. Check out the issues tracker and you'll meet way too many of these. There's even a case of a landwhale having a nervous breakdown because someone reverted her PR because some SJW employee pulled it without first checking it. The brave whale was congratulated for her maturity and sanity, after which the devs involved were doxed by the guy responsible for the PR merge.

>>58455309
Check out libcore. The rust people are splitting libcore and libstd purposely so you can have an even smaller standard library for the purpose of embedded development. They obviously care, if only somewhat.

>>58457635
t. inbred

>>58458222
I, too, am an expert parallel fizzbuzz programmer.

>>58450401
They can't, those are memes.

>>58428899
If you want to program in Ada, you could just program in Ada. No need to use this watered down garbage.

>>58462010
Come back when ada allows you to not do manual memory management, not use the GC nor reference counting, and not leak memory all at the same time.

>>58463132
Ada has memory pools and raii, what more do you need?

Coding Rust is kinda like being a professional saddle maker.

You put your entire soul into the effort of making the most beautiful saddle, crafted by human hands.

and yet people insists on driving those damn cars instead of riding horses.

>>58459180
you wouldn't happen to have a link or at least some clue how to find it?

File: 1482778606544.jpg (152KB, 715x1538px)

152KB, 715x1538px

>hash tables arent even built into the language

>>58463832
memory regions that guarantee the raii to be safe

>>58465136
>building hash tables into a language
This isn't about meme tier scripting, you know.

>>58465136
>>58465258
Rule of thumb: If the language has a data structure built in, it's because the language isn't expressive enough to allow programmers to define that data structure themselves

>>58465269
D has built-in hash tables

>>58465288
Thanks for the information?

>>58465136
Hashmaps are part of the standard library.
What the hell else would you want?

It's not fucking Lua.

>>58458222
It's hard to add multithreading to existing singlethreaded code. Rust makes it easier by not letting you fuck certain things up.

About safety. In Rust buffer overflows are checked when they're possible and the application exits when it happens. Even if there were safety bugs in Rust it's still better for safety overall. Not having "perfect" safety mechanisms doesn't mean you shouldn't give a fuck about safety.

>>58465078
https://github.com/rust-lang/rust/issues/28059 :^)
But really https://github.com/rust-lang/rust-www/pull/274
https://github.com/rust-lang/rust-www/issues/268

File: 1476976863832.png (100KB, 375x375px)

100KB, 375x375px

kek. searching for gender in the issue tracker brings up 9 closed issues. the pull requests tab brings up 6 closed issues

>>58465078
>>58466413
https://github.com/rust-lang/rust/pull/25585

Nu male cucks and feminazis

>>58466413

> https://github.com/rust-lang/rust-www/issues/268

HAHAHAHAHAHAHAHAHAHAHAHAHA

I just can't get the syntax. There is something just so inherently ugly and unintuitive to me about having every keyword shortered down to three or four letters.

Sure, you have to type a little less, but it completly tanks readability.

https://github.com/rust-lang/rust/issues/31817 oh wow

File: dont turn off.png (821KB, 1024x768px) Image search: [Google]

821KB, 1024x768px

>>58453737
>why is the tl:dr longer than the actual text?

He's a C++ programmer

>>58466823
>this pull request went nowhere because it was about muzzies and commies
ebin

>>58436630
css is too how about you start shilling that shit

>>58428899
>type inference
dropped

>>58464769
Quite the opposite. Rust is not the language that needs to be deprecated.

>>58466809
Apparently they used to have a rule of keeping everything under 4 characters or something.

I like it though. fn is way better than typing function imo.

>>58466878
I too like writing long type names like Vector<String> when it is absolutely unnecessary.

>>58428899
It isn't Haskell

File: laughing_security_experts.jpg (170KB, 1920x1080px)

170KB, 1920x1080px

>>58468484
>watered-down OCaml

>>58469075
but that's not true at all

Rust children think memory allocation can be made safe, which is frankly the most dangerous fallacy they are pedaling.

>>58465248
Will pointers and the data they allocate can't be used outside of their scope, do I don't see how they could be unsafe.

>>58428899
SJWs

>>58455241
That's a compiler default, not a language requisite iirc. And it makes sense for a compiler to unwind by default on most architectures.

http://esr.ibiblio.org/?p=7294
> no string concatenation
> no epoll/select
> no strong BDFL
meme tier language full of cultists

>>58469442
What is literate programming? What is static analysis?

Oh and most of all, what is Rust's unsafe mode?

>>58470297
RFCs are better anyhow.

>>58470319
I don't know, what is it?

>>58470319
What are you on about?

in my experience with the world of datacenters, enterprise systems, "big data," "scalable machine learning" etc. i've come to the conclusion that our neglect for performance and more importantly, efficiency is so criminal that i believe the compute-per-watt of a datacenter is wasteful by a factor of maybe 100-1000x or more

so when some fucking meme language "developer" tells me that performance doesn't matter, hardware is unimportant, we have virtual machines now and we need to do everything behind 20 layers of abstraction, i'm thinking "crappy fucking software is turning data centers into crappy space heaters"

having said that, rust is better than most. it's at least trying to be efficient, that's a design goal. but anyone who thinks there's an ethical crisis in computer security and can't see the ethical crisis in computer efficiency is a fucking moron

>>58470350
>>58470363
https://doc.rust-lang.org/nomicon/meet-safe-and-unsafe.html
The only trade-off compile time checked memory safety has is that a small amount of correct programs cannot be proven safe, for that you can use unsafe mode.

But there are otherwise a ton of literature on how to prove memory safety, it's by no means impossible.

>>58470297
From what I understand C does not have epoll/select in its STL. It also does not have string concatenation or string types for that matter.

Does that make C a meme language too?

>>58471130
C was already a meme language

>>58471130
> C
> epoll/select
> STL
What the fuck are you saying.

>>58471205
Well, that anon said Rust a meme because it lacks epoll/select in its standard library, but C does not have that either, right?

I don't use C so apologies for my ignorance.

>>58470314
>someone was so anal blasted that he wasted time in doing this
Delicious, delicious tears.

>>58471168
t. Lispfag

>>58470319
>literate programming
what does it have to do with anything?

>>58447054

explain to me how that rust pic translates to what your pic shows

>>58470314
That logo is far better designed than this piece of shit >>58456119

>>58472317
This is embarrassingly true.

>>58470350
It's about writing a book around your code base.
The advantage is that somebody can read your book from start to finish to get an idea about your codebase. The most important part is that your first dozen pages do nothing but define constants and imports that will be used hundred pages later and are totally irrelevant to what you're currently reading and by the time you're reading the page where this information is critikal you've already forgot what they mean. Oh and everytime there's a new release you have to read the entire book again if you want to stay up to date.


It's shit. People only want to know what they need to know. This format places equal importance on all parts of the project even though the majority of contributors do not need and want indepth knowledge about almost all subsystems and rather only focus on the things that are important to them.

>>58472388
>It's about writing a book around your code base.
Suddenly I am uninterested

>>58472388
I only know of 1 successful project that ever pulled this off anyways, and that was made by a fucking god.

>>58471956
It's exactly as depicted. I don't know what needs to be explained. Also I have no pic.

>>58472317
it's unbalanced tho

>>58438449
Does this little faggot know how many people were killed by communism?

>>58474628
Implying the would care.

>>58473240
Who and what project?

>>58432256
>Rust itself is written in Rust.

what?

>>58470297
>full of cultists
But it's not C.

>>58429081
Explain.

>>58474938
It's common practice for non-shit language (read: not go) to be written in themselves. The first compiler may be written in, say, ocaml, and then you use that compiler to program the next version of the compiler. Then you compile the compiler using the compiler, and you're ready to go.

>>58477316
Go is written in go though

>>58477374
They used an automatic C to go translator, actually. This of course results in shit code by default which does not properly make use of go strengths, avoiding go weaknesses, for example, and it goes without saying that the devs don't properly understand the compiler ("why is this here?"-like)

>>58474936
TeX by Donald Knuth

>>58428899
>Find one flaw (without mentioning the biggest overriding flaw that ruins the entire thing)!! XD upboats to the left good sirs !!!

fuck off

>>58476670
It looks like shit.

>>58428899
>>58428922
This, terrible logo. If you can't even design a logo I'd hate to see how poorly designed the language is.

>>58474936
TeX by Donald Trump

>>58470297
> no string concatenation
ESR literally did not read the tutorial: https://doc.rust-lang.org/book/strings.html#concatenation

> no epoll/select
C/C++ also have no epoll/select in their standard library, it's part of the Linux API.

> no strong BDFL
There is a core team that essentially act like BDFL. Also not always a good thing

>>58480153
[citation needed]

>>58474938
>>58477316
I think that was already a given, considering how there at least 2 OS that are made in Rust. So the language is mature enough to have its own tools written in Rust.

>>58474628
1. The USSR was socialist, not communist.
2. Karl Marx was dead long before the October revolution.
3. Capitalism, against which communism stands, has killed so much more people than communism. It's about to destroy mankind.

>>58483296
>Capitalism, against which communism stands, has killed so much more people than communism. It's about to destroy mankind.

LAUGHING_WOMEN.TIFF

Do you even KNOW what capitalism is? Fucking fag.

>>58480866
Nice meme.