Compare Programming Languages Execution Time
Tags: programming
Published: 2021-11-27 23:19:14

With stifan kristi (steve van christie) here, want to share the idea of this post is for comparing programming languages execution time with simple command that execute system command *hostname* to get computer hostname and for execution duration is taken by \*nix *time* command.

The programming languages compared here are : 
* Java (*.java), need java installed to run script
* JavaScript (*.js), need nodejs installed to run script
* R (*.r), need r installed to run script
* Go (*.go), need go installed to run script
* PHP (*.php), need php installed to run script
* Ruby (*.rb), need ruby installed to run script
* AppleScript (*.scpt), need mac environment to run script
* Tcl (*.tcl), need tclsh installed to run script
* Python (*.py), need python installed to run script
* Perl (*.pl), need perl installed to run script
* C (*.c), need gcc installed to compile script
* C++ (*.cpp), need g++ installed to compile script
* Shell (*.sh), need *nix environment to run script

alternatively, you can install conda or miniconda to run : nodejs, r, go, ruby, python and perl
of course you can compile or run it with your lovely IDE, but to get the execution time duration, we use \*nix *time* command in this topic, so better to execute everything in terminal.

\*nix *time* command will produce 3 summarries data : real, user and sys. 
* real is realtime
* user is user CPU time
* sys is system CPU time

Execute Command from Terminal (without any programming language) : 
`time hostname`

## Programming Language Compared

### Java

Check Version : 
`java -version`

#### exec

Create File : 
`Exec0.java`

```
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Exec0 {
    public static void main(String[] args)
    {
        try {
            Process process = Runtime.getRuntime().exec("hostname");
            StringBuilder output = new StringBuilder();
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream() ) );
            String line;
            while ((line = reader.readLine() ) != null) {
                output.append(line + "\n");
            }
            int exitVal = process.waitFor();
            if (exitVal == 0) {
                System.out.println(output);
                System.exit(0);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

Execute File from Terminal : 
`time javac Exec0.java`
`time java Exec0`

#### ProcessBuilder

Create File : 
`ProcessBuilder0.java`

```
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class ProcessBuilder0 {
    public static void main(String[] args)
    {
        try {
            ProcessBuilder pb = new ProcessBuilder("hostname");
            Process process = pb.start();
            StringBuilder output = new StringBuilder();
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream() ) );
            String line;
            while ((line = reader.readLine() ) != null) {
                output.append(line + "\n");
            }
            int exitVal = process.waitFor();
            if (exitVal == 0) {
                System.out.println(output);
                System.exit(0);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

Execute File from Terminal : 
`time javac ProcessBuilder0.java`
`time java ProcessBuilder0`

### JavaScript

Check Version : 
`node -v`

#### exec

Create File : 
`test_js_exec.js`

```
const { exec } = require("child_process");
exec("hostname", (error, stdout, stderr) => {
    if (error) {
        console.log(`error: ${error.message}`);
        return;
    }
    if (stderr) {
        console.log(`stderr: ${stderr}`);
        return;
    }
    console.log(`stdout: ${stdout}`);
});
```

Execute File from Terminal : 
`time node test_js_exec.js`

#### execSync

Create File : 
`test_js_execsync.js`

```
const { execSync } = require('child_process');
const output = execSync('hostname', {encoding: 'utf-8'} );
console.log('output: ' + output);
```

Execute File from Terminal : 
`time node test_js_execsync.js`

#### spawn

Create File : 
`test_js_spawn.js`

```
const { spawn } = require("child_process");
const hostname = spawn("hostname");
hostname.stdout.on("data", data => {
    console.log(`stdout: ${data}`);
});
hostname.stderr.on("data", data => {
    console.log(`stderr: ${data}`);
});
hostname.on('error', (error) => {
    console.log(`error: ${error.message}`);
});
hostname.on("close", code => {
    console.log(`child process exited with code ${code}`);
});
```

Execute File from Terminal : 
`time node test_js_spawn.js`

### R

Check Version : 
`Rscript --version`

#### system

Create File : 
`system.r`

```
system("hostname")
```

Execute File from Terminal : 
`time Rscript system.r`

#### system2

Create File : 
`system2.r`

```
system2("hostname", stdout = TRUE, stderr = TRUE)
```

Execute File from Terminal : 
`time Rscript system2.r`

#### sys

Install Package : 
`r`
`install.packages("sys")`
`any(grepl("sys", installed.packages() ) )`
`q()`

Create File : 
`sys.r`

```
out <- sys::exec_internal('hostname')
sys::as_text(out$stdout)
```

Execute File from Terminal : 
`time Rscript sys.r`

#### processx

Install Package : 
`r`
`install.packages("processx")`
`any(grepl("processx", installed.packages() ) )`
`q()`

Create File : 
`processx.r`

```
out <- processx::run('hostname')
out$stdout
```

Execute File from Terminal : 
`time Rscript processx.r`

### Go

Check Version : 
`go version`

Create File : 
`test.go`

```
package main
import (
    "fmt"
    "os/exec"
)
func main() {
    prg := "hostname"
    cmd := exec.Command(prg)
    stdout, err := cmd.Output()
    if err != nil {
        fmt.Println(err.Error() )
        return
    }
    fmt.Print(string(stdout) )
}
```

Execute File from Terminal : 
`time go run test.go`

### PHP

Check Version : 
`php -v`

#### backtick

Create File : 
`test_php_backtick.php`

```
<?php
$output = `hostname`;
echo "$output";
?>
```

Execute File from Terminal : 
`time php test_php_backtick.php`

#### system

Create File : 
`test_php_system.php`

```
<?php
system("hostname");
?>
```

Execute File from Terminal : 
`time php test_php_system.php`

#### passthru

Create File : 
`test_php_passthru.php`

```
<?php
passthru("hostname");
?>
```

Execute File from Terminal : 
`time php test_php_passthru.php`

### Ruby

Check Version : 
`ruby -v`

Create File : 
`test.rb`

```
#!/usr/bin/ruby
system("hostname")
```

Execute File from Terminal : 
`time ruby test.rb`

### AppleScript

Create File : 
`test.scpt`

```
do shell script "hostname"
```

Execute File from Terminal : 
`time osascript test.scpt`

### Tcl

Create File : 
`test.tcl`

```
set result [exec hostname]
puts $result
```

Execute File from Terminal : 
`time tclsh test.tcl`

### Python

Check Version : 
`python -V`

#### subprocess.run

Create File : 
`test_py_subprocess_run.py`

```
#!/usr/bin/python
# -*- coding: utf-8 -*-
import subprocess
subprocess.run("hostname")
```

Execute File from Terminal : 
`time python test_py_subprocess_run.py`

#### subprocess.Popen

Create File : 
`test_py_subprocess_popen.py`

```
#!/usr/bin/python
# -*- coding: utf-8 -*-
import subprocess
subprocess.Popen("hostname")
```

Execute File from Terminal : 
`time python test_py_subprocess_popen.py`

#### os

Create File : 
`test_py_os.py`

```
#!/usr/bin/python
# -*- coding: utf-8 -*-
import os
os.system("hostname")
```

Execute File from Terminal : 
`time python test_py_os.py`

In python you can compile it first with *py_compile* module, then execute the compiled version in pycache directory, e.g.
`time python -m py_compile test_py_subprocess_popen.py`
`time python __pycache__/test_py_subprocess_popen.cpython-*.pyc`
`time python -m py_compile test_py_subprocess_run.py`
`time python __pycache__/test_py_subprocess_run.cpython-*.pyc`
`time python -m py_compile test_py_os.py`
`time python __pycache__/test_py_os.cpython-*.pyc`

the result for execute compiled version (*.pyc) is faster than execute the source code (*.py). 
So, better to compile your source code when run in production environment.

But the result for compiling (python -m pycompile *.py), then execute compiled version (python *.pyc) take longer, 
than execute the source code version (python *.py).

### Perl

Check Version : 
`perl -v`

#### backtick

Create File : 
`test_pl_backtick.pl`

```
#!/usr/bin/perl
my $output = `hostname`;
print "$output";
```

Execute File from Terminal : 
`time perl test_pl_backtick.pl`

#### system

Create File : 
`test_pl_system.pl`

```
#!/usr/bin/perl
system("hostname");
```

Execute File from Terminal : 
`time perl test_pl_system.pl`

#### exec

Create File : 
`test_pl_exec.pl`

```
#!/usr/bin/perl
exec("hostname");
```

Execute File from Terminal : 
`time perl test_pl_exec.pl`

### C

Create File : 
`test.c`

```
#include <stdlib.h>
int main() {
    system("hostname");
}
```

Execute File from Terminal : 
`time gcc test.c -o c.out`
`time ./c.out`

### C++

Create File : 
`test.cpp`

```
#include <iostream>
int main() {
    system("hostname");
}
```

Execute File from Terminal : 
`time g++ test.cpp -o cpp.out`
`time ./cpp.out`

### Shell

#### TC Shell (tcsh)

Check Version : 
`tcsh --version`

Create File : 
`test_tcsh.sh`

```
#!/bin/tcsh
hostname
```

Execute File from Terminal : 
`time tcsh test_tcsh.sh`

#### C Shell (csh)

Check Version : 
`csh --version`

Create File : 
`test_csh.sh`

```
#!/bin/csh
hostname
```

Execute File from Terminal : 
`time csh test_csh.sh`

#### Z Shell (zsh)

Check Version : 
`zsh --version`

Create File : 
`test_zsh.sh`

```
#!/bin/zsh
hostname
```

Execute File from Terminal : 
`time zsh test_zsh.sh`

#### Korn Shell (ksh)

Check Version : 
`ksh --version`

Create File : 
`test_ksh.sh`

```
#!/bin/ksh
hostname
```

Execute File from Terminal : 
`time ksh test_ksh.sh`

#### Bash Shell (bash)

Check Version : 
`bash --version`

Create File : 
`test_bash.sh`

```
#!/bin/bash
hostname
```

Execute File from Terminal : 
`time bash test_bash.sh`

#### Bourne Shell (sh)

Check Version : 
`sh --version`

Create File : 
`test_sh.sh`

```
#!/bin/sh
hostname
```

Execute File from Terminal : 
`time sh test_sh.sh`

## Result
yeah, the result for all of this tests is not shown here because time execution result will different when test on other devices. 
Author won't give opinion about any programming language. you can try it yourself.