CSC 347 - Concepts of Programming Languages

Static and Dynamic Types

Instructor: Stefan Mitsch

Learning Objectives

How should we support programmers in interpreting memory content correctly?
How should we support programmers in applying operations correctly?

• Understand the role of types
• Understand the difference between static and dynamic types

Programming Without Types

What is difficult about the code below?
How can we improve the language to better support programmers?

void* getNext(void* x) {
  return *(x+4);
}
void* n = malloc(12); 
*n = 42; 
*(n+4) = NULL;
void* nn = getNext(n);

typedef struct Node { int value; Node* next; } Node;
Node* getNext (Node* x) {
  return x->next;  
}
Node* n = malloc(sizeof(Node)); 
n->value = 42; 
n->next = NULL;
Node* nn = getNext(n);

Types

• Types define offsets

  typedef struct Node { int value; Node* next; } Node;
  Node* getNext (Node* x) {
    return x->next;  
  }
  

• Types determine valid operations

  println( 1 - 2 )
  println( "dog" - "cat" )  
  

Type Enforcement

• Statically, track types with compiler
  • Compile time
  • Early

• Dynamically, store type with object
  • Run time
  • Late

Dynamic Type Checking in Scheme

• Dynamic type checking detects a failure

• How do we know Scheme is dynamic?

  #;> (- 5 "hello")
  Error in -: expected type number, got '"hello"'.
  

• Type checker invoked before execution starts?

Dynamic Type Checking in Scheme

#;> (define (f) (- 5 "hello"))
#;> (f)
Error in -: expected type number, got '"hello"'.

• Defer computation to function body

• Failure is when f runs
• Conclusion: no type checking before execution

Static Type Checking in Java and Scala

int a = 5;
String b = "hello";
System.out.println ("Result = " + (a - b));

val a = 5
val b = "hello"
println(s"Result = ${a-b}")

• Compiler rejects code with (5 - "hello")

  error: bad operand types for binary operator '-'
      System.out.println ("Result = " + (a - b));
                                          ^
    first type:  int
    second type: String
  

Dynamic Type Checking in Java and Scala

• We can make the error dynamic by casting

int a = 5;
String b = "hello";
System.out.println ("Result = " + (a - (int)(Object)b));

val a = 5
val b = "hello"
println(s"Result = ${a-b.asInstanceOf[Int]}")

• Compiler accepts code, but dynamic type checking at runtime catches the invalid cast

  ClassCastException: class String cannot be cast to class Integer
  

Variables in Static Languages

• In static languages, variables have types

int a = 5;
a = "hello";

var a = 5
a = "hello"

• Compiler error

  incompatible types: String cannot be converted to int
      a = "hello";
          ^
  

Casting

• We can convert any static error into a dynamic one: casting turns compile-time errors into runtime errors

int a = 5;
a = (int)(Object)"hello";

var a = 5
a = "hello".asInstanceOf[Int]

• Compiler accepts code, but invalid cast is detected at runtime

  ClassCastException: class String cannot be cast to class Integer
  

Type Inference

• Type inference infers the most precise type possible

var a = 5;
a = "hello";

var a = 5
a = "hello"

error: incompatible types: String cannot be converted to int
    a = "hello";
        ^

Variables in Dynamic Languages

• Variables do not have types in dynamic languages
• Only values have types

Scheme

#;> (define (main)
       (define a 5)
       (set! a "hello")
       (display a)
    )
#;> (main)
"hello"

Tradeoffs

• Dynamic
  • more flexible
  • usually conceptually simpler
  • faster compilation
  • easier runtime code generation/modification
• Static
  • compile-time detection of errors
  • no unit tests for type checking
  • automatic documentation
  • faster runtime (dynamic checks, optimization)
  • less memory consumption at runtime

Static Type Checking

• Static types are conservative

  def f(i: Int, s: String) = if true then i else s
  

• Static types may use type inference

  val x = 1
  

Summary

• Static type checking
  • at compile time
  • variables have types, but can often be inferred
• Dynamic type checking
  • at runtime
  • variables do not have types, data has types