Why did the benchmark game drop Scala and Clojure from the comparison...

Why did the benchmark game drop Scala and Clojure from the comparison, but keep irrelevant languages like Pascal or Chapel?

Other urls found in this thread:

rosettacode.org/wiki/Closures/Value_capture#Rust
rosettacode.org/wiki/Closures/Value_capture#Ada
haskell.cs.yale.edu/wp-content/uploads/2011/03/HaskellVsAda-NSWC.pdf
twitter.com/NSFWRedditImage

>for some languages the 1st and 3rd quartiles' distance to median is larger than the others' combined
>statistically significant
Pick one

>why no scala and clojure
They run in the JVM, whereas these languages run natively.

Also
>boxplots on a logarithmic scale
Indicates that some of them are really, really long-tail distributions I guess. That shit is just confusing.

Because they are either same as Java or slower.

That depends on the benchmark. A recursion test would be significantly faster in Scala than in Java, because the Scala compiler is able to do TCO.

But they include F#, which runs on the CLR and has far less users than Scala.

Why was rust invented when Ada was already around?

CLR works differently than the JVM, it's not a virtual machine in the same sense.

Because webhipsters gonna hip. There's a reason why they prefer writing everything from scratch all the time.

>They run in the JVM, whereas these languages run natively.
Idiot. Scala and Closure are slower than Java

>irrelevant languages
>Pascal
kys

Does it make you upset?

See Also
>implying GCJ doesn't compile Java to native code

...

When even C has aged better, you know your language was objectively shit.

>April, Rust is an awkward middle point between C and C++
>March, Rust strong and faster than C++
What went so right? Is Rust compiler a work of true art?

Ada has some nice features, but it is verbose as fuck and lacks a bunch of modern features.

Compare this rust snippet:
rosettacode.org/wiki/Closures/Value_capture#Rust

with the equivalent Ada:
rosettacode.org/wiki/Closures/Value_capture#Ada

See and I'm questioning the statistical significance of the benchmarks.

Thanks for quoting yourself. I'm really convinced now

The benchmarks are good if you want a rough idea of how well a language performs. If there's a factor of 2x between two languages with a large user base, that's significant.

Then there are perfectly accurate cases like Fortran, which does really really well on the benchmarks that do stuff that Fortran is optimized for, and terribly on the others.

If two languages are within 20% of each other on most benchmarks, with a few outliers, then it's not statistically significant enough to make solid conclusions. It just states that they are very roughly comparable.

>If two languages are within 20% of each other on most benchmarks, with a few outliers, then it's not statistically significant enough to make solid conclusions. It just states that they are very roughly comparable.
Who said these?

The guy you quoted

Literally who?

Because both trying to be "safe" doesn't mean they're equivalent, Rust has an advantage of being 30 years younger and thus implementing many good ideas from the PL theory what have happened in the last 30 years or so, like ADT and linear types. Ada has to rely on (highly optimized) naive run-time checks.

In real-world programming, closures are very rarely used, so this is a false comparison.
I wish I knew a good word for these imaginary problems that get hyped up to push an agenda. Like global warming.

> In real-world programming, closures are very rarely used
This is where you're wrong, kiddo.

Most real-world programming is embedded code, where dynamic allocation is considered harmful.

> Most real-world programming is embedded code
Embedded programming it too primitive to be considered a proper programming, m8, it's just a branch of EE. You might as well call JS "real-world programming".

It's real programming because it's close to the metal.
JS is the toxic spawn of academia. It's layer on layer of abstractions, totally removed from reality.

How being close to metal makes it more real? Low-level programming, while being hard, is at the same time algorithmically primitive and its design is mostly driven by the underlying hardware.
>JS
>academia
You have no idea, don't you?

Pascal was created mainly for teaching programming to newfags. We'd use interpreted languages like Python or Ruby for that now.

>In real-world programming, closures are very rarely used
Our C++ code at work is full of them

I loled. They are only "rarely used" in languages where they require a lot of boilerplate.

There is a huge class of problems which can be solved in a couple lines with a closure, which would require tons of boilerplate in Ada.

This old paper is a good example: haskell.cs.yale.edu/wp-content/uploads/2011/03/HaskellVsAda-NSWC.pdf

Ada and old C++ had no closures, so the solution was long. Lisp, Haskell, and the scripting languages had them, so they solved them trivially.

I'm surprised by the Swift benchmark. I thought that the LLVM backend could generate something equivalent to C++

Swift is slow because it's dynamically typed and reference counted under the hood.

Those are two features of the language, but you cannot prove that those are the main performance detractors.

Swift does really, really well on the benchmark, it beats both Java and Go.

It's just not as optimizeable as C/C++/Rust, and even if it was the benchmarks for those three languages have been crazy microoptimized by the submitters so writing a Swift program that approaches them in speed is far from easy.

Why is Go so shit despite having much fewer language features than Swift or Java?

Rust and C++ now both allow you to return unboxed closures from functions. No heap allocations are required, you can assign them to stack variables.

Because google programmers are too stupid to appreciate a "good" language. They only have experience with Python and Java.