Key differences between mainly used languages for data science

Javascript: weakly and dynamically typed

Let's define a small script, add_numbers.js:

function add_numbers(a, b) {
    result = a + b;
    return result;
}

c = "5"
n = 5

result = add_numbers(c, n);

console.log(result);

We defined a function add_numbers which takes two arguments a and b and return their sum. We apply it with a string c, and an int n, and write the result to the standard output. We can run the above script with:

node add_numbers.js

It outputs 55. Javascript converted silently the integer n to a string, and concatenated the two strings. If you expect to see 10, inverting the two arguments does not help you, since it produces the same result: "+" concatenates strings as soon as one of its operands is a string. This pitfall can be avoided by checking the types automatically beforehand (e.g. with Typescript), as we will see in another blog post. It also makes me prefer strongly typed languages, as we will see with Python.

Python: strongly and dynamically typed

Let's write the same script, but this time in Python (add_numbers.py):

def add_numbers(a, b):
    result = a + b
    return result

c = "5"
n = 5

result = add_numbers(c, n)
print(result)

The function add_numbers takes two arguments a and b, and return their sum. We apply it, as previously in Javascript, with a string c and an int n. When running the above script:

python3 add_numbers.py

It outputs:

TypeError: can only concatenate str (not "int") to str

This example shows that Python is strongly typed since it doesn't allow to sum an int and a string. It prevents erroneous results by raising an exception.

This error is however produced at run-time because Python is dynamically typed. It is not ideal since the error only pops up when the code snippet is executed. It means that if you have a long running piece of code before your mistake (forgetting to convert the string to an int for instance), you have to wait that amount of time to notice it, which slows down your development process.

In another blog post, we will see how to use static typing in Python, but for now, let's see another language which is statically typed: Scala.

Scala: strongly and statically typed

Here we define the same function in Scala, this time specifying the type of the arguments, and apply it with a string and an integer:

def add_numbers(a: Int, b: Int) : Int = {
  val result = a + b
  return result
}

val c = "5"
val n = 5

val result = add_numbers(c, n)
result

We can run this script (add_numbers.scala) with the Scala REPL. It compiles it and executes the resulting program:

scala add_numbers.scala

It outputs:

add_numbers.scala:9: error: type mismatch;
 found   : String
 required: Int
   val result = add_numbers(c, n)
                            ^
one error found

The error is found at compile time. To convince you, we can separate the two steps: compile and run. For this, we have to wrap the script into an object to produce a standalone Scala code:

object AddNumbers {
  def main(args: Array[String]): Unit = {
    val c = "5"
    val n = 5

    val result = add_numbers(c, n)
    println(result)
  }

  def add_numbers(a: Int, b: Int) :Int = {
    val result = a + b
    result
  }
}

Wrapping the script into an object was automatically done by the Scala REPL, which is a tool to evaluate expressions in Scala.

Here, we also show how to use type inference in Scala: the types of c and n are inferred to be String and Int respectively. The function add_numbers takes two arguments of type Int and return a value of the same type.

We can compile the Scala code with:

scalac add_numbers.scala

which outputs:

add_numbers.scala:6: error: type mismatch;
 found   : String
 required: Int
    val result = c + n
                 ^
one error found

Being able to detect such mistakes at compile time is extremely powerfull. This is possible with languages that are both strongly and statically typed. If the language is weakly typed, we fall into one of the pitfalls of Javascript: wrong results at run-time, as we will see with C.

C: weakly and statically typed

Here is again the same example, written in C:

#include <stdio.h>

int add_numbers(int a, int b) {
    int result = a + b;
    return result;
}

int main() {
    char c = "5";
    int n = 5;

    int result = add_numbers(c, n);
    printf("%d\n", result);

    return 0;
}

It can be compiled with:

gcc -w add_numbers.c

Which produces the executable add_numbers.out.

When running the executable:

./add_numbers.out

It outputs -73. This example shows the danger when using weakly typed languages.

In fact, when running the compiler, I disabled the warnings with the -w option. A good compiler with all the warnings activated can detect such things, for instance when compiling without the -w flag:

add_numbers.c:9:10: warning: incompatible pointer to integer conversion initializing 'char' with an expression
      of type 'char [2]' [-Wint-conversion]
    char c = "5";
         ^   ~~~
1 warning generated.

In more complicated cases (for instance using void pointers), the compiler does not catch the errors.