SlideShare a Scribd company logo
1 of 132
Download to read offline
LOVE, MARRIAGE & HAPPINESS
MATTHIAS FELLEISEN, NU PRL
MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL)
MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL)
1980
MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL)
1980
1984
MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL)
1980
1984
1985
MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL)
1980
1984
1985
MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL)
1980
1984
1985
MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL)
1980
1984
1985
1987
MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL)
1980
1984
1985
MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL)
1980
1984
1985
1987
MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL)
1980
1984
1985
1987
1992
MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL)
1980
1984
1985
1987
MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL)
1980
1984
1985
1987
2001
MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL)
1980
1984
1985
1987
2001
MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL)
1980
1984
1985
1987
2001
G*DDAMN FOREIGNER
MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL)
1980
1984
1985
1987
2001
G*DDAMN FOREIGNER
WHAT’S LOVE GOT TO DO WITH IT
πrogramming
λanguages
You are here because
you fell in love with
something about
programming languages.
YOU CAN’T JUST KEEP YOUR FINGERS OFF
πrogramming
λanguages
The most fundamental area
of computer science. If you
don’t have a language, you
can’t compute.
YOU CAN’T JUST KEEP YOUR FINGERS OFF
πrogramming
λanguages
The most fundamental area
of computer science. If you
don’t have a language, you
can’t compute.
Developers primarily use
programming languages.
The tools we build have
meaning for them.
YOU CAN’T JUST KEEP YOUR FINGERS OFF
πrogramming
λanguages
The most fundamental area
of computer science. If you
don’t have a language, you
can’t compute.
Developers primarily use
programming languages.
The tools we build have
meaning for them.
You will get to work with
elegant mathematics and,
some of you will develop
new mathematics.
YOU CAN’T JUST KEEP YOUR FINGERS OFF
πrogramming
λanguages
The most fundamental area
of computer science. If you
don’t have a language, you
can’t compute.
Developers primarily use
programming languages.
The tools we build have
meaning for them.
You will get to work with
elegant mathematics and,
some of you will develop
new mathematics.
Where else do
you get to work
with the coolest
professors on
the planet?
SO WHAT’S IT LIKE TO GET MARRIED TO PL RESEARCH
SO WHAT’S IT LIKE TO GET MARRIED TO PL RESEARCH
IT HAS ITS UPS AND DOWNS.
IT HAS ITS UPS AND DOWNS.
Falling in love.
IT HAS ITS UPS AND DOWNS.
Falling in love.
Being in love.
IT HAS ITS UPS AND DOWNS.
Falling in love.
Being in love.
Getting thru difficult,
troublesome times …
AND LOVE IS WHAT GETS YOU BACK ON TRACK.
AND LOVE IS WHAT GETS YOU BACK ON TRACK.
But really, if you don’t love
PL, getting a PhD is hard.
AND LOVE IS WHAT GETS YOU BACK ON TRACK.
But really, if you don’t love
PL, getting a PhD is hard.
Hard because it’s
an old and now
‘hidden’ discipline.
AND LOVE IS WHAT GETS YOU BACK ON TRACK.
But really, if you don’t love
PL, getting a PhD is hard.
Hard because it’s
an old and now
‘hidden’ discipline.
HARD because it isn’t
‘hot’ with IT industry.
AND LOVE IS WHAT GETS YOU BACK ON TRACK.
But really, if you don’t love
PL, getting a PhD is hard.
Hard because it’s
an old and now
‘hidden’ discipline.
HARD because it isn’t
‘hot’ with IT industry.
H.A.R.D.
ONE LAST WARNING: IF YOU DON’T LOVE IT, LEAVE IT.
ONE LAST WARNING: IF YOU DON’T LOVE IT, LEAVE IT.
If you want to be famous, get
into Artificial Intelligence.
ONE LAST WARNING: IF YOU DON’T LOVE IT, LEAVE IT.
If you want to be famous, get
into Artificial Intelligence.
If you want to make money,
do Big Data.
ONE LAST WARNING: IF YOU DON’T LOVE IT, LEAVE IT.
If you want to be famous, get
into Artificial Intelligence.
If you want to make money,
do Big Data.
If you want a career,
switch majors. I hear our
Business School is looking
for students.
TYPES FOR UNTYPED LANGUAGES, HOW LOVE WORKS
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
1987
CORKY CARTWRIGHT
“LET’S WORK ON TYPES
FOR SCHEME”
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
1987
CORKY CARTWRIGHT
“LET’S WORK ON TYPES
FOR SCHEME”
1988
(It doesn’t have to be
love at first sight.)
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
1987
CORKY CARTWRIGHT
“LET’S WORK ON TYPES
FOR SCHEME”
COOL! WORKING WITH
CARTWRIGHT AND FAGAN
1989
1988
(It doesn’t have to be
love at first sight.)
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
1987
CORKY CARTWRIGHT
“LET’S WORK ON TYPES
FOR SCHEME”
COOL! WORKING WITH
CARTWRIGHT AND FAGAN
1989
1993/94
THE ONLY USER OF
ANDREW WRIGHT’S SOFT
SCHEME
1988
(It doesn’t have to be
love at first sight.)
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
1987
CORKY CARTWRIGHT
“LET’S WORK ON TYPES
FOR SCHEME”
COOL! WORKING WITH
CARTWRIGHT AND FAGAN
1989
1993/94
THE ONLY USER OF
ANDREW WRIGHT’S SOFT
SCHEME
1988
(It doesn’t have to be
love at first sight.)
CO-CREATED SPIDEY
SCHEME WITH CORMAC
FLANAGAN
1995/97
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
1987
CORKY CARTWRIGHT
“LET’S WORK ON TYPES
FOR SCHEME”
COOL! WORKING WITH
CARTWRIGHT AND FAGAN
1989
1993/94
THE ONLY USER OF
ANDREW WRIGHT’S SOFT
SCHEME
1988
(It doesn’t have to be
love at first sight.)
CO-CREATED SPIDEY
SCHEME WITH CORMAC
FLANAGAN
1995/97
MODULAR SPIDER WITH
PHILIPPE MEUNIER
1998/2003
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
1987
CORKY CARTWRIGHT
“LET’S WORK ON TYPES
FOR SCHEME”
COOL! WORKING WITH
CARTWRIGHT AND FAGAN
1989
1993/94
THE ONLY USER OF
ANDREW WRIGHT’S SOFT
SCHEME
1988
(It doesn’t have to be
love at first sight.)
CO-CREATED SPIDEY
SCHEME WITH CORMAC
FLANAGAN
1995/97
MODULAR SPIDER WITH
PHILIPPE MEUNIER
1998/2003
2005-2016
TYPED RACKET W/
TOBIN-HOCHSTADT
(define (tautology? p)
(bond
[(boolean? p) p]
[else (and (tautology? (p true)) (tautology? (p false)))]))
WHAT’S THE TYPE OF AN UNTYPED PROGRAM?
1987
(define (tautology? p)
(bond
[(boolean? p) p]
[else (and (tautology? (p true)) (tautology? (p false)))]))
WHAT’S THE TYPE OF AN UNTYPED PROGRAM?
1987
(define (tautology? p)
(bond
[(boolean? p) p]
[else (and (tautology? (p true)) (tautology? (p false)))]))
WHAT’S THE TYPE OF AN UNTYPED PROGRAM?
THERE IS LOTS OF LISP OUT THERE
AND THEY MAY WANT TYPES.
1987
(define (tautology? p)
(bond
[(boolean? p) p]
[else (and (tautology? (p true)) (tautology? (p false)))]))
WHAT’S THE TYPE OF AN UNTYPED PROGRAM?
THERE IS LOTS OF LISP OUT THERE
AND THEY MAY WANT TYPES.
1987
WE WANT WIDE-SPECTRUM
PROGRAMMING.
(define (tautology? p)
(bond
[(boolean? p) p]
[else (and (tautology? (p true)) (tautology? (p false)))]))
WHAT’S THE TYPE OF AN UNTYPED PROGRAM?
THERE IS LOTS OF LISP OUT THERE
AND THEY MAY WANT TYPES.
PROGRAMMERS DO NOT WANT TO
COPE WITH THE IDIOSYNCRASIES OF
TYPE SYSTEMS.
1987
WE WANT WIDE-SPECTRUM
PROGRAMMING.
(define (tautology? p)
(bond
[(boolean? p) p]
[else (and (tautology? (p true)) (tautology? (p false)))]))
WHAT’S THE TYPE OF AN UNTYPED PROGRAM?
THERE IS LOTS OF LISP OUT THERE
AND THEY MAY WANT TYPES.
PROGRAMMERS DO NOT WANT TO
COPE WITH THE IDIOSYNCRASIES OF
TYPE SYSTEMS.
IT’LL COME TRUE IN
10 OR 20 YEARS.
1987
WE WANT WIDE-SPECTRUM
PROGRAMMING.
(define (tautology? p)
(bond
[(boolean? p) p]
[else (and (tautology? (p true)) (tautology? (p false)))]))
WHAT’S THE TYPE OF AN UNTYPED PROGRAM?
THERE IS LOTS OF LISP OUT THERE
AND THEY MAY WANT TYPES.
PROGRAMMERS DO NOT WANT TO
COPE WITH THE IDIOSYNCRASIES OF
TYPE SYSTEMS.
IT’LL COME TRUE IN
10 OR 20 YEARS.
1987
WE WANT WIDE-SPECTRUM
PROGRAMMING.
WHAT’S THE TYPE OF AN UNTYPED PROGRAM?
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true)) (tautology? (p false)))]))
(tautology? true)
(tautology? (lambda (x) (lambda (y) (or x y))))
WHAT’S THE TYPE OF AN UNTYPED PROGRAM?
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true)) (tautology? (p false)))]))
(tautology? true)
(tautology? (lambda (x) (lambda (y) (or x y))))
WHAT’S THE TYPE OF AN UNTYPED PROGRAM?
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true)) (tautology? (p false)))]))
(tautology? true)
(tautology? (lambda (x) (lambda (y) (or x y))))
EASY! TYPE INFERENCE! ML HAS HAD IT SINCE 1978.
WE CAN SAY IT IN OCAML
type proposition = InL of bool | InR of (bool -> proposition)
let rec is_tautology p =
match p with
| InL b -> b
| InR p -> is_tautology(p true) && is_tautology(p false)
is_tautology (InR(fun x -> InL true))
is_tautology (InR(fun x -> InR(fun y -> or then InL x else InL y)))
WE CAN SAY IT IN OCAML
type proposition = InL of bool | InR of (bool -> proposition)
let rec is_tautology p =
match p with
| InL b -> b
| InR p -> is_tautology(p true) && is_tautology(p false)
is_tautology (InR(fun x -> InL true))
is_tautology (InR(fun x -> InR(fun y -> or then InL x else InL y)))
WE DON’T WANT TO WRITE DOWN TYPE
DEFINITIONS. WE DON’T WANT TO ADD
INSERTIONS AND PROJECTIONS.
WE DON’T WANT TO WRITE DOWN TYPE
DEFINITIONS. WE DON’T WANT TO ADD
INSERTIONS AND PROJECTIONS.
WE DON’T WANT TO WRITE DOWN TYPE
DEFINITIONS. WE DON’T WANT TO ADD
INSERTIONS AND PROJECTIONS.
WE DON’T WANT TO WRITE DOWN TYPE
DEFINITIONS. WE DON’T WANT TO ADD
INSERTIONS AND PROJECTIONS.
WE DON’T WANT TO WRITE DOWN TYPE
DEFINITIONS. WE DON’T WANT TO ADD
INSERTIONS AND PROJECTIONS.
WE DON’T WANT TO WRITE DOWN TYPE
DEFINITIONS. WE DON’T WANT TO ADD
INSERTIONS AND PROJECTIONS.
WE CAN SAY IT IN OCAML
type proposition = InL of bool | InR of (bool -> proposition)
let rec is_tautology p =
match p with
| InL b -> b
| InR p -> is_tautology(p true) && is_tautology(p false);;
is_tautology (InR(fun x -> InL true))
is_tautology (InR(fun x -> InR(fun y -> or then InL x else InL y)))
WE DON’T WANT TO WRITE DOWN TYPE
DEFINITIONS. WE DON’T WANT TO ADD
INSERTIONS AND PROJECTIONS.
WE DON’T WANT TO WRITE DOWN TYPE
DEFINITIONS. WE DON’T WANT TO ADD
INSERTIONS AND PROJECTIONS.
WE DON’T WANT TO WRITE DOWN TYPE
DEFINITIONS. WE DON’T WANT TO ADD
INSERTIONS AND PROJECTIONS.
WE DON’T WANT TO WRITE DOWN TYPE
DEFINITIONS. WE DON’T WANT TO ADD
INSERTIONS AND PROJECTIONS.
WE DON’T WANT TO WRITE DOWN TYPE
DEFINITIONS. WE DON’T WANT TO ADD
INSERTIONS AND PROJECTIONS.
WE DON’T WANT TO WRITE DOWN TYPE
DEFINITIONS. WE DON’T WANT TO ADD
INSERTIONS AND PROJECTIONS.
WE DON’T WANT TO WRITE DOWN TYPE
DEFINITIONS. WE DON’T WANT TO ADD
INSERTIONS AND PROJECTIONS.
WE DON’T WANT TO WRITE DOWN TYPE
DEFINITIONS. WE DON’T WANT TO ADD
INSERTIONS AND PROJECTIONS.
SO HOW COULD WE SAY THIS IN SCHEME?
▸ replace ML’s type algebra (x, *, ->, …)
▸ with Remy’s extensible records exclusively
▸ make it work for 100-line purely functional
programs in quasi-Scheme
SO HOW COULD WE SAY THIS IN SCHEME?
▸ replace ML’s type algebra (x, *, ->, …)
▸ with Remy’s extensible records exclusively
▸ make it work for 100-line purely functional
programs in quasi-Scheme
▸ grow it to full Chez Scheme
▸ whole-program inference
▸ success: speed-up
WHAT SOFT SCHEME CAN DO
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true)) (tautology? (p false)))]))
(-> (μ (Proposition)
(+ Boolean (-> Boolean Proposition)))
Boolean)
infer via modified HM
WHAT SOFT SCHEME CAN DO
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true)) (tautology? (p false)))]))
(-> (μ (Proposition)
(+ Boolean (-> Boolean Proposition)))
Boolean)
infer via modified HM
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
1989
1993
FAGAN CAN CHECK 100 LINES.
WRIGHT CAN CHECK 1,000 LINES
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
1989
1993
FAGAN CAN CHECK 100 LINES.
WRIGHT CAN CHECK 1,000 LINES
YOURS TRULY STRUGGLES WITH
DOZENS OF SMALL AND LARGE
PROGRAMS.
1993/94
WHAT SOFT SCHEME CAN’T DO,
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true)) (p false))]))
WHAT SOFT SCHEME CAN’T DO,
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true)) (p false))]))
DOZENS OF LINES FOR
THE TYPE MISMATCH W/O
TELLING THE DEV WHERE
THINGS WENT WRONG
WHAT SOFT SCHEME CAN’T DO,
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true)) (p false))]))
any sensible type-error
message,
just one, please .. .. ..
formulate
DOZENS OF LINES FOR
THE TYPE MISMATCH W/O
TELLING THE DEV WHERE
THINGS WENT WRONG
WHAT SOFT SCHEME CAN’T DO,
any sensible error message,
just one, please .. .. ..
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true)) (p false))]))The Problem:
Gaussian elimination over equations in an
uninterpreted algebras cannot point back to
program when the system (of eqs) is inconsistent.
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
1989
1993
FAGAN CAN CHECK 100 LINES.
WRIGHT CAN CHECK 1,000 LINES
YOURS TRULY STRUGGLES WITH
DOZENS OF SMALL AND LARGE
PROGRAMS.
1993/94
NEVIN HEINZE SHOWED YOURS
TRULY SET-BASED ANALYSIS,
AND IT FELT LIKE AN IDEA THAT
COULD HELP OUT HERE.
HEYA, DID YOU CATCH THIS MISTAKE?
▸ derive sub-typing constraints from code
e.g. dom(f) < rng(g) or int < dom(h)
▸ solve via the transitive closure through the
constructors in the constraint algebra
▸ find type errors by comparing specified
constraints for prime with computed ones
WHAT SPIDER CAN DO
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true)) (tautology? (p false)))]))
(-> (μ (Proposition)
(U Boolean (-> Boolean Proposition)))
Boolean)
infer via componential SBA
AND THEY CAN EXPLAIN ERRORS, HALLELUJAH!
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true)) (p false))]))
(-> (μ (Proposition)
(U Boolean (-> Proposition)))
Boolean)
inspect errors via
flow graphs and
slices drawn on
top of code
AND THEY CAN EXPLAIN ERRORS, HALLELUJAH!
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true)) (p false))]))
(-> (μ (Proposition)
(U Boolean (-> Proposition)))
Boolean)
inspect errors via
flow graphs and
slices drawn on
top of code
EVEN WITH 3RD
UNDERGRADUATES
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
1995-97
FLANAGAN CAN CHECK 3,000 LINES
STUDENT PROGRAMS
FLANAGAN CAN EXPLAIN ERRORS
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
1995-97
FLANAGAN CAN CHECK 3,000 LINES
STUDENT PROGRAMS
FLANAGAN CAN EXPLAIN ERRORS
1998
WE CANNOT ANALYZE THE
COMPLETE CODE BASE OF THE
SYSTEM ITSELF OR ITS CONTEXT.
WE CAN’T EVEN ‘MODULARIZE’
THE ANALYSIS PROPERLY.
WHAT THEY CAN’T DO, ABSOLUTELY NOT, NOT FOR CRYING OUT LOUD
1,000 lines ~ 1 min
2,000 lines ~ 2 min
3,000 lines ~ 3 min
3,500 lines ~ 20 min
40,000 lines ~ 10 hrs
an analysis of large
programs or a truly modular
analysis of such systems
BUT …
WHAT THEY CAN’T DO, ABSOLUTELY NOT, NOT FOR CRYING OUT LOUD
1,000 lines ~ 1 min
2,000 lines ~ 2 min
3,000 lines ~ 3 min
3,500 lines ~ 20 min
40,000 lines ~ 10 hrs
an analysis of large
programs or a truly modular
analysis of such systems
BUT …
WHAT THEY CAN’T DO, ABSOLUTELY NOT, NOT FOR CRYING OUT LOUD
1,000 lines ~ 1 min
2,000 lines ~ 2 min
3,000 lines ~ 3 min
3,500 lines ~ 20 min
40,000 lines ~ 10 hrs
an analysis of large
programs or a truly modular
analysis of such systems
BUT …
WE KNOW TRANSITIVE CLOSURE IS
BASICALLY O(N^3) .. BUT ..
WHAT THEY CAN’T DO, ABSOLUTELY NOT, NOT FOR CRYING OUT LOUD
1,000 lines ~ 1 min
2,000 lines ~ 2 min
3,000 lines ~ 3 min
3,500 lines ~ 20 min
40,000 lines ~ 10 hrs
an analysis of large
programs or a truly modular
analysis of such systems
BUT …
WE KNOW TRANSITIVE CLOSURE IS
BASICALLY O(N^3) .. BUT ..
O(n^8)
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
1998
1995-97
FLANAGAN CAN CHECK 3,000 LINES
FLANAGAN CAN EXPLAIN ERRORS
WE CANNOT ANALYZE THE
COMPLETE CODE BASE OF THE
SYSTEM ITSELF OR ITS CONTEXT.
WE CAN’T EVEN ‘MODULARIZE’
THE ANALYSIS PROPERLY.
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
1998
1995-97
FLANAGAN CAN CHECK 3,000 LINES
YOURS TRULY SAYS
PROGRAMMERS USE
ASSERTIONS, THEY WILL USE
“CONTRACTS.”
FLANAGAN CAN EXPLAIN ERRORS
WE CANNOT ANALYZE THE
COMPLETE CODE BASE OF THE
SYSTEM ITSELF OR ITS CONTEXT.
WE CAN’T EVEN ‘MODULARIZE’
THE ANALYSIS PROPERLY.
HEYA, DID YOU CATCH THIS MISTAKE?
▸ modules comes with contracts
▸ type inference turns contracts into
constraints
▸ .. and stores derived constraints per
module
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
2002/03
THE DREAM COME TRUE. WE’RE DONE.
MEUNIER’S MRSPIDE
CAN DO IT ALL
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
2002/03
THE DREAM COME TRUE. WE’RE DONE.
MEUNIER’S MRSPIDE
CAN DO IT ALL
2005
PROGRAMMERS DON’T REALLY
WRITE GOOD CONTRACTS.
THE TYPES BECOME HUGE AND
INCOMPREHENSIBLE. EVEN WITH GOOD CONTRACTS,
MODULAR ANALYSIS REMAINS A
PIPE DREAM.
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
2002/03
THE DREAM COME TRUE. WE’RE DONE.
MEUNIER’S MRSPIDE
CAN DO IT ALL
2005
PROGRAMMERS DON’T REALLY
WRITE GOOD CONTRACTS.
THE TYPES BECOME HUGE AND
INCOMPREHENSIBLE. EVEN WITH GOOD CONTRACTS,
MODULAR ANALYSIS REMAINS A
PIPE DREAM.
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
2002/03
THE DREAM COME TRUE. WE’RE DONE.
MEUNIER’S MRSPIDE
CAN DO IT ALL
YOURS TRULY SAYS
“NEVER MIND.”
2005
PROGRAMMERS DON’T REALLY
WRITE GOOD CONTRACTS.
THE TYPES BECOME HUGE AND
INCOMPREHENSIBLE. EVEN WITH GOOD CONTRACTS,
MODULAR ANALYSIS REMAINS A
PIPE DREAM.
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
2002/03
THE DREAM COME TRUE. WE’RE DONE.
MEUNIER’S MRSPIDE
CAN DO IT ALL
YOURS TRULY SAYS
“NEVER MIND.”
2005
PROGRAMMERS DON’T REALLY
WRITE GOOD CONTRACTS.
THE TYPES BECOME HUGE AND
INCOMPREHENSIBLE. EVEN WITH GOOD CONTRACTS,
MODULAR ANALYSIS REMAINS A
PIPE DREAM.
THE PROBLEM HAD
BECOME REAL. IT WAS
TIME TO THINK
DIFFERENTLY
LET’S ADD TYPES INCREMENTALLY
TO A CODE BASE AND MAKE SURE
THE COMBINATION IS SOUND.
ADD TYPES INCREMENTALLY
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology?
(p true))
(tautology?
(p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
ADD TYPES INCREMENTALLY
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology?
(p true))
(tautology?
(p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
‣ You want to add types.
‣ And now you have two problems:
‣ You should not change code that works, other
than adding type annotations and definitions.
Respect existing idioms of the language.
‣ You want the existing untyped code to play well
with the newly typed code. Respect the central
theorem of programming languages, type
soundness.
ADD TYPES INCREMENTALLY
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology?
(p true))
(tautology?
(p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
ADD TYPES INCREMENTALLY
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology?
(p true))
(tautology?
(p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true)) (tautology? (p false)))]))
(tautology? true)
(tautology? (lambda (x) (lambda (y) (or x y))))
ADD TYPES INCREMENTALLY
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology?
(p true))
(tautology?
(p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true)) (tautology? (p false)))]))
(tautology? true)
(tautology? (lambda (x) (lambda (y) (or x y))))
(define-type Proposition (U Boolean (Boolean -> Proposition)))
(: tautology? (-> Proposition Boolean))
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true)) (tautology? (p false)))]))
(tautology? true)
(tautology? (lambda ({x : Boolean}) (lambda ({y : Boolean}) (or x y))))
ADD TYPES INCREMENTALLY
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology?
(p true))
(tautology?
(p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
ADD TYPES INCREMENTALLY
ADD TYPES INCREMENTALLY: ACCOMMODATING GROWN PROGRAMMING IDIOMS
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology?
(p true))
(tautology?
(p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
(define-type Proposition (U Boolean (Boolean -> Proposition)))
(: tautology? (Proposition -> Boolean))
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true)) (tautology? (p false)))]))
ADD TYPES INCREMENTALLY: ACCOMMODATING GROWN PROGRAMMING IDIOMS
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology?
(p true))
(tautology?
(p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
(define-type Proposition (U Boolean (Boolean -> Proposition)))
(: tautology? (Proposition -> Boolean))
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true)) (tautology? (p false)))]))
: PROPOSITION
ADD TYPES INCREMENTALLY: ACCOMMODATING GROWN PROGRAMMING IDIOMS
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology?
(p true))
(tautology?
(p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
(define-type Proposition (U Boolean (Boolean -> Proposition)))
(: tautology? (Proposition -> Boolean))
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true)) (tautology? (p false)))]))
: PROPOSITION
: BOOLEAN
ADD TYPES INCREMENTALLY: ACCOMMODATING GROWN PROGRAMMING IDIOMS
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology?
(p true))
(tautology?
(p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
(define-type Proposition (U Boolean (Boolean -> Proposition)))
(: tautology? (Proposition -> Boolean))
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true)) (tautology? (p false)))]))
: PROPOSITION
: BOOLEAN
: (-> BOOLEAN PROPOPSITION): (-> BOOLEAN PROPOPSITION)
ADD TYPES INCREMENTALLY: ACCOMMODATING GROWN PROGRAMMING IDIOMS
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology?
(p true))
(tautology?
(p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
(define-type Proposition (U Boolean (Boolean -> Proposition)))
(: tautology? (Proposition -> Boolean))
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true)) (tautology? (p false)))]))
: PROPOSITION
: BOOLEAN
: (-> BOOLEAN PROPOPSITION): (-> BOOLEAN PROPOPSITION)ICFP 2010
ADD TYPES INCREMENTALLY: PROTECTION FROM CONTRACTS
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology?
(p true))
(tautology?
(p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
.. … …
(provide:
(big? (-> Integer Bool))
.. … …
.. … …
(require A)
(big? “hello world”)
.. … …
module A
module B
ADD TYPES INCREMENTALLY: PROTECTION FROM CONTRACTS
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology?
(p true))
(tautology?
(p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
.. … …
(provide:
(big? (-> Integer Bool))
.. … …
.. … …
(require A)
(big? “hello world”)
.. … …
module A
WHAT PREVENTS MODULE B FROM APPLYING
THE BIG? FUNCTION TO A STRING?
CONTRACTS!
module B
ADD TYPES INCREMENTALLY: PROTECTION FROM CONTRACTS
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology?
(p true))
(tautology?
(p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
.. … …
(provide:
(big? (-> Integer Bool))
.. … …
.. … …
(require A)
(big? “hello world”)
.. … …
module A
WHAT PREVENTS MODULE B FROM APPLYING
THE BIG? FUNCTION TO A STRING?
CONTRACTS!
module B
DLS 2006
ADD TYPES INCREMENTALLY: PROTECTION FROM CONTRACTS
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology?
(p true))
(tautology?
(p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
(require A)
.. (provvide
(all-from A)) ..
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
.. … …
(provide:
(big? (-> Integer Bool))
.. … …
.. … …
(require B)
(big? “hello world”)
.. … …
module A
ADD TYPES INCREMENTALLY: PROTECTION FROM CONTRACTS
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology?
(p true))
(tautology?
(p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
(require A)
.. (provvide
(all-from A)) ..
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
.. … …
(provide:
(big? (-> Integer Bool))
.. … …
.. … …
(require B)
(big? “hello world”)
.. … …
module A
ADD TYPES INCREMENTALLY: PROTECTION FROM CONTRACTS
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology?
(p true))
(tautology?
(p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
(require A)
.. (provvide
(all-from A)) ..
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
.. … …
(provide:
(big? (-> Integer Bool))
.. … …
.. … …
(require B)
(big? “hello world”)
.. … …
module A
POPL 2008
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
THE IDEA IS WORKED OUT
THE CONTRACTS WORK
THE TYPE SYSTEMS ACCOMMODATES
THE EXISTING IDIOMS.
2006-2010
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
THE IDEA IS WORKED OUT
THE CONTRACTS WORK
THE TYPE SYSTEMS ACCOMMODATES
THE EXISTING IDIOMS.
2006-2010
WHAT’S
MISSING?
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
THE IDEA IS WORKED OUT
THE CONTRACTS WORK
THE TYPE SYSTEMS ACCOMMODATES
THE EXISTING IDIOMS.
2006-2010
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
THE IDEA IS WORKED OUT
THE CONTRACTS WORK
THE TYPE SYSTEMS ACCOMMODATES
THE EXISTING IDIOMS.
2006-2010
OBJECT-
ORIENTED RACKET
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
THE IDEA IS WORKED OUT
THE CONTRACTS WORK
THE TYPE SYSTEMS ACCOMMODATES
THE EXISTING IDIOMS.
2006-2010
OBJECT-
ORIENTED RACKET
THERE IT
IS!
THERE IT
IS!
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
THE IDEA IS WORKED OUT
THE CONTRACTS WORK
THE TYPE SYSTEMS ACCOMMODATES
THE EXISTING IDIOMS.
2006-2010
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
THE IDEA IS WORKED OUT
THE CONTRACTS WORK
THE TYPE SYSTEMS ACCOMMODATES
THE EXISTING IDIOMS.
2006-2010
WE HAVE A DESIGN FOR OO RACKET.
2013
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
THE IDEA IS WORKED OUT
THE CONTRACTS WORK
THE TYPE SYSTEMS ACCOMMODATES
THE EXISTING IDIOMS.
2006-2010
WE HAVE A DESIGN FOR OO RACKET.
2013
WE HAVE AN IMPLEMENTATION.
2015
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
THE IDEA IS WORKED OUT
THE CONTRACTS WORK
THE TYPE SYSTEMS ACCOMMODATES
THE EXISTING IDIOMS.
2006-2010
WE HAVE A DESIGN FOR OO RACKET.
2013
WE HAVE AN IMPLEMENTATION.
2015
EVERYTHING
HUNKY DORY?
ADDING TYPES INCREMENTALLY: PERFORMANCE MEASUREMENTS
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology? (p true))
(tautology? (p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
lambda (x)
(or x y))))
false)
lambda (x)
(or x y))))
false)
(define (tautology? p)
(cond
[(boolean? p) p]
[else (and (tautology?
(p true))
(tautology?
(p false)))]))
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
;; Proposition = Boolean | (Boolean -> Proposition)
;; Proposition -> Boolean
(check-expect (tautology? (lambda (_) true)) true)
(check-expect
(tautology?
POPL 2016
THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
PERFORMANCE. PERFORMANCE.
PERFORMANCE.
2016
BACK TO THIS LOVE AND PHD BUSINESS.
WHAT DO YOU DO WHEN YOU GET INTO SUCH A BAD SITUATION?
IS SOUND GRADUAL TYPING DEAD?
2016
1993
1996
2002
2009 2015
1991
TYPE INFERENCE
INCREMENTALLY ADDED
EXPLICITLY STATIC TYPES
WHAT DO YOU DO WHEN YOU GET INTO SUCH A BAD SITUATION?
IS SOUND GRADUAL TYPING DEAD?
2016
1993
1996
2002
2009 2015
1991
TYPE INFERENCE
INCREMENTALLY ADDED
EXPLICITLY STATIC TYPES
RESEARCH IS WHEN IT CAN FAIL
WHAT DO YOU DO WHEN YOU GET INTO SUCH A BAD SITUATION?
IS SOUND GRADUAL TYPING DEAD?
2016
1993
1996
2002
2009 2015
1991
TYPE INFERENCE
INCREMENTALLY ADDED
EXPLICITLY STATIC TYPES
WHAT DO YOU DO WHEN YOU GET INTO SUCH A BAD SITUATION?
IS SOUND GRADUAL TYPING DEAD?
2016
1993
1996
2002
2009 2015
1991
TYPE INFERENCE
INCREMENTALLY ADDED
EXPLICITLY STATIC TYPES
THIS HAPPENS TO ADVISORS
WITH A LONG-TERM RESEARCH
PROGRAM
WHAT DO YOU DO WHEN YOU GET INTO SUCH A BAD SITUATION?
IS SOUND GRADUAL TYPING DEAD?
2016
1993
1996
2002
2009 2015
1991
TYPE INFERENCE
INCREMENTALLY ADDED
EXPLICITLY STATIC TYPES
WHAT DO YOU DO WHEN YOU GET INTO SUCH A BAD SITUATION?
IS SOUND GRADUAL TYPING DEAD?
2016
1993
1996
2002
2009 2015
1991
TYPE INFERENCE
INCREMENTALLY ADDED
EXPLICITLY STATIC TYPES
AND IT HAPPENS TO STUDENTS
DURING A PHD PROGRAM.
PHD RESEARCH: BE PREPARED FOR UPS AND DOWNS
PhD research, like a
relationship, has its
ups and downs.
The downs can feel
very down. Really.
The memories of
“falling in love” can
get you going again.
The ups feel good.
PHD RESEARCH: BE PREPARED FOR UPS AND DOWNS
PhD research, like a
relationship, has its
ups and downs.
The downs can feel
very down. Really.
The memories of
“falling in love” can
get you going again.
The ups feel good.
YES, THIS IS IRRATIONAL BUT WHILE DESIGN,
ENGINEERING, & SCIENCE PRODUCE RATIONAL RESULTS,
THE MOTIVATION NEEDS AN IRRATIONAL ELEMENT.
PHD RESEARCH: BE PREPARED FOR UPS AND DOWNS
PhD research, like a
relationship, has its
ups and downs.
The downs can feel
very down. Really.
The memories of
“falling in love” can
get you going again.
The ups feel good.
▸ And your advisor’s emotional
wavelength matters, a lot.
▸ So choose your advisor well.
PHD RESEARCH: BE PREPARED FOR UPS AND DOWNS
PhD research, like a
relationship, has its
ups and downs.
The downs can feel
very down. Really.
The memories of
“falling in love” can
get you going again.
The ups feel good.
▸ And your advisor’s emotional
wavelength matters, a lot.
▸ So choose your advisor well.
LOVE, LOVE IS WHAT YOU REALLY NEED.
THE END
▸ And two dozen PhD students, who had
the guts to work with me and believed
I could be their scientific and
emotional guide
▸ Daniel Friedman, my advisor,
for showing me what an advisor
can do for a PhD student
▸ Herrn G. Dopfer, my high school
mathematics teacher, for encouraging me to
not take English, focus on math and physics,
and go to university, a first for our family
QUESTIONS?

More Related Content

Viewers also liked

Viewers also liked (13)

Research is a Social Process
Research is a Social ProcessResearch is a Social Process
Research is a Social Process
 
The Truth, the Whole Truth, and Nothing but the Truth: A Pragmatic Guide to A...
The Truth, the Whole Truth, and Nothing but the Truth: A Pragmatic Guide to A...The Truth, the Whole Truth, and Nothing but the Truth: A Pragmatic Guide to A...
The Truth, the Whole Truth, and Nothing but the Truth: A Pragmatic Guide to A...
 
Professional Communication
Professional CommunicationProfessional Communication
Professional Communication
 
Simple made easy
Simple made easySimple made easy
Simple made easy
 
Programming Paradigms
Programming ParadigmsProgramming Paradigms
Programming Paradigms
 
Whither Software Engineering Research? (keynote talk at APSEC 2012)
Whither Software Engineering Research? (keynote talk at APSEC 2012)Whither Software Engineering Research? (keynote talk at APSEC 2012)
Whither Software Engineering Research? (keynote talk at APSEC 2012)
 
Career Management (invited talk at ICSE 2014 NFRS)
Career Management (invited talk at ICSE 2014 NFRS)Career Management (invited talk at ICSE 2014 NFRS)
Career Management (invited talk at ICSE 2014 NFRS)
 
Known Unknowns: Testing in the Presence of Uncertainty (talk at ACM SIGSOFT F...
Known Unknowns: Testing in the Presence of Uncertainty (talk at ACM SIGSOFT F...Known Unknowns: Testing in the Presence of Uncertainty (talk at ACM SIGSOFT F...
Known Unknowns: Testing in the Presence of Uncertainty (talk at ACM SIGSOFT F...
 
Applications and Abstractions: A Cautionary Tale (invited talk at a DIMACS Wo...
Applications and Abstractions: A Cautionary Tale (invited talk at a DIMACS Wo...Applications and Abstractions: A Cautionary Tale (invited talk at a DIMACS Wo...
Applications and Abstractions: A Cautionary Tale (invited talk at a DIMACS Wo...
 
Probability and Uncertainty in Software Engineering (keynote talk at NASAC 2013)
Probability and Uncertainty in Software Engineering (keynote talk at NASAC 2013)Probability and Uncertainty in Software Engineering (keynote talk at NASAC 2013)
Probability and Uncertainty in Software Engineering (keynote talk at NASAC 2013)
 
Felicitous Computing (invited Talk for UC Irvine ISR Distinguished Speaker Se...
Felicitous Computing (invited Talk for UC Irvine ISR Distinguished Speaker Se...Felicitous Computing (invited Talk for UC Irvine ISR Distinguished Speaker Se...
Felicitous Computing (invited Talk for UC Irvine ISR Distinguished Speaker Se...
 
The Power of Probabilistic Thinking (keynote talk at ASE 2016)
The Power of Probabilistic Thinking (keynote talk at ASE 2016)The Power of Probabilistic Thinking (keynote talk at ASE 2016)
The Power of Probabilistic Thinking (keynote talk at ASE 2016)
 
Jogging While Driving, and Other Software Engineering Research Problems (invi...
Jogging While Driving, and Other Software Engineering Research Problems (invi...Jogging While Driving, and Other Software Engineering Research Problems (invi...
Jogging While Driving, and Other Software Engineering Research Problems (invi...
 

Similar to Felleisen_Keynote

Similar to Felleisen_Keynote (14)

The Future of Motion Design
The Future of Motion DesignThe Future of Motion Design
The Future of Motion Design
 
Intro to Procedural Context Generation for Text
Intro to Procedural Context Generation for TextIntro to Procedural Context Generation for Text
Intro to Procedural Context Generation for Text
 
Communicating Science Effectively
Communicating Science EffectivelyCommunicating Science Effectively
Communicating Science Effectively
 
Essay Curfew Laws. Online assignment writing service.
Essay Curfew Laws. Online assignment writing service.Essay Curfew Laws. Online assignment writing service.
Essay Curfew Laws. Online assignment writing service.
 
Types For Frontend Developers
Types For Frontend DevelopersTypes For Frontend Developers
Types For Frontend Developers
 
Teaching Grammar . . . Theory & Practice
Teaching Grammar . . . Theory & PracticeTeaching Grammar . . . Theory & Practice
Teaching Grammar . . . Theory & Practice
 
Intuitive Intro to Gödel's Incompleteness Theorem
Intuitive Intro to Gödel's Incompleteness TheoremIntuitive Intro to Gödel's Incompleteness Theorem
Intuitive Intro to Gödel's Incompleteness Theorem
 
Essay
EssayEssay
Essay
 
Art for Ads' Sake Mumbrella360 2017
Art for Ads' Sake Mumbrella360 2017Art for Ads' Sake Mumbrella360 2017
Art for Ads' Sake Mumbrella360 2017
 
Artificial Intelligence and Machine Learning
Artificial Intelligence and Machine LearningArtificial Intelligence and Machine Learning
Artificial Intelligence and Machine Learning
 
Tom's TEFL - Occupations
Tom's TEFL - OccupationsTom's TEFL - Occupations
Tom's TEFL - Occupations
 
2019-02 The Recommendation Engine @ SunshinePHP
2019-02 The Recommendation Engine @ SunshinePHP2019-02 The Recommendation Engine @ SunshinePHP
2019-02 The Recommendation Engine @ SunshinePHP
 
The Potential of Metadata - Geoweb 2010
The Potential of Metadata - Geoweb 2010The Potential of Metadata - Geoweb 2010
The Potential of Metadata - Geoweb 2010
 
Poems method Lorie Whitaker - IXDA 2018
Poems method   Lorie Whitaker - IXDA 2018Poems method   Lorie Whitaker - IXDA 2018
Poems method Lorie Whitaker - IXDA 2018
 

Recently uploaded

Human genetics..........................pptx
Human genetics..........................pptxHuman genetics..........................pptx
Human genetics..........................pptx
Silpa
 
biology HL practice questions IB BIOLOGY
biology HL practice questions IB BIOLOGYbiology HL practice questions IB BIOLOGY
biology HL practice questions IB BIOLOGY
1301aanya
 
+971581248768>> SAFE AND ORIGINAL ABORTION PILLS FOR SALE IN DUBAI AND ABUDHA...
+971581248768>> SAFE AND ORIGINAL ABORTION PILLS FOR SALE IN DUBAI AND ABUDHA...+971581248768>> SAFE AND ORIGINAL ABORTION PILLS FOR SALE IN DUBAI AND ABUDHA...
+971581248768>> SAFE AND ORIGINAL ABORTION PILLS FOR SALE IN DUBAI AND ABUDHA...
?#DUbAI#??##{{(☎️+971_581248768%)**%*]'#abortion pills for sale in dubai@
 
Porella : features, morphology, anatomy, reproduction etc.
Porella : features, morphology, anatomy, reproduction etc.Porella : features, morphology, anatomy, reproduction etc.
Porella : features, morphology, anatomy, reproduction etc.
Silpa
 
Bacterial Identification and Classifications
Bacterial Identification and ClassificationsBacterial Identification and Classifications
Bacterial Identification and Classifications
Areesha Ahmad
 

Recently uploaded (20)

Proteomics: types, protein profiling steps etc.
Proteomics: types, protein profiling steps etc.Proteomics: types, protein profiling steps etc.
Proteomics: types, protein profiling steps etc.
 
Human genetics..........................pptx
Human genetics..........................pptxHuman genetics..........................pptx
Human genetics..........................pptx
 
GBSN - Microbiology (Unit 2)
GBSN - Microbiology (Unit 2)GBSN - Microbiology (Unit 2)
GBSN - Microbiology (Unit 2)
 
Locating and isolating a gene, FISH, GISH, Chromosome walking and jumping, te...
Locating and isolating a gene, FISH, GISH, Chromosome walking and jumping, te...Locating and isolating a gene, FISH, GISH, Chromosome walking and jumping, te...
Locating and isolating a gene, FISH, GISH, Chromosome walking and jumping, te...
 
GBSN - Biochemistry (Unit 1)
GBSN - Biochemistry (Unit 1)GBSN - Biochemistry (Unit 1)
GBSN - Biochemistry (Unit 1)
 
CURRENT SCENARIO OF POULTRY PRODUCTION IN INDIA
CURRENT SCENARIO OF POULTRY PRODUCTION IN INDIACURRENT SCENARIO OF POULTRY PRODUCTION IN INDIA
CURRENT SCENARIO OF POULTRY PRODUCTION IN INDIA
 
biology HL practice questions IB BIOLOGY
biology HL practice questions IB BIOLOGYbiology HL practice questions IB BIOLOGY
biology HL practice questions IB BIOLOGY
 
Thyroid Physiology_Dr.E. Muralinath_ Associate Professor
Thyroid Physiology_Dr.E. Muralinath_ Associate ProfessorThyroid Physiology_Dr.E. Muralinath_ Associate Professor
Thyroid Physiology_Dr.E. Muralinath_ Associate Professor
 
+971581248768>> SAFE AND ORIGINAL ABORTION PILLS FOR SALE IN DUBAI AND ABUDHA...
+971581248768>> SAFE AND ORIGINAL ABORTION PILLS FOR SALE IN DUBAI AND ABUDHA...+971581248768>> SAFE AND ORIGINAL ABORTION PILLS FOR SALE IN DUBAI AND ABUDHA...
+971581248768>> SAFE AND ORIGINAL ABORTION PILLS FOR SALE IN DUBAI AND ABUDHA...
 
300003-World Science Day For Peace And Development.pptx
300003-World Science Day For Peace And Development.pptx300003-World Science Day For Peace And Development.pptx
300003-World Science Day For Peace And Development.pptx
 
GBSN - Microbiology (Unit 1)
GBSN - Microbiology (Unit 1)GBSN - Microbiology (Unit 1)
GBSN - Microbiology (Unit 1)
 
Porella : features, morphology, anatomy, reproduction etc.
Porella : features, morphology, anatomy, reproduction etc.Porella : features, morphology, anatomy, reproduction etc.
Porella : features, morphology, anatomy, reproduction etc.
 
An introduction on sequence tagged site mapping
An introduction on sequence tagged site mappingAn introduction on sequence tagged site mapping
An introduction on sequence tagged site mapping
 
FAIRSpectra - Enabling the FAIRification of Spectroscopy and Spectrometry
FAIRSpectra - Enabling the FAIRification of Spectroscopy and SpectrometryFAIRSpectra - Enabling the FAIRification of Spectroscopy and Spectrometry
FAIRSpectra - Enabling the FAIRification of Spectroscopy and Spectrometry
 
Chemistry 5th semester paper 1st Notes.pdf
Chemistry 5th semester paper 1st Notes.pdfChemistry 5th semester paper 1st Notes.pdf
Chemistry 5th semester paper 1st Notes.pdf
 
Bacterial Identification and Classifications
Bacterial Identification and ClassificationsBacterial Identification and Classifications
Bacterial Identification and Classifications
 
Human & Veterinary Respiratory Physilogy_DR.E.Muralinath_Associate Professor....
Human & Veterinary Respiratory Physilogy_DR.E.Muralinath_Associate Professor....Human & Veterinary Respiratory Physilogy_DR.E.Muralinath_Associate Professor....
Human & Veterinary Respiratory Physilogy_DR.E.Muralinath_Associate Professor....
 
Exploring Criminology and Criminal Behaviour.pdf
Exploring Criminology and Criminal Behaviour.pdfExploring Criminology and Criminal Behaviour.pdf
Exploring Criminology and Criminal Behaviour.pdf
 
Dr. E. Muralinath_ Blood indices_clinical aspects
Dr. E. Muralinath_ Blood indices_clinical  aspectsDr. E. Muralinath_ Blood indices_clinical  aspects
Dr. E. Muralinath_ Blood indices_clinical aspects
 
Grade 7 - Lesson 1 - Microscope and Its Functions
Grade 7 - Lesson 1 - Microscope and Its FunctionsGrade 7 - Lesson 1 - Microscope and Its Functions
Grade 7 - Lesson 1 - Microscope and Its Functions
 

Felleisen_Keynote

  • 1. LOVE, MARRIAGE & HAPPINESS MATTHIAS FELLEISEN, NU PRL
  • 2. MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL)
  • 3. MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL) 1980
  • 4. MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL) 1980 1984
  • 5. MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL) 1980 1984 1985
  • 6. MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL) 1980 1984 1985
  • 7. MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL) 1980 1984 1985
  • 8. MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL) 1980 1984 1985 1987
  • 9. MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL) 1980 1984 1985
  • 10. MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL) 1980 1984 1985 1987
  • 11. MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL) 1980 1984 1985 1987 1992
  • 12. MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL) 1980 1984 1985 1987
  • 13. MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL) 1980 1984 1985 1987 2001
  • 14. MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL) 1980 1984 1985 1987 2001
  • 15. MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL) 1980 1984 1985 1987 2001 G*DDAMN FOREIGNER
  • 16. MY CAREER, GEOGRAPHY & NUMBERS (THIS IS PLDI AFTER ALL) 1980 1984 1985 1987 2001 G*DDAMN FOREIGNER
  • 17.
  • 18. WHAT’S LOVE GOT TO DO WITH IT πrogramming λanguages You are here because you fell in love with something about programming languages.
  • 19. YOU CAN’T JUST KEEP YOUR FINGERS OFF πrogramming λanguages The most fundamental area of computer science. If you don’t have a language, you can’t compute.
  • 20. YOU CAN’T JUST KEEP YOUR FINGERS OFF πrogramming λanguages The most fundamental area of computer science. If you don’t have a language, you can’t compute. Developers primarily use programming languages. The tools we build have meaning for them.
  • 21. YOU CAN’T JUST KEEP YOUR FINGERS OFF πrogramming λanguages The most fundamental area of computer science. If you don’t have a language, you can’t compute. Developers primarily use programming languages. The tools we build have meaning for them. You will get to work with elegant mathematics and, some of you will develop new mathematics.
  • 22. YOU CAN’T JUST KEEP YOUR FINGERS OFF πrogramming λanguages The most fundamental area of computer science. If you don’t have a language, you can’t compute. Developers primarily use programming languages. The tools we build have meaning for them. You will get to work with elegant mathematics and, some of you will develop new mathematics. Where else do you get to work with the coolest professors on the planet?
  • 23. SO WHAT’S IT LIKE TO GET MARRIED TO PL RESEARCH
  • 24. SO WHAT’S IT LIKE TO GET MARRIED TO PL RESEARCH
  • 25. IT HAS ITS UPS AND DOWNS.
  • 26. IT HAS ITS UPS AND DOWNS. Falling in love.
  • 27. IT HAS ITS UPS AND DOWNS. Falling in love. Being in love.
  • 28. IT HAS ITS UPS AND DOWNS. Falling in love. Being in love. Getting thru difficult, troublesome times …
  • 29. AND LOVE IS WHAT GETS YOU BACK ON TRACK.
  • 30. AND LOVE IS WHAT GETS YOU BACK ON TRACK. But really, if you don’t love PL, getting a PhD is hard.
  • 31. AND LOVE IS WHAT GETS YOU BACK ON TRACK. But really, if you don’t love PL, getting a PhD is hard. Hard because it’s an old and now ‘hidden’ discipline.
  • 32. AND LOVE IS WHAT GETS YOU BACK ON TRACK. But really, if you don’t love PL, getting a PhD is hard. Hard because it’s an old and now ‘hidden’ discipline. HARD because it isn’t ‘hot’ with IT industry.
  • 33. AND LOVE IS WHAT GETS YOU BACK ON TRACK. But really, if you don’t love PL, getting a PhD is hard. Hard because it’s an old and now ‘hidden’ discipline. HARD because it isn’t ‘hot’ with IT industry. H.A.R.D.
  • 34. ONE LAST WARNING: IF YOU DON’T LOVE IT, LEAVE IT.
  • 35. ONE LAST WARNING: IF YOU DON’T LOVE IT, LEAVE IT. If you want to be famous, get into Artificial Intelligence.
  • 36. ONE LAST WARNING: IF YOU DON’T LOVE IT, LEAVE IT. If you want to be famous, get into Artificial Intelligence. If you want to make money, do Big Data.
  • 37. ONE LAST WARNING: IF YOU DON’T LOVE IT, LEAVE IT. If you want to be famous, get into Artificial Intelligence. If you want to make money, do Big Data. If you want a career, switch majors. I hear our Business School is looking for students.
  • 38. TYPES FOR UNTYPED LANGUAGES, HOW LOVE WORKS
  • 39. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS
  • 40. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS 1987 CORKY CARTWRIGHT “LET’S WORK ON TYPES FOR SCHEME”
  • 41. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS 1987 CORKY CARTWRIGHT “LET’S WORK ON TYPES FOR SCHEME” 1988 (It doesn’t have to be love at first sight.)
  • 42. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS 1987 CORKY CARTWRIGHT “LET’S WORK ON TYPES FOR SCHEME” COOL! WORKING WITH CARTWRIGHT AND FAGAN 1989 1988 (It doesn’t have to be love at first sight.)
  • 43. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS 1987 CORKY CARTWRIGHT “LET’S WORK ON TYPES FOR SCHEME” COOL! WORKING WITH CARTWRIGHT AND FAGAN 1989 1993/94 THE ONLY USER OF ANDREW WRIGHT’S SOFT SCHEME 1988 (It doesn’t have to be love at first sight.)
  • 44. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS 1987 CORKY CARTWRIGHT “LET’S WORK ON TYPES FOR SCHEME” COOL! WORKING WITH CARTWRIGHT AND FAGAN 1989 1993/94 THE ONLY USER OF ANDREW WRIGHT’S SOFT SCHEME 1988 (It doesn’t have to be love at first sight.) CO-CREATED SPIDEY SCHEME WITH CORMAC FLANAGAN 1995/97
  • 45. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS 1987 CORKY CARTWRIGHT “LET’S WORK ON TYPES FOR SCHEME” COOL! WORKING WITH CARTWRIGHT AND FAGAN 1989 1993/94 THE ONLY USER OF ANDREW WRIGHT’S SOFT SCHEME 1988 (It doesn’t have to be love at first sight.) CO-CREATED SPIDEY SCHEME WITH CORMAC FLANAGAN 1995/97 MODULAR SPIDER WITH PHILIPPE MEUNIER 1998/2003
  • 46. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS 1987 CORKY CARTWRIGHT “LET’S WORK ON TYPES FOR SCHEME” COOL! WORKING WITH CARTWRIGHT AND FAGAN 1989 1993/94 THE ONLY USER OF ANDREW WRIGHT’S SOFT SCHEME 1988 (It doesn’t have to be love at first sight.) CO-CREATED SPIDEY SCHEME WITH CORMAC FLANAGAN 1995/97 MODULAR SPIDER WITH PHILIPPE MEUNIER 1998/2003 2005-2016 TYPED RACKET W/ TOBIN-HOCHSTADT
  • 47. (define (tautology? p) (bond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) WHAT’S THE TYPE OF AN UNTYPED PROGRAM? 1987
  • 48. (define (tautology? p) (bond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) WHAT’S THE TYPE OF AN UNTYPED PROGRAM? 1987
  • 49. (define (tautology? p) (bond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) WHAT’S THE TYPE OF AN UNTYPED PROGRAM? THERE IS LOTS OF LISP OUT THERE AND THEY MAY WANT TYPES. 1987
  • 50. (define (tautology? p) (bond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) WHAT’S THE TYPE OF AN UNTYPED PROGRAM? THERE IS LOTS OF LISP OUT THERE AND THEY MAY WANT TYPES. 1987 WE WANT WIDE-SPECTRUM PROGRAMMING.
  • 51. (define (tautology? p) (bond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) WHAT’S THE TYPE OF AN UNTYPED PROGRAM? THERE IS LOTS OF LISP OUT THERE AND THEY MAY WANT TYPES. PROGRAMMERS DO NOT WANT TO COPE WITH THE IDIOSYNCRASIES OF TYPE SYSTEMS. 1987 WE WANT WIDE-SPECTRUM PROGRAMMING.
  • 52. (define (tautology? p) (bond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) WHAT’S THE TYPE OF AN UNTYPED PROGRAM? THERE IS LOTS OF LISP OUT THERE AND THEY MAY WANT TYPES. PROGRAMMERS DO NOT WANT TO COPE WITH THE IDIOSYNCRASIES OF TYPE SYSTEMS. IT’LL COME TRUE IN 10 OR 20 YEARS. 1987 WE WANT WIDE-SPECTRUM PROGRAMMING.
  • 53. (define (tautology? p) (bond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) WHAT’S THE TYPE OF AN UNTYPED PROGRAM? THERE IS LOTS OF LISP OUT THERE AND THEY MAY WANT TYPES. PROGRAMMERS DO NOT WANT TO COPE WITH THE IDIOSYNCRASIES OF TYPE SYSTEMS. IT’LL COME TRUE IN 10 OR 20 YEARS. 1987 WE WANT WIDE-SPECTRUM PROGRAMMING.
  • 54. WHAT’S THE TYPE OF AN UNTYPED PROGRAM? (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) (tautology? true) (tautology? (lambda (x) (lambda (y) (or x y))))
  • 55. WHAT’S THE TYPE OF AN UNTYPED PROGRAM? (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) (tautology? true) (tautology? (lambda (x) (lambda (y) (or x y))))
  • 56. WHAT’S THE TYPE OF AN UNTYPED PROGRAM? (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) (tautology? true) (tautology? (lambda (x) (lambda (y) (or x y))))
  • 57. EASY! TYPE INFERENCE! ML HAS HAD IT SINCE 1978.
  • 58. WE CAN SAY IT IN OCAML type proposition = InL of bool | InR of (bool -> proposition) let rec is_tautology p = match p with | InL b -> b | InR p -> is_tautology(p true) && is_tautology(p false) is_tautology (InR(fun x -> InL true)) is_tautology (InR(fun x -> InR(fun y -> or then InL x else InL y)))
  • 59. WE CAN SAY IT IN OCAML type proposition = InL of bool | InR of (bool -> proposition) let rec is_tautology p = match p with | InL b -> b | InR p -> is_tautology(p true) && is_tautology(p false) is_tautology (InR(fun x -> InL true)) is_tautology (InR(fun x -> InR(fun y -> or then InL x else InL y))) WE DON’T WANT TO WRITE DOWN TYPE DEFINITIONS. WE DON’T WANT TO ADD INSERTIONS AND PROJECTIONS. WE DON’T WANT TO WRITE DOWN TYPE DEFINITIONS. WE DON’T WANT TO ADD INSERTIONS AND PROJECTIONS. WE DON’T WANT TO WRITE DOWN TYPE DEFINITIONS. WE DON’T WANT TO ADD INSERTIONS AND PROJECTIONS. WE DON’T WANT TO WRITE DOWN TYPE DEFINITIONS. WE DON’T WANT TO ADD INSERTIONS AND PROJECTIONS. WE DON’T WANT TO WRITE DOWN TYPE DEFINITIONS. WE DON’T WANT TO ADD INSERTIONS AND PROJECTIONS. WE DON’T WANT TO WRITE DOWN TYPE DEFINITIONS. WE DON’T WANT TO ADD INSERTIONS AND PROJECTIONS.
  • 60. WE CAN SAY IT IN OCAML type proposition = InL of bool | InR of (bool -> proposition) let rec is_tautology p = match p with | InL b -> b | InR p -> is_tautology(p true) && is_tautology(p false);; is_tautology (InR(fun x -> InL true)) is_tautology (InR(fun x -> InR(fun y -> or then InL x else InL y))) WE DON’T WANT TO WRITE DOWN TYPE DEFINITIONS. WE DON’T WANT TO ADD INSERTIONS AND PROJECTIONS. WE DON’T WANT TO WRITE DOWN TYPE DEFINITIONS. WE DON’T WANT TO ADD INSERTIONS AND PROJECTIONS. WE DON’T WANT TO WRITE DOWN TYPE DEFINITIONS. WE DON’T WANT TO ADD INSERTIONS AND PROJECTIONS. WE DON’T WANT TO WRITE DOWN TYPE DEFINITIONS. WE DON’T WANT TO ADD INSERTIONS AND PROJECTIONS. WE DON’T WANT TO WRITE DOWN TYPE DEFINITIONS. WE DON’T WANT TO ADD INSERTIONS AND PROJECTIONS. WE DON’T WANT TO WRITE DOWN TYPE DEFINITIONS. WE DON’T WANT TO ADD INSERTIONS AND PROJECTIONS. WE DON’T WANT TO WRITE DOWN TYPE DEFINITIONS. WE DON’T WANT TO ADD INSERTIONS AND PROJECTIONS. WE DON’T WANT TO WRITE DOWN TYPE DEFINITIONS. WE DON’T WANT TO ADD INSERTIONS AND PROJECTIONS.
  • 61. SO HOW COULD WE SAY THIS IN SCHEME? ▸ replace ML’s type algebra (x, *, ->, …) ▸ with Remy’s extensible records exclusively ▸ make it work for 100-line purely functional programs in quasi-Scheme
  • 62. SO HOW COULD WE SAY THIS IN SCHEME? ▸ replace ML’s type algebra (x, *, ->, …) ▸ with Remy’s extensible records exclusively ▸ make it work for 100-line purely functional programs in quasi-Scheme ▸ grow it to full Chez Scheme ▸ whole-program inference ▸ success: speed-up
  • 63. WHAT SOFT SCHEME CAN DO (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) (-> (μ (Proposition) (+ Boolean (-> Boolean Proposition))) Boolean) infer via modified HM
  • 64. WHAT SOFT SCHEME CAN DO (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) (-> (μ (Proposition) (+ Boolean (-> Boolean Proposition))) Boolean) infer via modified HM
  • 65. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS 1989 1993 FAGAN CAN CHECK 100 LINES. WRIGHT CAN CHECK 1,000 LINES
  • 66. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS 1989 1993 FAGAN CAN CHECK 100 LINES. WRIGHT CAN CHECK 1,000 LINES YOURS TRULY STRUGGLES WITH DOZENS OF SMALL AND LARGE PROGRAMS. 1993/94
  • 67. WHAT SOFT SCHEME CAN’T DO, (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (p false))]))
  • 68. WHAT SOFT SCHEME CAN’T DO, (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (p false))])) DOZENS OF LINES FOR THE TYPE MISMATCH W/O TELLING THE DEV WHERE THINGS WENT WRONG
  • 69. WHAT SOFT SCHEME CAN’T DO, (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (p false))])) any sensible type-error message, just one, please .. .. .. formulate DOZENS OF LINES FOR THE TYPE MISMATCH W/O TELLING THE DEV WHERE THINGS WENT WRONG
  • 70. WHAT SOFT SCHEME CAN’T DO, any sensible error message, just one, please .. .. .. (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (p false))]))The Problem: Gaussian elimination over equations in an uninterpreted algebras cannot point back to program when the system (of eqs) is inconsistent.
  • 71. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS 1989 1993 FAGAN CAN CHECK 100 LINES. WRIGHT CAN CHECK 1,000 LINES YOURS TRULY STRUGGLES WITH DOZENS OF SMALL AND LARGE PROGRAMS. 1993/94 NEVIN HEINZE SHOWED YOURS TRULY SET-BASED ANALYSIS, AND IT FELT LIKE AN IDEA THAT COULD HELP OUT HERE.
  • 72. HEYA, DID YOU CATCH THIS MISTAKE? ▸ derive sub-typing constraints from code e.g. dom(f) < rng(g) or int < dom(h) ▸ solve via the transitive closure through the constructors in the constraint algebra ▸ find type errors by comparing specified constraints for prime with computed ones
  • 73. WHAT SPIDER CAN DO (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) (-> (μ (Proposition) (U Boolean (-> Boolean Proposition))) Boolean) infer via componential SBA
  • 74. AND THEY CAN EXPLAIN ERRORS, HALLELUJAH! (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (p false))])) (-> (μ (Proposition) (U Boolean (-> Proposition))) Boolean) inspect errors via flow graphs and slices drawn on top of code
  • 75. AND THEY CAN EXPLAIN ERRORS, HALLELUJAH! (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (p false))])) (-> (μ (Proposition) (U Boolean (-> Proposition))) Boolean) inspect errors via flow graphs and slices drawn on top of code EVEN WITH 3RD UNDERGRADUATES
  • 76. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS 1995-97 FLANAGAN CAN CHECK 3,000 LINES STUDENT PROGRAMS FLANAGAN CAN EXPLAIN ERRORS
  • 77. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS 1995-97 FLANAGAN CAN CHECK 3,000 LINES STUDENT PROGRAMS FLANAGAN CAN EXPLAIN ERRORS 1998 WE CANNOT ANALYZE THE COMPLETE CODE BASE OF THE SYSTEM ITSELF OR ITS CONTEXT. WE CAN’T EVEN ‘MODULARIZE’ THE ANALYSIS PROPERLY.
  • 78. WHAT THEY CAN’T DO, ABSOLUTELY NOT, NOT FOR CRYING OUT LOUD 1,000 lines ~ 1 min 2,000 lines ~ 2 min 3,000 lines ~ 3 min 3,500 lines ~ 20 min 40,000 lines ~ 10 hrs an analysis of large programs or a truly modular analysis of such systems BUT …
  • 79. WHAT THEY CAN’T DO, ABSOLUTELY NOT, NOT FOR CRYING OUT LOUD 1,000 lines ~ 1 min 2,000 lines ~ 2 min 3,000 lines ~ 3 min 3,500 lines ~ 20 min 40,000 lines ~ 10 hrs an analysis of large programs or a truly modular analysis of such systems BUT …
  • 80. WHAT THEY CAN’T DO, ABSOLUTELY NOT, NOT FOR CRYING OUT LOUD 1,000 lines ~ 1 min 2,000 lines ~ 2 min 3,000 lines ~ 3 min 3,500 lines ~ 20 min 40,000 lines ~ 10 hrs an analysis of large programs or a truly modular analysis of such systems BUT … WE KNOW TRANSITIVE CLOSURE IS BASICALLY O(N^3) .. BUT ..
  • 81. WHAT THEY CAN’T DO, ABSOLUTELY NOT, NOT FOR CRYING OUT LOUD 1,000 lines ~ 1 min 2,000 lines ~ 2 min 3,000 lines ~ 3 min 3,500 lines ~ 20 min 40,000 lines ~ 10 hrs an analysis of large programs or a truly modular analysis of such systems BUT … WE KNOW TRANSITIVE CLOSURE IS BASICALLY O(N^3) .. BUT .. O(n^8)
  • 82. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS 1998 1995-97 FLANAGAN CAN CHECK 3,000 LINES FLANAGAN CAN EXPLAIN ERRORS WE CANNOT ANALYZE THE COMPLETE CODE BASE OF THE SYSTEM ITSELF OR ITS CONTEXT. WE CAN’T EVEN ‘MODULARIZE’ THE ANALYSIS PROPERLY.
  • 83. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS 1998 1995-97 FLANAGAN CAN CHECK 3,000 LINES YOURS TRULY SAYS PROGRAMMERS USE ASSERTIONS, THEY WILL USE “CONTRACTS.” FLANAGAN CAN EXPLAIN ERRORS WE CANNOT ANALYZE THE COMPLETE CODE BASE OF THE SYSTEM ITSELF OR ITS CONTEXT. WE CAN’T EVEN ‘MODULARIZE’ THE ANALYSIS PROPERLY.
  • 84. HEYA, DID YOU CATCH THIS MISTAKE? ▸ modules comes with contracts ▸ type inference turns contracts into constraints ▸ .. and stores derived constraints per module
  • 85. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS 2002/03 THE DREAM COME TRUE. WE’RE DONE. MEUNIER’S MRSPIDE CAN DO IT ALL
  • 86. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS 2002/03 THE DREAM COME TRUE. WE’RE DONE. MEUNIER’S MRSPIDE CAN DO IT ALL 2005 PROGRAMMERS DON’T REALLY WRITE GOOD CONTRACTS. THE TYPES BECOME HUGE AND INCOMPREHENSIBLE. EVEN WITH GOOD CONTRACTS, MODULAR ANALYSIS REMAINS A PIPE DREAM.
  • 87. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS 2002/03 THE DREAM COME TRUE. WE’RE DONE. MEUNIER’S MRSPIDE CAN DO IT ALL 2005 PROGRAMMERS DON’T REALLY WRITE GOOD CONTRACTS. THE TYPES BECOME HUGE AND INCOMPREHENSIBLE. EVEN WITH GOOD CONTRACTS, MODULAR ANALYSIS REMAINS A PIPE DREAM.
  • 88. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS 2002/03 THE DREAM COME TRUE. WE’RE DONE. MEUNIER’S MRSPIDE CAN DO IT ALL YOURS TRULY SAYS “NEVER MIND.” 2005 PROGRAMMERS DON’T REALLY WRITE GOOD CONTRACTS. THE TYPES BECOME HUGE AND INCOMPREHENSIBLE. EVEN WITH GOOD CONTRACTS, MODULAR ANALYSIS REMAINS A PIPE DREAM.
  • 89. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS 2002/03 THE DREAM COME TRUE. WE’RE DONE. MEUNIER’S MRSPIDE CAN DO IT ALL YOURS TRULY SAYS “NEVER MIND.” 2005 PROGRAMMERS DON’T REALLY WRITE GOOD CONTRACTS. THE TYPES BECOME HUGE AND INCOMPREHENSIBLE. EVEN WITH GOOD CONTRACTS, MODULAR ANALYSIS REMAINS A PIPE DREAM. THE PROBLEM HAD BECOME REAL. IT WAS TIME TO THINK DIFFERENTLY
  • 90. LET’S ADD TYPES INCREMENTALLY TO A CODE BASE AND MAKE SURE THE COMBINATION IS SOUND.
  • 91. ADD TYPES INCREMENTALLY ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))]))
  • 92. ADD TYPES INCREMENTALLY ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ‣ You want to add types. ‣ And now you have two problems: ‣ You should not change code that works, other than adding type annotations and definitions. Respect existing idioms of the language. ‣ You want the existing untyped code to play well with the newly typed code. Respect the central theorem of programming languages, type soundness.
  • 93. ADD TYPES INCREMENTALLY ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))]))
  • 94. ADD TYPES INCREMENTALLY ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) (tautology? true) (tautology? (lambda (x) (lambda (y) (or x y))))
  • 95. ADD TYPES INCREMENTALLY ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) (tautology? true) (tautology? (lambda (x) (lambda (y) (or x y)))) (define-type Proposition (U Boolean (Boolean -> Proposition))) (: tautology? (-> Proposition Boolean)) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) (tautology? true) (tautology? (lambda ({x : Boolean}) (lambda ({y : Boolean}) (or x y))))
  • 96. ADD TYPES INCREMENTALLY ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))]))
  • 98. ADD TYPES INCREMENTALLY: ACCOMMODATING GROWN PROGRAMMING IDIOMS ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) (define-type Proposition (U Boolean (Boolean -> Proposition))) (: tautology? (Proposition -> Boolean)) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))]))
  • 99. ADD TYPES INCREMENTALLY: ACCOMMODATING GROWN PROGRAMMING IDIOMS ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) (define-type Proposition (U Boolean (Boolean -> Proposition))) (: tautology? (Proposition -> Boolean)) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) : PROPOSITION
  • 100. ADD TYPES INCREMENTALLY: ACCOMMODATING GROWN PROGRAMMING IDIOMS ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) (define-type Proposition (U Boolean (Boolean -> Proposition))) (: tautology? (Proposition -> Boolean)) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) : PROPOSITION : BOOLEAN
  • 101. ADD TYPES INCREMENTALLY: ACCOMMODATING GROWN PROGRAMMING IDIOMS ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) (define-type Proposition (U Boolean (Boolean -> Proposition))) (: tautology? (Proposition -> Boolean)) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) : PROPOSITION : BOOLEAN : (-> BOOLEAN PROPOPSITION): (-> BOOLEAN PROPOPSITION)
  • 102. ADD TYPES INCREMENTALLY: ACCOMMODATING GROWN PROGRAMMING IDIOMS ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) (define-type Proposition (U Boolean (Boolean -> Proposition))) (: tautology? (Proposition -> Boolean)) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) : PROPOSITION : BOOLEAN : (-> BOOLEAN PROPOPSITION): (-> BOOLEAN PROPOPSITION)ICFP 2010
  • 103. ADD TYPES INCREMENTALLY: PROTECTION FROM CONTRACTS ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) .. … … (provide: (big? (-> Integer Bool)) .. … … .. … … (require A) (big? “hello world”) .. … … module A module B
  • 104. ADD TYPES INCREMENTALLY: PROTECTION FROM CONTRACTS ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) .. … … (provide: (big? (-> Integer Bool)) .. … … .. … … (require A) (big? “hello world”) .. … … module A WHAT PREVENTS MODULE B FROM APPLYING THE BIG? FUNCTION TO A STRING? CONTRACTS! module B
  • 105. ADD TYPES INCREMENTALLY: PROTECTION FROM CONTRACTS ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) .. … … (provide: (big? (-> Integer Bool)) .. … … .. … … (require A) (big? “hello world”) .. … … module A WHAT PREVENTS MODULE B FROM APPLYING THE BIG? FUNCTION TO A STRING? CONTRACTS! module B DLS 2006
  • 106. ADD TYPES INCREMENTALLY: PROTECTION FROM CONTRACTS ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? (require A) .. (provvide (all-from A)) .. lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) .. … … (provide: (big? (-> Integer Bool)) .. … … .. … … (require B) (big? “hello world”) .. … … module A
  • 107. ADD TYPES INCREMENTALLY: PROTECTION FROM CONTRACTS ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? (require A) .. (provvide (all-from A)) .. lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) .. … … (provide: (big? (-> Integer Bool)) .. … … .. … … (require B) (big? “hello world”) .. … … module A
  • 108. ADD TYPES INCREMENTALLY: PROTECTION FROM CONTRACTS ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? (require A) .. (provvide (all-from A)) .. lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) .. … … (provide: (big? (-> Integer Bool)) .. … … .. … … (require B) (big? “hello world”) .. … … module A POPL 2008
  • 109. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS THE IDEA IS WORKED OUT THE CONTRACTS WORK THE TYPE SYSTEMS ACCOMMODATES THE EXISTING IDIOMS. 2006-2010
  • 110. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS THE IDEA IS WORKED OUT THE CONTRACTS WORK THE TYPE SYSTEMS ACCOMMODATES THE EXISTING IDIOMS. 2006-2010 WHAT’S MISSING?
  • 111. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS THE IDEA IS WORKED OUT THE CONTRACTS WORK THE TYPE SYSTEMS ACCOMMODATES THE EXISTING IDIOMS. 2006-2010
  • 112. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS THE IDEA IS WORKED OUT THE CONTRACTS WORK THE TYPE SYSTEMS ACCOMMODATES THE EXISTING IDIOMS. 2006-2010 OBJECT- ORIENTED RACKET
  • 113. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS THE IDEA IS WORKED OUT THE CONTRACTS WORK THE TYPE SYSTEMS ACCOMMODATES THE EXISTING IDIOMS. 2006-2010 OBJECT- ORIENTED RACKET THERE IT IS! THERE IT IS!
  • 114. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS THE IDEA IS WORKED OUT THE CONTRACTS WORK THE TYPE SYSTEMS ACCOMMODATES THE EXISTING IDIOMS. 2006-2010
  • 115. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS THE IDEA IS WORKED OUT THE CONTRACTS WORK THE TYPE SYSTEMS ACCOMMODATES THE EXISTING IDIOMS. 2006-2010 WE HAVE A DESIGN FOR OO RACKET. 2013
  • 116. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS THE IDEA IS WORKED OUT THE CONTRACTS WORK THE TYPE SYSTEMS ACCOMMODATES THE EXISTING IDIOMS. 2006-2010 WE HAVE A DESIGN FOR OO RACKET. 2013 WE HAVE AN IMPLEMENTATION. 2015
  • 117. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS THE IDEA IS WORKED OUT THE CONTRACTS WORK THE TYPE SYSTEMS ACCOMMODATES THE EXISTING IDIOMS. 2006-2010 WE HAVE A DESIGN FOR OO RACKET. 2013 WE HAVE AN IMPLEMENTATION. 2015 EVERYTHING HUNKY DORY?
  • 118. ADDING TYPES INCREMENTALLY: PERFORMANCE MEASUREMENTS lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology?lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? lambda (x) (or x y)))) false) lambda (x) (or x y)))) false) (define (tautology? p) (cond [(boolean? p) p] [else (and (tautology? (p true)) (tautology? (p false)))])) ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? ;; Proposition = Boolean | (Boolean -> Proposition) ;; Proposition -> Boolean (check-expect (tautology? (lambda (_) true)) true) (check-expect (tautology? POPL 2016
  • 119. THE UPS AND DOWNS OF ONE OF MY OWN RESEARCH TOPICS PERFORMANCE. PERFORMANCE. PERFORMANCE. 2016
  • 120. BACK TO THIS LOVE AND PHD BUSINESS.
  • 121. WHAT DO YOU DO WHEN YOU GET INTO SUCH A BAD SITUATION? IS SOUND GRADUAL TYPING DEAD? 2016 1993 1996 2002 2009 2015 1991 TYPE INFERENCE INCREMENTALLY ADDED EXPLICITLY STATIC TYPES
  • 122. WHAT DO YOU DO WHEN YOU GET INTO SUCH A BAD SITUATION? IS SOUND GRADUAL TYPING DEAD? 2016 1993 1996 2002 2009 2015 1991 TYPE INFERENCE INCREMENTALLY ADDED EXPLICITLY STATIC TYPES RESEARCH IS WHEN IT CAN FAIL
  • 123. WHAT DO YOU DO WHEN YOU GET INTO SUCH A BAD SITUATION? IS SOUND GRADUAL TYPING DEAD? 2016 1993 1996 2002 2009 2015 1991 TYPE INFERENCE INCREMENTALLY ADDED EXPLICITLY STATIC TYPES
  • 124. WHAT DO YOU DO WHEN YOU GET INTO SUCH A BAD SITUATION? IS SOUND GRADUAL TYPING DEAD? 2016 1993 1996 2002 2009 2015 1991 TYPE INFERENCE INCREMENTALLY ADDED EXPLICITLY STATIC TYPES THIS HAPPENS TO ADVISORS WITH A LONG-TERM RESEARCH PROGRAM
  • 125. WHAT DO YOU DO WHEN YOU GET INTO SUCH A BAD SITUATION? IS SOUND GRADUAL TYPING DEAD? 2016 1993 1996 2002 2009 2015 1991 TYPE INFERENCE INCREMENTALLY ADDED EXPLICITLY STATIC TYPES
  • 126. WHAT DO YOU DO WHEN YOU GET INTO SUCH A BAD SITUATION? IS SOUND GRADUAL TYPING DEAD? 2016 1993 1996 2002 2009 2015 1991 TYPE INFERENCE INCREMENTALLY ADDED EXPLICITLY STATIC TYPES AND IT HAPPENS TO STUDENTS DURING A PHD PROGRAM.
  • 127. PHD RESEARCH: BE PREPARED FOR UPS AND DOWNS PhD research, like a relationship, has its ups and downs. The downs can feel very down. Really. The memories of “falling in love” can get you going again. The ups feel good.
  • 128. PHD RESEARCH: BE PREPARED FOR UPS AND DOWNS PhD research, like a relationship, has its ups and downs. The downs can feel very down. Really. The memories of “falling in love” can get you going again. The ups feel good. YES, THIS IS IRRATIONAL BUT WHILE DESIGN, ENGINEERING, & SCIENCE PRODUCE RATIONAL RESULTS, THE MOTIVATION NEEDS AN IRRATIONAL ELEMENT.
  • 129. PHD RESEARCH: BE PREPARED FOR UPS AND DOWNS PhD research, like a relationship, has its ups and downs. The downs can feel very down. Really. The memories of “falling in love” can get you going again. The ups feel good. ▸ And your advisor’s emotional wavelength matters, a lot. ▸ So choose your advisor well.
  • 130. PHD RESEARCH: BE PREPARED FOR UPS AND DOWNS PhD research, like a relationship, has its ups and downs. The downs can feel very down. Really. The memories of “falling in love” can get you going again. The ups feel good. ▸ And your advisor’s emotional wavelength matters, a lot. ▸ So choose your advisor well. LOVE, LOVE IS WHAT YOU REALLY NEED.
  • 131. THE END ▸ And two dozen PhD students, who had the guts to work with me and believed I could be their scientific and emotional guide ▸ Daniel Friedman, my advisor, for showing me what an advisor can do for a PhD student ▸ Herrn G. Dopfer, my high school mathematics teacher, for encouraging me to not take English, focus on math and physics, and go to university, a first for our family