Count to 1 billion

I agree with @superfola, I believe we need more insight on your methodology.

On a different hardware I got results similar to yours only for Node.Js and PHP 8.1, while Rust was totally different.

<?php
$i=0;
while($i < 1000000000){
        $i++;
}

This little guy got 26 seconds to run:

$: time php count.php 

real    0m26,712s
user    0m26,504s
sys     0m0,046s

Node 18. performed slightly better on my HW:

let i = 0;
while (i < 1000000000){
    i++;
}

❯ time node index.js 

real    0m0,888s
user    0m0,873s
sys     0m0,010s

While Rust took almost no time:

fn main() {
    let mut n  = 0;
    while n <= 1000000000 {
        n+=1;
    }
}

❯ cargo build --release
...
❯ time target/release/count

real    0m0,004s
user    0m0,003s
sys     0m0,001s

With debug symbols the situation changes perceptibly:

❯ cargo build 
...
❯ time target/debug/count 

real    0m3,315s
user    0m3,291s
sys     0m0,008s

Obviously these are not proper benchmarks but does help us understand the magnitude of execution time.

I suspect you did count the build time of cargo and the runtime of the program, not the actual program running, but we need more info to be sure.
Possibly the same with C++.

Interesting! I suspect the JIT compiled languages here (C#, Node.js) are optimising out the loop since it doesn't do anything, as would C++ and probably other AOT compilers if told to optimise (eg: -O3) If you called say a random number generator, that the optimiser cannot predict (eg: rand() in C++) on each iteration, you might find things are very different; performance measurement is hard 😄

Your results might be like this because of the type of builds you produced. Since you are measure a quite trivial operation (an addition), I would have expected C++ to be on top, with Rust alongside.

Did you compile in release mode?

I would be interested to see a another test done using the count variable as a reference type and having to do heap access for each iteration. There should be decent resolution using a fraction of the iterations to see the difference (something like 10 million might be enough), but this would be telling as well for each language. I'm not set up for all of these languages or I would do this myself.

Python is the worst performer. I don't know the exact reason for this behavior

That's because python's autour has always prioritized people's needs over micro benchmarks and I think that's the right trade off.

People who want to do C++ style super low level stuff already have C++

Rust is very slow when it's in dev mode because of all its extra features. Those are removed in production and executes extremely fast. Perhaps you should get a benchmark of that in prod mode?

(Btw, I was really surprised that NodeJS made the top. I tried some of those myself and you were surprisingly correct!)

Hmmmm, I got quite different results on the M1 Pro. All tests fell withing the 1-4 secs range

Every time I run this in php, I get 5-6 seconds.

Interesting 👍 Could you add Lua please? Very curious about this one but won’t be able to reproduce the setup unfortunately.

good info

In C# you can do this much faster
I was running the folliwing code (using Benchmark)

I runit on Intel i7, 2 core and the results in C# or in milliseconds, not seconds :)

** Standard, your code

public void CountTo1BPlusPlus()
        {
            int count = 0;
            for (int i = 0; i < 1000000000; i++)
                count++;
        }

** Standard, Assign code (slower)

public void CountTo1B()
        {
            int count = 0;
            for (int i = 0; i < 1000000000; i++)
                count=i;
        }

** Foreach and Range (Slower)

public void CountTo1BRange()
        {
            int count = 0;
            foreach (int index in Enumerable.Range(0, 1000000000))
                count++;
        }

** Foreach (much slower)

 public void CountTo1BForEach()
        {
            int count = 0;
            Enumerable.Range(1, 1000000000).ToList().ForEach(i => count++);
        }

I'm surprised C++ is so slow. Almost as if it wasn't compiled with optimizations enabled -O3.

This is like the most stupid way of doing things i've seen in a while ...
I'll illustrate some differences in PHP.

First of all i will time only the loop inside the script not the whole execution because it has nothing to do with the speed of the code itself.

1)
First way of doing things (the incredible stupid way of doing things illustrated by the OP) using range inside a for loop... for real are we timing creation of arrays or counting ?

2)
Now let's mix it up a little and do something crazy like for example taking out of the loop the part where u generate an array of 1 billion elements...

3)
Now that we got the totally stupid ways of doing things out of the way let's look into more ways to skin this cat ... how about using a while loop since for is not really useful in this case cause we have no need of knowing the current index of the loop.

4)
How about using the language as it is intended, did u know PHP has JIT ? Let's write the code in a form that takes advantage of that.

In conclusion:
Stop misleading people with this BS about one language being better than the other when you obviously use them wrong and have no clue what you are doing.
Someone just starting looking on what language to learn may read your post and take it for real and make a real life decision based on that because he doesn't know any better.

Do you think, in a coding interview, it would be fair to assume solutions in these languages would run at the equal time?