Type systems are not just syntax checkers, but are intended to prevent execution errors by catching type errors. Static typing catches errors at compile-time rather than run-time, as demonstrated by examples in Ruby and C#. While static typing can seem bureaucratic in some languages, it enables type inference and other "smart" features in languages like Haskell. Both static and dynamic typing are flexible depending on the language, as dynamic languages allow for eval and meta-programming while static languages have reflection and templates. Overall, typing influences language design and tools but flexible features depend more on the language's meta-model, while static languages can feel bureaucratic due to historical reasons rather than limitations of the typing model.

1. one or two things
you may not know
about
type systems
phillip calçado
http://fragmental.tw

2. myths

3. myth:type systems
are just syntax
checkers

4. “The fundamental purpose of a type system is to
prevent the occurrence of execution errors during
the running of a program.”
- Luca Cardelli, Type Systems

5. what kind of
errors?

6. package org.apache.commons.lang.time;
public class DateUtils {
public static boolean isSameDay(Date date1, Date
date2) {
if (date1 == null || date2 == null) {
throw new IllegalArgumentException("The date
must not be null");
}
return verifySameDay(date1, date2);
}
}

7. package org.apache.commons.lang.time;
public class DateUtils {
but why would it be
public static boolean isSameDay(Date date1, Date
date2) {
if (date1 == null || date2 == null) {
allowed to be null in
throw new IllegalArgumentException("The date
must not be null");
}
the first place?
Calendar cal1 = Calendar.getInstance();
cal1.setTime(date1);
Calendar cal2 = Calendar.getInstance();
cal2.setTime(date2);
return isSameDay(cal1, cal2);
}
}

8. use System;
public class DatePrinter {
public static void Main(string[] args)
{
Print(new DateTime());
}
public static void Print(DateTime d)
{
Console.WriteLine(d);
}
}

9. ☑
use System;
public class DatePrinter {
public static void Main(string[] args)
{
Print(new DateTime());
}
public static void Print(DateTime d)
{
Console.WriteLine(d);
}
}

10. use System;
public class DatePrinter {
public static void Main(string[] args)
{
Print(null);
}
public static void Print(DateTime d)
{
Console.WriteLine(d);
}
}

11. ☒
use System;
public class DatePrinter {
public static void Main(string[] args)
{
Print(null);
}
public static void Print(DateTime d)
{
Console.WriteLine(d);
}
pcalcado@pcalcado:awayday2009$ gmcs DatePrinter.cs
} DatePrinter.cs(7,5): error CS1502: The best overloaded method match for
`DatePrinter.Print(System.DateTime)' has some invalid arguments
DatePrinter.cs(10,22): (Location of the symbol related to previous error)
DatePrinter.cs(7,5): error CS1503: Argument `#1' cannot convert `null'
expression to type `System.DateTime'
Compilation failed: 2 error(s), 0 warnings

12. use System;
public class DatePrinter {
public static void Main(string[] args)
{
Print(null);
}
public static void Print(DateTime? d)
{
Console.WriteLine(d);
}
}

13. ☑
use System;
public class DatePrinter {
public static void Main(string[] args)
{
Print(null);
}
public static void Print(DateTime? d)
{
Console.WriteLine(d);
}
}

14. “I call it my billion-dollar mistake. It was the
invention of the null reference in 1965. At that
time, I was designing the first comprehensive type
system [...] My goal was to ensure that all use of
references should be absolutely safe, with checking
performed automatically by the compiler. But I
couldn’t resist the temptation to put in a null
reference [...] This has led to innumerable errors
[...] which have probably caused a billion dollars of
pain and damage in the last forty years. In recent
years, a number of program analysers [...] in
Microsoft have been used to check references, and
give warnings if there is a risk they may be non-
null. More recent programming languages like Spec#
have introduced declarations for non-null references.
This is the solution, which I rejected in 1965.”
- C.A.R. Hoare

15. myth:
dynamic
means
weak

16. what is
weak?

17. “typeful programming advocates static typing, as much
as possible, and dynamic typing when necessary; the
strict observance of either or both of these
techniques leads to strong typing, intended as the
absence of unchecked run-time type errors.”
- Luca Cardelli, Typeful Programming

18. unchecked run-time type errors

19. pcalcado@pcalcado:~$ php ‐a
Interactive mode enabled
<?php
$i_am_a_string = "see?";
$weird_result = 100 + $i_am_a_string + 20;
echo $weird_result . "n";
echo $i_am_a_string . "n";
?>
120
see?

20. unchecked run-time type errors
$weird_result = 100 + “see” + 20;
=> 120

21. pcalcado@pcalcado:~$ irb
>> weird_result = 100 + "see?" + 20
TypeError: String can't be coerced into
Fixnum
from (irb):1:in `+'
from (irb):1
>>

22. myth:
static
means
safe

23. “typeful programming advocates static typing, as much
as possible, and dynamic typing when necessary; the
strict observance of either or both of these
techniques leads to strong typing, intended as the
absence of unchecked run-time type errors.”
- Luca Cardelli, Typeful Programming

24. “typeful programming advocates static typing, as much
as possible, and dynamic typing when necessary; the
strict observance of either or both of these
techniques leads to strong typing, intended as the
absence of unchecked run-time type errors.”
- Luca Cardelli, Typeful Programming

25. type error:
$weird_result = 100 + “see” + 20;
=> 120

26. public class NoError{
public static void main(String[] args){
Triangle t = new Triangle();
t.addVertex(0,0);
t.addVertex(10,10);
t.addVertex(20,20);
t.addVertex(30,30);
System.out.println("Your triangle has "+
t.getVertices().size() + " vertices");
}
}
class Triangle{
private List<int[]> vertices = new ArrayList<int[]>();
public void addVertex(int x, int y){
vertices.add(new int[]{x, y});
}
public List<int[]> getVertices(){
return vertices;
}
}

27. no type error:
=> Your triangle has 4 vertices

28. myth:
static means
bureaucratic

29. public class Sum {
public static int add(int a,
int b) {
return a + b;
}
}

30. add(a, b) {
return a + b
}
Is this hypothetical language dynamic or static?

31. Ruby
def add(a, b)
a + b
end
Dynamic

32. C#
((a, b) => a + b)
Static

33. Clojure
(defn add [a b]
(+ a b))
Dynamic

34. Haskell
add a b = a + b
Static

35. static can be
smart

36. add a b = a + b
Prelude> :load add.hs
[1 of 1] Compiling Main
( add.hs, interpreted )
Ok, modules loaded: Main.
*Main> :type add
add :: (Num a) => a ‐> a ‐> a
*Main> :type (add 1 2)
(add 1 2) :: (Num t) => t
*Main>

37. myth:
only dynamic
is flexible

38. >> my_func()
NoMethodError: undefined method
`my_func' for main:Object
from (irb):1
>> instance_eval("def my_func()n puts
666n end")
=> nil
>> my_func()
666
=> nil
>>

40. “we think that people use eval as a poor
man’s substitute for higher-order
functions. Instead of passing around
a function and call it, they pass around
a string and eval it. [...]
A final use of eval that we want to
mention is for partial evaluation,multi-
stage programming, or meta programming.
We argue that in that case strings are
not really the most optimal structure to
represent programs and it is much better
to use programs to represent programs,
i.e. C++-style templates, quasiquote/
unquote as in Lisp, or code literals as
in the various multi-stage programming
languages.”
- The End of the Cold War Between Programming
Languages, Erik Meijer and Peter Drayton

41. main = runBASIC $ do
10 GOSUB 1000
20 PRINT "* Welcome to HiLo *"
30 GOSUB 1000
100 LET I := INT(100 * RND(0))
200 PRINT "Guess my number:"
210 INPUT X
220 LET S := SGN(I-X)
230 IF S <> 0 THEN 300
240 FOR X := 1 TO 5
250 PRINT X*X;" You won!"
260 NEXT X
270 STOP
300 IF S <> 1 THEN 400
310 PRINT "Your guess ";X;" is too low."
320 GOTO 200
400 PRINT "Your guess ";X;" is too high."
410 GOTO 200
1000 PRINT "*******************"
1010 RETURN
9999 END

42. 652 lines of
Haskell

43. what does the
future hold?

44. does typing
matter?

45. =>typing influences
language features and
tools
=>static typing is
YES
being wrongly bashed
because of C#/Java just
as dynamic was bashed
because of PHP/Perl
=>schools are merging
(e.g. C# 4) and it’s
important to know each
one’s sweet spot

46. =>saying that something
is static or dynamic
doesn’t tell much about
what it can do
=>most nice features in
NO Python/Ruby/JavaScript
are related to meta-
model, not typing
=>Java/C# are
bureaucratic for
historical reasons, not
limitations on typing

47. refs:
=>http://pico.vub.ac.be/~wdmeuter/RDL04/papers/
Meijer.pdf
=>http://lucacardelli.name/Papers/TypefulProg.A4.pdf
=>http://sadekdrobi.com/2008/12/22/null-references-
the-billion-dollar-mistake/
=>http://www.flickr.com/photos/twindx/
=>http://www.flickr.com/photos/darwinbell/
=>http://www.flickr.com/photos/wainwright/
=>http://www.flickr.com/photos/fikirbaz/