These are the only good programming languages. if you use anything else, you are doing it wrong

these are the only good programming languages. if you use anything else, you are doing it wrong.

Attached: rusterlang.png (1015x512, 140K)

Other urls found in this thread:

julialang.org/
youtube.com/watch?v=xrIjfIjssLE
nerves-project.org/
techempower.com/benchmarks/#section=data-r16&hw=ph&test=plaintext
benchmarksgame-team.pages.debian.net/benchmarksgame/faster/erlang.html
erlang.org/faq/introduction.html#idp32114576
github.com/rust-lang/rust/issues/34486
twitter.com/SFWRedditGifs

>Erlang
Fuck off.

Rust only exists because Mozilla's devs are too stupid to use C++.

>guys we don't know how to write C++, one of the most used languages nowadays with a huge community behind and a C-like syntax which is used in most languages
>let's create a whole new language using OCaml to write the first compiler because that's much easier than having our devs learn C++ or hiring new developers fluent in cpp

That's how stupid you look

Attached: IMG_20180731_183357.jpg (450x364, 9K)

the only practical functional language. suck it haskellfagot.

Google basically did the same thing with Go. They invented Go because the devs they hire are too stupid to write C++.

go is c++ minus features plus greenthreads and garbage collection, whereas rust is c++ but with the modern parts being easier to write than the "c with classes" parts and mandatory static analysis

they're not really comparable

What about Elixir?

Isn't Elixir just Erlang with Ruby syntax? It's probably fine if so, although there wasn't any real need for different syntax.

elixir has interface-based polymorphism and macro metaprogramming on top. plus new project management, not sure if this was an improvement on some say

Erlang is bretty good

ats > mlton ~= adga > all

OCaml is unironically much nicer for a compiler frontend than anything else though.

If you aren't writing in assembly language you aren't a real programmer

AHAHAHAHAHAHAHAHAHAHAH

Attached: rust-vs-cpp.png (1364x672, 116K)

You are a stupid fag, who doesn't understand anything about programming.

There isn't a "only good" programming language.
A programming language is a tool and you should use it, when you need it.

You program a PE packer?
>Probably not Rust or Erland, except you are a total retard. C and ASM is the right choice.

You program for an embedded *NIX system?
>C, maybe C++ but not bloated Rust or Erlang.

An GUI application without any performance requirement
>Whatever you want but you can minimize the cost by using a easy language like Python.

I like Julia better than both of these ( julialang.org/ ). But then again, I mostly do the stuff it was designed to be good at.

I dislike Rust because typeclasses/traits aren't even powerful enough to let me generically define an implementation for all instances of an abstract data type (for example, I can't generically define fold for all concrete implementations of a heap). I dislike Erlang because it basically doesn't have a type system and doesn't have any form of ad-hoc polymorphism, runtime or otherwise.

Attached: Julialogo.png (370x208, 10K)

>const int&
lol

Attached: Screenshot_2018-08-04_15-31-38.png (1087x263, 34K)

Is this a troll?

>rust
kek

kino
youtube.com/watch?v=xrIjfIjssLE

Why do you think Rust is more bloated than C++?

it currently carries around jemalloc by default. you can disable that and use the system allocator already though, and that'll be the default soon enough

jemalloc is a better default than system malloc unless a 500 kb binary is too big for you. Rust isn't GCed and it has pointers, so it's subject to memory fragmentation if you don't use a non-fragmenting allocator.

>jemalloc is a better default than system malloc
My personal comparisons have shown them to be generally the same for my purposes.
>it's subject to memory fragmentation if you don't use a non-fragmenting allocator.
What system allocator doesn't take pains to prevent fragmentation?

>when you try to be cool and get utterly btfo

Python + C/C++ = GOD

I mean, Rust does the same thing when you take b by copy. C++ still gets BTFO when taking by reference, though.

Attached: 20180804godbolttakebbyvalue.png (630x156, 13K)

Why does Rust look so disgusting?

ATS is the ultimate language to learn, admire and not use.

the size of your integers is important enough to your program to be made explicit, especially when the alternative is garbage like "long long"
a variable is better off being mistakenly constant than being mistakenly mutable since the former can be fixed by just slapping muts while the latter is part of your API. this is especially bad with c/c++'s shallow const model
visibility is good
types after variable names is the only remaining distinction; being able to distinguish between type name and variable name easily by looking at the colon is neat, but other than that this is largely personal preference and not something that makes rust "ugly"

compared to what?

nerves-project.org/

Attached: 1527935640690.jpg (900x1200, 181K)

So if I'm using the Erlang VM for a distributed embedded systems project, would it be better to use Erlang or Elixir?

We use Elixir in our embedded products at the company I work at, but it's mostly because we just like it better and it works. I imagine Erlang would be at least slightly better suited for it.

Erlang is the good language of the two though.

WHat I don't understand is, if Erlang and Elixir are so great at concurrent request handling and networking, why aren't they found in the top spots of
techempower.com/benchmarks/#section=data-r16&hw=ph&test=plaintext

RUST FAGGOT ETERNALLY HEMORAGGING BUTTHURT BLOOD HOLY FUCKING SHIT

Who takes an integer constant by reference? Seriously? Learn some C++

>t. Stroustrup Internet Defense Force

benchmarksgame-team.pages.debian.net/benchmarksgame/faster/erlang.html

oof, erlang slow

imagine it scaled to an actual class, it's a minimized example for fuck sake

>Who made Rust?
>Insufferable and insurmountable faggot detected

The the generated code would be different too. But hey, don't let me get in the way of your Rust faggotry!

Erlang is gold for the poser fizzbuzz kids on this board
>holy shit, a niche language with niche professional use and some epic meme features, this is incredible! I am an expert now and you should be using this or else.

no it would be the same C++ embarrassment, just multiple times

why would you use c++ for that user

Jesus Christ, it's worse than javascript

Attached: Screen Shot 2018-08-04 at 2.24.09 PM.png (984x226, 35K)

>one to two orders of magnitude slower than JAVA
lol erlang

This! You can get just about anything done with those.

Attached: two_types_of_people.jpg (236x219, 20K)

that's not surprising, JavaScript is pretty damn fast

to be fair, Java is pretty fast and even faster than those benchmarks (since those benchmarks don't pre-warm the JVM)

no it's fucking slow compared to Java/C/C++/C#/Rust/Go
Not just in those benchmarks but in the techempower ones too. JS being fast is a meme.

id rather have C# as a scripting interface

>JS being fast is a meme
At least it's not Python

Attached: Screen Shot 2018-08-04 at 2.39.07 PM.png (249x222, 18K)

best case 30x python is not good

Doing n-body simulations in pure Python is a horrific idea, why would you even want to do that?

You wouldn't, because Python is slow

So rust automatically ensures that there is no pointer aliasing?

Attached: C.png (1269x203, 32K)

mutable aliasing, the immutable is fine
weird that C++ doesn't have anything like restrict pointer without compiler extension, not even std::unique_ptr

>doubles down after BTFO
rust pilpul isn't gonna work son

The way you do heavy computation in python is to write mathematics code in C++ wrapped in a python object and then use that python object with the rest of your application. You can get native performance that way while still having a nice easy to use python module for interacting with the math code

>BTFO
you changed the parameters of the problem only to ignore that C++ isn't even better in the changed problem ()

>You fucking shitlord you called out my strawman!
Why would you ever use a reference const integer

>how stupid you look
>glass house
The stench of failure is starting to surround Rust
The only major production application with any significant amount of Rust is Firefox Quantum
Since release, the only thing Firefox leaks faster than memory is its userbase
Rust is memory "safe" though. Leaking memory is "safe"
Rust is safer than C because Rust binaries depend on libc
Rust is high performance. That's why it gets annihilated by JVM based Vert.x in techempower benchmarks
Rust never even managed to put together a native IDE
The Xi text editor is a half done research project, I've never seen anyone use it seriously
Without bolt-on solutions like Eclipse or Idea's Rust support, they wouldn't have anything
There still isn't decent libraries for core functionality like dates or crypto
ESR pitted Rust vs Go for a new project, Go won
Rust compiles are horrible and slow
Rust is "low level." It doesn't even compile itself to machine code, just LLVM IR
Rust hello world is more than half a megabyte
There are no Rust jobs
Rust has a code of conduct about inclusivity
Their community outreach team is lead by Ashley "Kill all men" Williams

>Repost the same garbage in each thread
>Don't bother supporting it when anyone points out how dumb it is.
Why are you so mad about Rust existing?

>someone makes credible points
>derails my shill thread
>Can't ban this user from my 'community'

Attached: download.jpg (601x508, 28K)

>I'm retarded because they're retarded
>Posts a photo of a cat instead of anyone looking stupid
What a trainwreck of a post.

rust is an extremely well-designed lang and it solves a lot of the problems of the embedded world quite elegantly. I'm really hoping it gets more popular, my industry could benefit from it.
Haskell and Scala cover both realms where Erlang could be a viable option, but both langs do it better than Erlang.

Rust and C++ are wildly different langs in application

>Rust never even managed to put together a native IDE
the never needed to because the Jetbrains plugin is excellent. Even if there was a Rust-specific IDE, I wouldn't use it because I like CLion. Don't make developers change IDEs when they don't have to.
>Rust is "low level." It doesn't even compile itself to machine code, just LLVM IR
Explain the ARM Rust toolchain
>Rust has a code of conduct about inclusivity
if you actually think about programming languages in terms of politics, you either have never had a job, or don't deserve the one you have
>There still isn't decent libraries for core functionality like dates or crypto
and yet it's 2018 and C++ still doesn't have a package manager or a proper package management utility.

Attached: lolol.png (288x215, 6K)

erlang.org/faq/introduction.html#idp32114576
>Most (all?) large systems developed using Erlang make heavy use of C for low-level code, leaving Erlang to manage the parts which tend to be complex in other languages, like controlling systems spread across several machines and implementing complex protocol logic.
Erlang/OTP is for building complex distributed systems. Number crunching is offloaded to glorious C.

>Haskell and Scala cover both realms where Erlang could be a viable option, but both langs do it better than Erlang.
provide examples. they're all functional, yes, but Erlang has a very specific target domain that Scala and Haskell don't cover.

Attached: 1362287093416.jpg (643x636, 181K)

>Jetbrains
>excellent
pick one
>if there was a Rust-specific IDE
then rust developers could contribute to the success of the platform
instead of waiting for Java developers to throw you a bone
>Explain the ARM Rust toolchain
implying the arm toolchains don't use llvm
github.com/rust-lang/rust/issues/34486
>if you actually think about programming languages in terms of politics, you either have never had a job, or don't deserve the one you have
No wonder there are no rust jobs, because all they care about is politics
>and yet it's 2018 and C++
puhlease, cargo is shit
vulnerable to typosquatting
doesn't the signed packages
because, as mentioned, jack shit for good crypto libs

in what universe does anyone want a rust specific ide, even if there was one you'd be bitching it's not muh vim

>in what universe does anyone want a rust specific ide
see
>these are the only good programming languages. if you use anything else, you are doing it wrong.
Oh, wait, we're cool with Java now because we're too incompetent to produce our own IDE?

>Oh, wait, we're cool with Java now because we're too incompetent to produce our own IDE?
he fell for the hating java meme lol

walking it back now
thinking nobody will notice
>erlang,rust
>if you use anything else, you are doing it wrong
>anything else

>puhlease, cargo is shit
>vulnerable to typosquatting
>doesn't the signed packages
at least it exists, go back to your feature-bloated clusterfuck of a 1995 memelang
>because, as mentioned, jack shit for good crypto libs
rustotpony
schannel-rs
rust-security-framework
rust-openssl
rust-native-tls
rooster
rncryptor-rs
rust-djangohashers
mpw-rs
hashes
octavo
suruga
exonum
libblockchain
sodiumoxide
rust-crypto
rustls
orion
webpki
ring
suicide is always an option user

Great, then you have signed packages now...
oh
you don't
do you?
gee, all of those crypto libs, and all of them are garbage,
because you can't implement signed packages with even one of them
which means none of them can be trusted
>well if you just review every line of code in all your packages every time you download them
lol
rust evangelists

>The way you do heavy computation in python is to write it in a different language
okay

It's not as silly as it sounds. You build the small performance-critical parts in another language, and then you write the actual logic of the program in Python.

Sounds like a scripting language

Kek, Erlang is worthless unless your hardware is free, because it's so goddamn slow that you will need 20 times the cpu power for the same performance as most other languages deliver.

>Erlang
>Performance
Retard.

It's usually not small though. Ideally pretty much everything hhappens in a C library. See tensorflow, most of it is the C library. You can create a neural net in few lines of Python, true, but I could have done it in C++ too if I had the API.

>I could have done it in C++ too if I had the API
Why would you want to? Performance-critical parts are already in C++, you can happily glue them together in Python.

All of these are unironically true. Rust is a useless mess and if you want memory saftey you just follow a few simple guidelines in c++

>if you want memory saftey you just follow a few simple guidelines in c++
lmfao

the syntax for proper c++ that follows those guidelines is 10000 times worse than rust's. the compiler also doesn't toss out code that doesn't follow those guidelines in c++, whereas it does in rust.

>... devs are too stupid to ...
This is why python exists.

99% of the Rust users could just use a GC'ed language.

Why do you people keep arguing about languages when you've never written a non-trivial program?

Here are some more truth pills:
- Unsafe is Rust's forbidden fruit and will be the most popular feature among non-hobbyists. Why fight the Rust compiler for days when an unsafe solves all your problems in a second?
- Cargo isn't better than any other package manager and their """build scripts""" are pure crap
- The whole "fearless concurrency" thing is BS. Rust forces you to use all these run-time checked data structures any sane programmer would use in their concurrent programs anyway.
- Rust abstractions are shit, just look at the over-engineered mess they constantly produce. Look at tokio, they turned a simple concept into pure madness. Want more? quote crate, they do a breaking change with every x.x.1 version bump, working with that shit is mind-numbing. Using hyper made me seriously consider sending HTTP request as raw strings over sockets. Clap is terrible and your builds will take a minute if you add that freaking COMMAND LINE FLAG PARSER.

>more garlic error handling? DUUUDE JUST LET IT FAILLL LAWWWWWL

>Rust
Lmao. Bet you also like taking dick.

>rust
>bloated

Attached: rustvsc.png (1833x782, 76K)

>garlic error handling
huh?

And the top will still become a 5MB binary

if you build with debugging info enabled, then yes. the C build with debug info will be smaller but this doesn't matter in production