You can't spell trust without Rust

>Doesn't understand that his graph shows that the average Rust program is slower than 75% of C++ programs.
Rustfags are so retarded they're completely mathematically illiterate.

>Is any of it's implementations mantained to the extent of the GHC?
no, ML is just for mental masturbation.
go with OCaml.

Why SBCL is so fast tho, isn't Lisp a dynamically typed shit?

Is there a source for this or is it another meme chart?

> he doesn't know about the benchmark game
benchmarksgame-team.pages.debian.net/benchmarksgame/

How the fuck are not only Haskell and Rust, but also fucking Java safer than ML?
SML code compiled with MLton is often faster than similar Haskell code compiled with GHC. Standard ML is a standardized, frozen language like Common Lisp, so MLton doesn't need to be maintained to the same extent.

I tried rust and all the popular libs were at version 0.1, is shilling for this meme some sort of an inside joke?

You can't spell turds without rust

brainlet here
how do i read this?

en.wikipedia.org/wiki/Box_plot
They werk well enough. People are just too conservative with thei semver
>by a factor of less than 2
>by a language this young
There's so much room to get it way better

The box is the region which the average 50% of programs reside in. The line in the middle of the box is the exact average. The bars connected by lines to the box) show the range of all programs, except statistical outliers (the detached bars)

>>by a factor of less than 2
If a factor of 2 doesn't matter then a factor of 3 doesn't either and you can use Lisp instead.

What are you talking about? Rust is slower by several percents, not by a factor of 2.

Attached: rust_cpp.png (729x2645, 158K)

sbcl is a compiler, it figures out a lot of things analyzing the code to make the program faster it's not being interpreted

C++ is faster than C

It's actually even slower than it appears because the chart is logarithmic

Thanks, guys.

This

Meme chart, or the one making the test had no fucking idea of what were they doing. C > C++, and Ada can even be faster than C if you formally verify everything at compile time and disable checks after that.

C benchmarks faster than C++ almost all of the time, excluding some contrived benchmarks.
How can C++ be considered to be "fast" when it doesn't even has basic shit like restrict pointers?

std::unique_ptr?

std::sort is faster than qsort because of monomorphisation.

>monomorphisation
What is that?

Generating a specialized version of a template function based on the arguments.

Is that different from template specialisations? Like one templated function which contains several different function signatures with different implementations?

You can't spell discotheque without C.
You can't spell agony without Go.

> Is that different from template specialisations?
Yes, but it's somewhat close, monomorphisation is performed by the compiler at the compile time based on the template function definition. I.e. if you have a template function `template foo(T t)`, it's not present in the resulting binary, only monomorphized versions with the concrete types like `foo` and `foo` are.

Oh I see, so monomorphisation is just the word that refers to the action the compiler takes to generate different functions depending on the invocations of the templated function in the source, meaning there is no run-time overhead for using templated functions in C++. Thank you

You can't get iron putrefaction without Rust.

Can someone add ColdFusion above and to the right of Rust?

Restrict pointers suck. If you want to assert that two pointers do not alias, then just make the assertion.

That's not the point of restrict, retard.

Define restrict in your own terms then.

Implement SML on CL.

HOL4 seems to be around and maintained, that would suggest at least Poly/ML gets maintenance.

>not using C++ for desktop software
>not using Go for web dev

>HOL4
and Isabelle

>faster
most of the time haskell and ml will perform similar. but it's easier to write predictably fast code in SML than in haskell, because sml is strict.
also, several sml compilers have true multicore. haskells multicore libraries are much harder to use and ocaml doesn't really have a true working multicore implementation yet.
> Is any of it's implementations mantained to the extent of the GHC?
there are several maintained implementations. the ml community is tiny though compared to haskell and the language was standardized in 1997 and hasn't changed since. therefore implementations are pretty stable and don't change much.
noteworthy implementations that are actively maintained are smlnj, mlton, polyml.

>SBCL beating Java

Whew lads, is it the year of Common Lisp's return finally?

Here's a funny.
Some ARM chips have hardware based JavaScript acceleration now.
If Sun hadn't interfered with the language's development, people would now be walking around with lisp machines in their pockets.