Is Rust a meme?

> muuh security
> alien syntax
> I can't handle C++

hahahahahaha

Other urls found in this thread:

air.mozilla.org/bay-area-rust-meetup-february-2016/#@25m50s
youtube.com/watch?v=QM1iUe6IofM)
cvedetails.com/product/19997/Google-Android.html?vendor_id=1224
cvedetails.com/product/15031/Google-Chrome.html?vendor_id=1224
cvedetails.com/product/3264/Mozilla-Firefox.html?vendor_id=452
cvedetails.com/product/9900/Microsoft-Internet-Explorer.html?vendor_id=26
github.com/redox-os/redox
tiobe.com/tiobe-index/
githut.info/
doc.rust-lang.org/book/ownership.html#meta
github.com/servo/rust-smallvec
twitter.com/AnonBabble

botnet

>>muh security
30+ years of buffer overflows, use-after-free exploits, and memory leaks have proved that this is by far the most important metric in evaluating systems programming languages

>>alien syntax
not an argument

>>I can't handle C++
I'd rather not waste another 9 years of my life just to understand the typical compilation error message

Your whole life is a meme.

Why would anyone use c or c++ when rust and go exist?

The amount of time it takes to develop something is the biggest cost of software, higher level syntax reduces that cost greatly.

epic thread xxd
epic post
c++ is also good
what he said
legacy code
also go sucks

>all those triggered rust fags

Even web developers pity you

you're mama is a botnet

> I can't use the existing tooling to assert my code quality
> I can't follow project guidelines to ensure my product success
> I need redesign everything from scratch because a built-in code analyzer to protect my code from my own stupidity

Good senpai.

> Entire new language because of coroutines
> No generics, no ADT, no immutable types, no pattern matching
> GARBAGE COLLECTOR
> Made by google

Kill yourself.

>muh security
Not having to worry about segfaults or dangling pointers is nice senpai.

>alien syntax
Example?

>I can't handle C++
C++ is a bloated clusterfuck.

ADTs are a meme. Use unions. Pattern matching is also a meme. This is what OOP is for in the first place.

> I can't use tooling made for another language with this other language

How is this even an argumet?

You're missing the point. Rust doesn't perform any checks that you couldn't already perform using existing tools on a C++ codebase. The entire language is redundant. The SJWs only made it to use it as leverage in their underhanded power grab.

> The entire language is redundant.

Yes.

Rustfags can't handle the truth.

>legacy code
>like that's a good thing

...

I don't like D but it's the only language out there that can use libraries written in C++.

its a meme. just use go as your system programming language

None of these "modern" (inefficient) languages are suitable for writing embedded software, drivers, or other system components.

Use C.

You can use C code in Rust as i know.

You can also use C code in C! What a concept.

You can use C and C++ code in D as i know.

>tfw immutable save your life

Rust is safer, deal with it.

Who the fuck use D?

Maybe JavaEE runs on your credit card. You have been cucked anyway.

you can use C code in Python if you do
from __future__ import braces

>If I remove "unsafety" my code will work 100% of the time woo hoo! There's no way 100% safe and secure logic errors could be just as bad or worse! Sure glad I learned a babyproofed language that didn't teach me to be thorough at all
>I'm sure glad I wated 9 years of my life to understand the typical borrow checker error message.

C++ sucks balls, but it's the only language with at least barely adequate coverage in every area that matters.

> compiled
> no GC
> straightforward linkage with C
> large set of libraries in the wild plus number of developers who know/use it
> can use varible degree of OOP depending project scale
> standardized templating/metaprogramming

You could technically use C instead of C++ almost anywhere, but sufficiently large projects start taking lives of their own with rats' nests of ad-hoc preprocessor bandaids. It's usually better to use restricted subsets of C++ than try to build up in-house versions of the most common missing idioms.

Rust, D, and Go all lack at least one thing from the list above (foremost the lack of userbase), but Rust will have the hardest time since it tries to be a "fixed" C++ but will only be fully comprehensible to advanced C++ devs who will not be very inclined to jump ship for the most part.

The best parts of C are how long it's been around and how ubiquitous it is. Find me a language that's safer than C but has been around just as long and runs on just as many platforms. Anything else is a joke and instantly disqualified. Looking at Rust here.

ALGOL

...

Python

Please, we're talking about real programming languages.

>this is by far the most important metric in evaluating systems programming languages
Depends on the system and how low-level it is.

>I'd rather not waste another 9 years of my life just to understand the typical compilation error message
Stop using a shit compiler, and read the C++ spec.

>implying D is a real programming language
it's on the level of shittiness and memeness as python

...

Rust doesn't really lend itself to refactoring code. The type system is very strong and there's not much type inference. The type signature of even simple functions can get out of control especially when you have multiple "lifetimes" you have to keep track of.

It's just a really cumbersome language to program in. Not to mention that despite having real modules the compile times are fucking atrocious.

I prefer the direction Jonathan Blow's language "Jai" is going.

oh look, another "x language is superior to y language" thread

every language has a purpose. choose the language for the job you want to do.

Jonathan Blow is an elitist asshole as bad as any college professor but at least he knows how to write a compiler. The imbeciles who built Rust don't have the first clue what they're doing.

Rust is better than C++ and it can replace C and C++, but it's not enough and it's not so obvious. Sometimes you need to know all these languages very well to understand all advantages of Rust. But you need an army of developers to be moved to this lang, without them Rust will remain just another new language and that's it, like D.
If business takes cares of it - Rust will succeed, if doesn't - it's just a waste of time.

LISP

There's substantial corporate backing for it from Mozilla, and to a smaller degree from places like Dropbox and MaidSafe. Rust will succeed if they continue to support it. It's critical for people to use their connections to undermine these companies politically and financially to force them to switch from Rust to D or Go.

Common lisp can as well. In fact, a shitton of languages can. You just have to stop being retarded for about 5 microseconds.

s-smug loli?

I haven't visited Sup Forums in over a year. Thanks for reminding me why I left this shithole.

Thankfully, rust is already orders of magnitude more popular than D and has the libraries to show it. Perhaps we'll finally be able to move out of the dark ages that C forced upon the programming world.

> Change to something worse

rofl

>superior in every single way imaginable
>worse

lmao

>not a chance
What did they mean by this?

It's a joke user. Python is whitespace delimitted. You can use c in Python though.

They meant that python was shit on purpose.

Because C is more lightweight and actually produces competent programmers who know how computers work.

>alien syntax

Literally what? References are &, arrays are [], generics are angle brackets, "static methods" are called with ::, methods and fields are called with the dot operator.

The only "foreign" thing I can think of is the label syntax (a single apostrophe and then an identifier) which can be used to label a loop construct or a specify a region constraint/lifetime.

It is an insanely unoriginal syntax, apart from putting the types after identifiers where they fucking belong.

Neither statement is true.

>Rust doesn't perform any checks that you couldn't already perform using existing tools on a C++ codebase.

That's patently false: Rust prevents data races statically at compile time by way of the Send/Sync markers. The only "equivalent" tooling for other languages is done using imperfect heuristics at runtime, or using htird party libraries which can be ignored accidentally or easily subverted by C/C++'s complete lack of a rigorous type system.

>Rust
>inefficient

Try harder senpai, the fastest font renderer in the world is written in Rust, it's an order of magnitude faster than comparable C/C++ codebases. (10s of microseconds instead of 100s of microseconds.)

Hygienic macros and type-safe generics in a systems programming language are hardly redundant. True these features aren't necessarily novel, but they are usually only seen in functional languages that have godawful performance and large runtimes.

The C preprocessor is a fucking joke.

or learn c++ and realise it's the language for everything

Was, then rust came along.

C++ is the language for everything.
Rust is the language for nothing.

Sepples sheeple everybody

great, until you want to do anything on windows and realise there's no fucking support yet

maybe in 20 years rust and other meme languages will have enough shit to overcome the inertia of c++

maybe c++ will add its one party trick and nobody will care about it

>all these butthurt C++ stockholm syndrome babies
no wonder the web and computing is going nowhere, with all these faggots against progress and improvement lmao

>web faggotry
>c++
you know what century we're in, right?

>but I'm too smart for these types of errors to occur in my code
I really wish this meme would die

>web and computing
should i teach you how to read too now?

Even if that were true, the real issue is when a project grows just beyond you.

Do you trust code written by your coworkers? What about a contractor? What about unemployable NEETs contributing to your FOSS project?

I don't. That phrase is the easiest way to spot a pretentious poseur who hasn't written a single line of C/C++ code in his life.

>100MB Hello World binaries

>30+ years of buffer overflows, use-after-free exploits, and memory leaks have proved that this is by far the most important metric in evaluating systems programming languages
"Safe systems programming language" is an oxymoron.

Why use Rust or Go (meme C replacements) rather than something that's ACTUALLY high-level, like Java or Python?

BASIC

C++ cannot into self-modifying code.

Rust cannot into OOP.

Does Rust have significant support on any platform at this time?

>Java or Python?

Good luck making a kernel in python.

>two items
>sperg out over one not being addressed
go home esl

>is called out on mistake
>ur triggerd!!!11
keep going tho you are doing my job for me kek

>implying C++ isn't web
>implying every web browser isn't written in C++

Servo's WebRender outperforms every browser layout engine in existence by serveral orders of magnitude, and is poised to be integrated into Gecko/Firefox. air.mozilla.org/bay-area-rust-meetup-february-2016/#@25m50s

Enjoy being entirely irrelevant in a few months since you'll never be able to formally prove a highly parallel C++ layout and rasterizer to be thread safe.


>Rust cannot into OOP.

That's a good thing, OOP is the single biggest mistake in the history of computer science. (youtube.com/watch?v=QM1iUe6IofM)

Rust is nothing like a formal proof language. The borrow checker is a hacked together version of memory management rules that programmers apply manually in C++. Existing tools will verify them already in existing codebases.

Rust is D 2.0

but you didn't call me out on a mistake

web is full of interpreted/JIT bullshit (because hacking shit together quick matters more than how solid it is) while computing is doing just fine from what I see around the place

writing web browsers doesn't count as webdev

Good luck making a kernel in anything that isn't C or C++.

>Existing tools will verify them already in existing codebases.

That is empirically false. How about you spend two seconds browsing the CVE database before opening your mouth on Sup Forums.

Existing tools will verify them in C++ at runtime if you have 100% code coverage. In any non-trivial C++ project that quickly becomes intractable.

[1]: cvedetails.com/product/19997/Google-Android.html?vendor_id=1224

[2]: cvedetails.com/product/15031/Google-Chrome.html?vendor_id=1224

[3]: cvedetails.com/product/3264/Mozilla-Firefox.html?vendor_id=452

[4]: cvedetails.com/product/9900/Microsoft-Internet-Explorer.html?vendor_id=26

Are we playing jeaporady?

>What is github.com/redox-os/redox ?

While we're on the subject it's completely possible to program device drivers and embedded systems with Rust. It's almost like it's a fucking systems programming language.

You can easily do it in Rust.

>Rust is more popular than D

What you mean to say is "Rust is more popular on Reddit than D" because the rest of the internet seems to disagree with you:
tiobe.com/tiobe-index/

>tiobe.com/tiobe-index/
>The ratings are based on the number of skilled engineers world-wide, courses and third party vendors. Popular search engines such as Google, Bing, Yahoo!, Wikipedia, Amazon, YouTube and Baidu are used to calculate the ratings.
into the trash it goes

githut.info/

Metaprogramming in C++ is like trying to write your thesis by cutting your dick and using the blood that comes out as ink, but your writing utensils are your toenails that you cut completely off with a hammer.

Technically you can write a kernel in Haskell. That doesn't mean it's a good idea.

but I did, just observe the memory leaks and vulnerabilities produced by C++, tor's furryfox got cucked 5 times due to vulnerabilities in C++ constructs (one related to Array) an isolated language like rust would solve that

Fortunately for Rust, it's not Haskell.

Using Rust isn't what solves the problem. Using Rust also creates new problems you didn't have before, like constantly fighting the borrow checker and its arcane/incomprehensible demands.

> compiled
Rust has it.

> no GC
Rust has it.

> straightforward linkage with C
Rust has it.

> large set of libraries in the wild plus number of developers who know/use it
Rust has it, and cargo is far better at managing dependencies than anything C++ developers have come up with

>can use varible degree of OOP depending project scale
Rust doesn't have this because OOP is a mistake. Though it does have dynamic dispatch of course, which is the only tool you need if you really think OOP "fits" your problem.

> standardized templating/metaprogramming
Rust's hygienic macros & generics are quite literally state of the art. First of all it's hilarious you think the C++ preprocessor is "standardized", second of all it's a pathetic excuse for metaprogramming.

tl;dr: try harder C++uck.

But it is. A strong isolation system with premade constructs will withstand more vulnerability research than something your average game dev / network dev cooks up with his spaghetti code.

>constantly fighting the borrow checker and its arcane/incomprehensible demands.

There are not arcane or incomprehensible. Once you actually learn how to write a Rust program you hardly will ever worry about the borrow checker. You never got over the learning curve.

>large set of libraries
Maybe if you count the Node.js style one liners uploaded by some blowhard webdev.
>large number of developers who know/use it
There are maybe 300 Rust developers worldwide.
>standardized templating/metaprogramming
Rust is incapable of doing something so basic as passing a string or a number as a template parameter.

doc.rust-lang.org/book/ownership.html#meta

>Many new users to Rust experience something we like to call 'fighting with the borrow checker', where the Rust compiler refuses to compile a program that the author thinks is valid. This often happens because the programmer’s mental model of how ownership should work doesn’t match the actual rules that Rust implements. You probably will experience similar things at first. There is good news, however: more experienced Rust developers report that once they work with the rules of the ownership system for a period of time, they fight the borrow checker less and less.

>rust
extern crate redis;
use redis::Commands;

fn do_something(con: &redis::Connection) -> redis::RedisResult {
let _ : () = try!(con.set("my_key", 42));
Ok(())
}

>wahhh, Rust makes me think about how long the memory in this stack frame is valid for

Arcane? Incomprehensible? It's literally a static constraint that your memory is either on the heap, or on a stack frame you haven't popped.

>Rust is incapable of doing something so basic as passing a string or a number as a template parameter.

Passing a string as a "template" parameter is pretty simple:

Passing a number as a template parameter, what do you want to do with that type? If you want to do arithmetic on them then constrain it to any relevant operators from from core::ops, if you want to compare them just constrain it to or

Geez, it's almost like Rust makes you think about what you want to do with generic types, so that you don't end up with thousands of lines of template instantiation errors.

>First of all it's hilarious you think the C++ preprocessor is "standardized", second of all it's a pathetic excuse for metaprogramming.
what does the preprocessor have to do with c++ templates?

Vector

What would this look like in Rust?

What do you think templates are? It's textual substitution, same as your godawful excuse for macros.

"SFINAE" only exists because templates are a preprocessor step unknown to the compiler.

github.com/servo/rust-smallvec


try! harder, we just stabilized the `?` operator ... and if you seriously think exceptions/longjmp is a better solution for routine error handling you're fucking delusional.

Nim?

>let _
>(())
>(((language)))
>RedisResult
>

Nim is great. It's a shame it doesn't have more support

>githut
>Q4/2014

Sweet bro, glad you've found something up to date and you never have to change anything you think about anything. You're seem like a real smart dude who knows that gitbuh wouldn't favor web programming and the memes that come from web programmers, sweet bro, you're smart :+1: let's dock dicks later at the new coffee place that's better and more organic than Starbucks.

Rust was created because Mozilla filled up with SJWs, and those people are too stupid for C++.