1. CS5205: Foundation in Programming Languages Lecture 1 : Overview
“Language Foundation,
Extensions and Reasoning
Lecturer : Chin Wei Ngan
Office : S
CS5205
Introduction

2. Course Objectives - graduate-level course with foundation focus
- languages as tool for programming
- foundations for reasoning about programs
- explore various language innovations
CS5205
Introduction

3. Course Outline Lecture Topics (13 weeks) Lambda Calculus
Advanced Language (Haskell)
Type System for Lightweight Analysis
Semantics
Formal Reasoning – Separation Logic + Provers
Language Innovations (paper readings)
CS5205
Introduction

4. Administrative Matters
- mainly IVLE
- Reading Materials (mostly online):
Robert Harper : Foundations of Practical Programming Languages.
Free PL books :
- Lectures + Assignments + Presentation + Exam
- Assignment/Quiz (30%)
- Paper Reading + Critique (25%)
- Exam (45%)
CS5205
Introduction

5. Paper Critique Focus on Language Innovations Select Topic (Week 3)
2-Page Summary (Week 5)
Prepare Presentation (Week 7)
Oral Presentation (Last 4 weeks)
Paper Critique (Week 13)
Possible Topics
Concurrent and MultiCore Programming
Software Transaction Memory
GUI Programming with Array
Testing with QuickCheck
IDE for Haskell
SELinks (OCaml)
CS5205
Introduction

6. Advanced Language - Haskell
Strongly-typed with polymorphism
Higher-order functions
Pure Lazy Language.
Algebraic data types + records
Exceptions
Type classes, Monads, Arrows, etc
Advantages : concise, abstract, reuse
Why use Haskell ?
cool & greater
productivity
CS5205
Introduction

7. Example - Haskell Program
Apply a function to every element of a list.
data List a = Nil | Cons a (List a)
map f Nil = Nil
map f (Cons x xs) = Cons (f x) (map f xs)
map inc (Cons 1 (Cons 2 (Cons 3 Nil)))
==> (Cons 2 (Cons 3 (Cons 4 Nil)))
a type variable
type is : (a  b)  (List a)  (List b)
CS5205
Introduction

8. Some Applications Hoogle – search in code library
Darcs – distributed version control
Programming user interface with arrows..
How to program multicore?
map/reduce and Cloud computing
Some issues to be studied in Paper Reading.
CS5205
Introduction

9. Type System – Lightweight Analysis
Abstract description of code + genericity
Compile-time analysis that is tractable
Guarantees absence of some bad behaviors
Issues – expressivity, soundness,
completeness, inference?
How to use, design and prove type system.
Why?
detect bugs
CS5205
Introduction

10. Specification with Separation Logic
Is sorting algorithm correct?
Any memory leaks?
Any null pointer dereference?
Any array bound violation?
What is the your specification/contract?
How to verify program correctness?
Issues – mutation and aliasing
Why?
sw reliability
CS5205
Introduction

11. Lambda Calculus Untyped Lambda Calculus Evaluation Strategy
Techniques - encoding, extensions, recursion
Operational Semantics
Explicit Typing
Introduction to Lambda Calculus:
Lambda Calculator :
CS5205
Introduction

12. Untyped Lambda Calculus
Extremely simple programming language which captures core aspects of computation and yet allows programs to be treated as mathematical objects.
Focused on functions and applications.
Invented by Alonzo (1936,1941), used in programming (Lisp) by John McCarthy (1959).
CS5205
Introduction

13. Functions without Names
Usually functions are given a name (e.g. in language C):
int plusOne(int x) { return x+1; }
…plusOne(5)…
However, function names can also be dropped:
(int (int x) { return x+1;} ) (5)
Notation used in untyped lambda calculus:
(l x . x+1) (5)
CS5205
Introduction

14. Syntax x variable l x . t abstraction t t application
In purest form (no constraints, no built-in operations), the lambda calculus has the following syntax.
t ::= terms
x variable
l x . t abstraction
t t application
This is simplest universal programming language!
CS5205
Introduction

15. Conventions Parentheses are used to avoid ambiguities.
e.g. x y z can be either (x y) z or x (y z)
Two conventions for avoiding too many parentheses:
Applications associates to the left
e.g. x y z stands for (x y) z
Bodies of lambdas extend as far as possible.
e.g. l x. l y. x y x stands for l x. (l y. ((x y) x)).
Nested lambdas may be collapsed together.
e.g. l x. l y. x y x can be written as l x y. x y x
CS5205
Introduction

16. Scope
An occurrence of variable x is said to be bound when it occurs in the body t of an abstraction l x . t
An occurrence of x is free if it appears in a position where it is not bound by an enclosing abstraction of x.
Examples: x y
y. x y
l x. x (identity function)
(l x. x x) (l x. x x) (non-stop loop)
(l x. x) y
(l x. x) x
CS5205
Introduction

17. Alpha Renaming
Lambda expressions are equivalent up to bound variable renaming.
e.g. l x. x =a l y. y
l y. x y =a l z. x z
But NOT:
l y. x y =a l y. z y
Alpha renaming rule:
l x . E =a l z . [x a z] E (z is not free in E)
CS5205
Introduction

18. Beta Reduction
An application whose LHS is an abstraction, evaluates to the body of the abstraction with parameter substitution.
e.g. (l x. x y) z !b z y
(l x. y) z !b y
(l x. x x) (l x. x x) !b (l x. x x) (l x. x x)
Beta reduction rule (operational semantics):
( l x . t1 ) t2 !b [x a t2] t1
Expression of form ( l x . t1 ) t2 is called a redex (reducible expression).
CS5205
Introduction

19. Evaluation Strategies
A term may have many redexes. Evaluation strategies can be used to limit the number of ways in which a term can be reduced.
An evaluation strategy is deterministic, if it allows reduction with at most one redex, for any term.
Examples:
- full beta reduction
- normal order
- call by name
- call by value, etc
CS5205
Introduction

20. Full Beta Reduction
Any redex can be chosen, and evaluation proceeds until no more redexes found.
Example: (lx.x) ((lx.x) (lz. (lx.x) z))
denoted by id (id (lz. id z))
Three possible redexes to choose:
id (id (lz. id z))
Reduction:
! id (id (lz.z))
! id (lz.z)
! lz.z !
CS5205
Introduction

21. Normal Order Reduction
Deterministic strategy which chooses the leftmost, outermost redex, until no more redexes.
Example Reduction:
id (id (lz. id z))
! id (lz. id z))
! lz.id z
! lz.z !
CS5205
Introduction

22. Call by Name Reduction
Chooses the leftmost, outermost redex, but never reduces inside abstractions.
Example:
id (id (lz. id z))
! id (lz. id z))
! lz.id z !
CS5205
Introduction

23. Call by Value Reduction
Chooses the leftmost, innermost redex whose RHS is a value; and never reduces inside abstractions.
Example:
id (id (lz. id z))
! id (lz. id z)
! lz.id z !
CS5205
Introduction

24. Strict vs Non-Strict Languages
Strict languages always evaluate all arguments to function before entering call. They employ call-by-value evaluation (e.g. C, Java, ML).
Non-strict languages will enter function call and only evaluate the arguments as they are required. Call-by-name (e.g. Algol-60) and call-by-need (e.g. Haskell) are possible evaluation strategies, with the latter avoiding the re-evaluation of arguments.
In the case of call-by-name, the evaluation of argument occurs with each parameter access.
CS5205
Introduction

25. Programming Techniques in l-Calculus
Multiple arguments.
Church Booleans.
Pairs.
Church Numerals.
Recursion.
Extended Calculus
CS5205
Introduction

26. Multiple Arguments
Pass multiple arguments one by one using lambda abstraction as intermediate results. The process is also known as currying.
Example:
f = l(x,y).s f = l x. (l y. s)
Application:
f(v,w) (f v) w
requires pairs as
primitve types
requires higher
order feature
CS5205
Introduction

27. Church Booleans
Church’s encodings for true/false type with a conditional:
true = l t. l f. t
false = l t. l f. f
if = l l. l m. l n. l m n
Example:
if true v w
= (l l. l m. l n. l m n) true v w
! true v w
= (l t. l f. t) v w
! v
Boolean and operation can be defined as:
and = l a. l b. if a b false
= l a. l b. (l l. l m. l n. l m n) a b false
= l a. l b. a b false
CS5205
Introduction

28. Pairs
Define the functions pair to construct a pair of values, fst to get the first component and snd to get the second component of a given pair as follows:
pair = l f. l s. l b. b f s
fst = l p. p true
snd = l p. p false
Example:
snd (pair c d)
= (l p. p false) ((l f. l s. l b. b f s) c d)
! (l p. p false) (l b. b c d)
! (l b. b c d) false
! false c d
! d
CS5205
Introduction

29. Church Numerals Numbers can be encoded by: c0 = l s. l z. z
c1 = l s. l z. s z
c2 = l s. l z. s (s z)
c3 = l s. l z. s (s (s z)) :
CS5205
Introduction

30. Church Numerals Successor function can be defined as: Example:
succ = l n. l s. l z. s (n s z)
Example:
succ c1
= ( n.  s.  z. s (n s z)) ( s.  z. s z)
 l s. l z. s ((l s. l z. s z) s z)
! l s. l z. s (s z)
succ c2
= l n. l s. l z. s (n s z) (l s. l z. s (s z))
! l s. l z. s ((l s. l z. s (s z)) s z)
! l s. l z. s (s (s z))
CS5205
Introduction

31. Church Numerals Other Arithmetic Operations:
plus = l m. l n. l s. l z. m s (n s z)
times = l m. l n. m (plus n) c0
iszero = l m. m (l x. false) true
Exercise : Try out the following.
plus c1 x
times c0 x
times x c1
iszero c0
iszero c2
CS5205
Introduction

32. Recursion
Some terms go into a loop and do not have normal form. Example:
(l x. x x) (l x. x x)
! (l x. x x) (l x. x x)
! …
However, others have an interesting property
fix = λf. (λx. f (x x)) (λx. f (x x))
fix = l f. (l x. f (l y. x x y)) (l x. f (l y. x x y))
that returns a fix-point for a given functional.
Given x = h x
= fix h
That is: fix h ! h (fix h) ! h (h (fix h)) ! …
x is fix-point of h
CS5205
Introduction

33. Example - Factorial We can define factorial as:
fact = l n. if (n<=1) then 1 else times n (fact (pred n))
= (l h. l n. if (n<=1) then 1 else times n (h (pred n))) fact
= fix (l h. l n. if (n<=1) then 1 else times n (h (pred n)))
CS5205
Introduction

34. Example - Factorial Recall:
fact = fix (l h. l n. if (n<=1) then 1 else times n (h (pred n)))
Let g = (l h. l n. if (n<=1) then 1 else times n (h (pred n)))
Example reduction:
fact 3 = fix g 3
= g (fix g) 3
= times 3 ((fix g) (pred 3))
= times 3 (g (fix g) 2)
= times 3 (times 2 ((fix g) (pred 2)))
= times 3 (times 2 (g (fix g) 1))
= times 3 (times 2 1)
= 6
CS5205
Introduction

35. Enriching the Calculus
We can add constants and built-in primitives to enrich l-calculus. For example, we can add boolean and arithmetic constants and primitives (e.g. true, false, if, zero, succ, iszero, pred) into an enriched language we call lNB:
Example:
l x. succ (succ x) 2 lNB
l x. true 2 lNB
CS5205
Introduction

36. Formal Treatment of Lambda Calculus
Let V be a countable set of variable names. The set of terms is the smallest set T such that:
x 2 T for every x 2 V
if t1 2 T and x 2 V, then l x. t1 2 T
if t1 2 T and t2 2 T, then t1 t2 2 T
Recall syntax of lambda calculus:
t ::= terms
x variable
l x.t abstraction
t t application
CS5205
Introduction

37. Free Variables The set of free variables of a term t is defined as:
FV(x) = {x}
FV(l x.t) = FV(t) \ {x}
FV(t1 t2) = FV(t1) [ FV(t2)
CS5205
Introduction

38. Substitution
Works when free variables are replaced by term that does not clash:
[x a l z. z w] (l y.x) = (l y. l z. z w)
However, problem if there is name capture/clash:
[x a l z. z w] (l x.x) ¹ (l x. l z. z w)
[x a l z. z w] (l w.x) ¹ (l w. l z. z w)
CS5205
Introduction

39. Formal Defn of Substitution
[x a s] x = s if y=x
[x a s] y = y if y¹x
[x a s] (t1 t2) = ([x a s] t1) ([x a s] t2)
[x a s] (l y.t) = l y.t if y=x
[x a s] (l y.t) = l y. [x a s] t if y¹ x Æ y FV(s)
[x a s] (l y.t) = [x a s] (l z. [y a z] t)
if y¹ x Æ y 2 FV(s) Æ fresh z
CS5205
Introduction

40. Syntax of Lambda Calculus
Term:
t ::= terms
x variable
l x.t abstraction
t t application
Value:
v ::= value
l x.t abstraction value
CS5205
Introduction

41. Call-by-Value Semantics
premise
t1 ! t’1
t1 t2 ! t’1 t2
(E-App1)
conclusion
t2 ! t’2
v1 t2 ! v1 t’2
(E-App2)
(l x.t) v ! [x a v] t (E-AppAbs)
CS5205
Introduction

42. Call-by-Name Semantics
t1 ! t’1
t1 t2 ! t’1 t2
(E-App1)
(l x.t) t2 ! [x a t2] t (E-AppAbs)
CS5205
Introduction

43. Getting Stuck
Evaluation can get stuck. (Note that only values are l-abstraction)
e.g. (x y)
In extended lambda calculus, evaluation can also get stuck due to the absence of certain primitive rules.
(l x. succ x) true ! succ true !
CS5205
Introduction

44. Boolean-Enriched Lambda Calculus
Term:
t ::= terms
x variable
l x.t abstraction
t t application
true constant true
false constant false
if t then t else t conditional
Value:
v ::= value
l x.t abstraction value
true true value
false false value
CS5205
Introduction

45. Key Ideas Exact typing impossible.
if <long and tricky expr> then true else (l x.x)
Need to introduce function type, but need argument and result types.
if true then (l x.true) else (l x.x)
CS5205
Introduction

46. Simple Types
The set of simple types over the type Bool is generated by the following grammar:
T ::= types
Bool type of booleans
T ! T type of functions
! is right-associative:
T1 ! T2 ! T3 denotes T1 ! (T2 ! T3)
CS5205
Introduction

47. Implicit or Explicit Typing
Languages in which the programmer declares all types are called explicitly typed. Languages where a typechecker infers (almost) all types is called implicitly typed.
Explicitly-typed languages places onus on programmer but are usually better documented. Also, compile-time analysis is simplified.
CS5205
Introduction

48. Explicitly Typed Lambda Calculus
t ::= terms …
l x : T.t abstraction
v ::= value
l x : T.t abstraction value
T ::= types
Bool type of booleans
T ! T type of functions
CS5205
Introduction

49. Examples l x:Bool . x (l x:Bool . x) true true
if false then (l x:Bool . True) else (l x:Bool . x)
CS5205
Introduction