Programming language raw performance tests

Some simple tests measuring performance of programming languages. Maybe not so scientific, it just provides a brief concept.

Here are the results for Fibonacci sequence fib(40) using recursive function calls, single-threaded, on Thinkpad X200, Ubuntu 14.04:

Group 1

Language	Finished in seconds
C/gcc 4.8.4 (no optimization)	2s
C/gcc 4.8.4 (-O3 optimization)	0.37s
C/clang 4.0.1 (no optimization)	2.08s
C/clang 4.0.1 (-O3 optimization)	1.13s
Rust 1.23.0 (no optimization)	2.4s
Rust 1.23.0 (-O optimization)	0.8s
Swift 5.11-dev (no optimization)	2.5s
Swift 5.11-dev (-O optimization)	1.57s
Go 1.9.2 (go run)	2.25s
Go 1.9.2 (compiled)	1.97s
OCaml 4.02.3	1.48s
F# 3.0	1.45s

Group 2

Language	Finished in seconds
Java 1.8.0_161	0.76s
Scala 2.12.4	0.72s
Clojure 1.9.0	4.4s
Kotlin 1.2.0 (JRE 1.8.0_161-b12)	0.8s
C# / Mono 3.2.8	1.66s

Group 3

Language	Finished in seconds
JavaScript/node.js 6.11.5	1.95s
Python 2.7.6	45s
Python 3.4.3	39s
Python 3.6.1 (non-optimized)	66s
Python 3.6.4 (--enable-optimizations)	47s
Python 3.6.1 / Cython 0.27.3	0.38s
Python 3.6.1 / Numba 0.33.0	2.2s
Python 3.5.3 / PyPy 5.10.1	2.6s
Ruby 2.4.0p0	15s
Crystal 0.24.1 (crystal run fib.rb)	2.76s
Crystal 0.24.1 (compiled)	1.65s
Crystal 0.24.1 (--release compiled)	1.11s
Julia 0.6.2	1.51s

Group 4

Language	Finished in seconds
Elixir 1.5.2 / Erlang/OTP 20	5.7s

Source Code

C code

#include <stdio.h>

int fib(int n)
{
    if (n < 3)
        return 1;
    else
        return fib(n - 2) + fib(n - 1);
}

int main(int argc, char const *argv[])
{
    printf("fib(40) = %d\n", fib(40));
    return 0;
}

Ruby / Crystal code

def fib(n)
  if n < 3
    return 1
  else
    return fib(n-2) + fib(n-1)
  end
end

puts(fib(40))

Python code

def fib(n):
  if n < 3:
    return 1
  else:
    return fib(n-2) + fib(n-1)

print(fib(40))

Julia code

function fib(n)
  if (n < 3)
    return 1
  else
    return fib(n - 2) + fib(n - 1)
  end
end

println(fib(40))

Elixir code

defmodule Math do

  def fib(1), do: 1

  def fib(2), do: 1

  def fib(n) do
    fib(n-2) + fib(n-1)
  end

end

IO.puts Math.fib(40)

Go code

package main

import (
    "fmt"
)

func fib(n int) int {
    if n < 3 {
        return 1
    }
    return fib(n-2) + fib(n-1)
}

func main() {
    fmt.Printf("fib(40) = %d\n", fib(40))
}

Java code

public class Fib {
    static int fib(int n) {
        if (n < 3)
            return 1;
        else
            return fib(n -2) + fib(n - 1);
    }

    public static void main(String[] args) {
        long tStart = System.currentTimeMillis();
        System.out.printf("fib(40) = %d\n", fib(40));
        long tEnd = System.currentTimeMillis();
        long tDelta = tEnd - tStart;
        double elapsedSeconds = tDelta / 1000.0;
        System.out.printf("Elapsed time: %g\n", elapsedSeconds);
    }
}

Rust code

fn fib(n: i64) -> i64 {
    if n < 3 {
        1
    } else {
        fib(n - 2) + fib(n - 1)
    }
}

fn main() {
    print!("fib(40) = {}\n", fib(40));
}

Swift code

func fib(n: Int) -> Int {
  if n < 3 {
    return 1
  } else {
    return fib(n: n-2) + fib(n: n-1)
  }
}

print(fib(n: 40))

OCaml code

let rec fib n =
  if n < 3 then
    1
  else
    fib (n-1) + fib (n-2)

let () =
  Printf.printf "%d\n" (fib 40)

JavaScript code

function fib(n)
{
    if (n < 3)
        return 1;
    else
        return fib(n - 2) + fib(n - 1);
}

console.log(fib(40));