Benchmarck (comparação de velocidade) Python, C, Java, Javascript, C++, Kotlin, Go

anotacao.txt

machine:
alex@alex-Aspire-V3-571:~$ lscpu 
Arquitetura:           x86_64
Modo(s) operacional da CPU32-bit, 64-bit
Byte Order:            Little Endian
CPU(s):                4
On-line CPU(s) list:   0-3
Thread(s) per núcleo  2
Núcleo(s) por soquete:2
Soquete(s):            1
Nó(s) de NUMA:        1
ID de fornecedor:      GenuineIntel
Família da CPU:       6
Modelo:                58
Step:                  9
CPU MHz:               2601.000
BogoMIPS:              5187.86
Virtualização:       VT-x
cache de L1d:          32K
cache de L1i:          32K
cache de L2:           256K
cache de L3:           3072K
NUMA node0 CPU(s):     0-3


python 2.7:
alex@alex-Aspire-V3-571:~/Documentos/cod-cursos/benchmark$ time python python.py 
499500

real	0m0.019s
user	0m0.008s
sys	0m0.011s


python 3.4:
alex@alex-Aspire-V3-571:~/Documentos/cod-cursos/benchmark$ time python3 python.py 
499500

real	0m0.025s
user	0m0.025s
sys	0m0.000s


c:
alex@alex-Aspire-V3-571:~/Documentos/cod-cursos/benchmark$ time ./c-lang 
499500
real	0m0.002s
user	0m0.000s
sys	0m0.001s


js
alex@alex-Aspire-V3-571:~/Documentos/cod-cursos/benchmark$ time node nodejs.js 
499500

real	0m0.047s
user	0m0.040s
sys	0m0.008s

java7
alex@alex-Aspire-V3-571:~/Documentos/cod-cursos/benchmark$ time java Java
499500

real	0m0.077s
user	0m0.066s
sys	0m0.012s


c++
alex@alex-Aspire-V3-571:~/Documentos/cod-cursos/benchmark$ g++ -std=c++11 cpp.cpp -o cpp
alex@alex-Aspire-V3-571:~/Documentos/cod-cursos/benchmark$ time ./cpp
499500

real	0m0.003s
user	0m0.002s
sys	0m0.000s

ruby # contribuition from ruannawe
ruan@ruan-Inspiron-5457:~/Documents/ruby$ ruby executiontime.rb
499500

user: 0.000046
system: 0.000007
total: 0.000053
real: 0.000053

kotlin 1.3 
alex@pc:~/workspace/scripts$ kotlinc kotlin.kt
alex@pc:~/workspace/scripts$ time java KotlinKt 
499500

real	0m0,058s
user	0m0,071s
sys	0m0,009s

go 1.12
alex@pc:~/workspace/scripts$ time ./bm
499500

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

bm.go

package main

import "fmt"

func main() {
    var count = 0
    for  i:=0; i < 1000; i++ {
	      count += i
    }
    fmt.Printf("%d\n", count)
}

c_language.c

#include <stdio.h>

int main(){
  int count = 0;
  int i = 0;
  for(i; i<1000; i++){
    count += i;
  }
  printf("%d", count);
}

considerações

Eu já tinha visto alguns desses testes antes.
E também até já ouvi falar que Java é mais rápido do que C.
E que Python é lento. 
Nada é melhor do que faça você mesmo para tirar suas conclusões.

Meu computador é um Acer com OS gnu-linux (Ubuntu-14.04), processador i5.

Conclusão:
  Eu gosto bastaste de Python mas não tem um bom suporte para multicore.
  Kotlin pode ser um excelente escolha para desenvolver Aplicações e Go para Sistemas.
  A velocidade de linguages baseadas na JVM pode melhorar consideralvmente com Graaval.

cpp.cpp

#include <iostream>

int main (){
    unsigned int i, count=0;
    for(i=0; i<1000; ++i){
        count += i;
    }
    std::cout << count << std::endl;
    return 0;
}

Java.java

public class Java {
    public static void main(String[] args) {
        int count = 0;
        for(int i=0; i<1000; i++){
          count += i;
        }
        System.out.println(count); // corrigido conforme comentario
    }
}

Kotlin.kt

fun main() {
   var count = 0
   repeat(1000) {
      count += it
   }
   println(count)
}

nodejs.js

'use strict';

var count = 0;
for(var i=0; i<1000; i++)
  count += i;

console.log(count);

python.py

count = 0
for i in range(1000):
    count += i

print(count)

@vini29
O código que você propôs da erro de sintase.
O mínimo de código seria:

for i in range(1000): i += 1
print(i)

Porém não chega a ser mais rápido.
Agradeço o seu comentário, não respondi porque só vi agora mais de 2 anos depois.

machine

Architecture: x86_64
CPU op-mode(s): 32-bit, 64-bit
Byte Order: Little Endian
CPU(s): 4
On-line CPU(s) list: 0-3
Thread(s) per core: 2
Core(s) per socket: 2
Socket(s): 1
NUMA node(s): 1
Vendor ID: GenuineIntel
CPU family: 6
Model: 78
Model name: Intel(R) Core(TM) i7-6500U CPU @ 2.50GHz
Stepping: 3
CPU MHz: 984.453
CPU max MHz: 3100,0000
CPU min MHz: 400,0000
BogoMIPS: 5184.00
Virtualization: VT-x
L1d cache: 32K
L1i cache: 32K
L2 cache: 256K
L3 cache: 4096K
NUMA node0 CPU(s): 0-3

Ruby 2.5.0

ruan@ruan-Inspiron-5457:~/Documents/ruby$ ruby executiontime.rb

user: 0.000046
system: 0.000007
total: 0.000053
real: 0.000053

Code

require 'benchmark'

count = 0
Benchmark.bm(7) do |x|
  x.report('for:') do
    for i in 1..1000
      count += i
    end
  end
end

O Java não precisava somar o número em uma string, poderia ser direto System.out.println(count);
Isso não mudaria muito o desempenho, eu acho kkkk...
Em C++ tem algum objetivo de usar o unsigned int i ?

Podia ter feito computações mais agressivas, multiplicações de matrizes por exemplo. Em um programa tão simples, Python e principalmente Java levam desvantagem

@pmatos2000 nada especial em usar esse tipo em C++, mas ele cabe perfeitamente nesse caso.
Porque são inteiros positivos.