1.
Functional
Programming
Past, Present and Future
Pushkar N Kulkarni
IBM Runtimes
IBM India Software Lab

2.
Functional Programming - today’s special
…
• Timeline – parallel to the imperative timeline
• Languages
• Concepts
Goal: Bootstrapping for functional programming

3.
The beginning of all creation …

4.
Theory of Computation <- Math + Logic
Alonzo Church
Lambda Calculus
Alan Turing
Turing Machine
Stephen Kleene
Recursive Function
Theory

5.
Lambda Calculus
It’s a formal system in mathematical logic for
expressing computation based on function
abstraction and application using variable binding
and substitution.
~ Wikipedia

6.
Lambda Calculus – Fundamental Idea
x //variable
t //lambda term
Λx.t //lambda abstraction
Λx. x2
+1 // x is bound in t by Λx
Λx. x2
+1(2) = 22
+1 = 5 //application
Note: A lambda abstraction has no name

7.
LISP - 1958
LIST Processor
Influenced by Church’s
lambda calculus
notation
Multi-paradigm, pre-fix
notation
John McCarthy

8.
LISP
;;Employee compensation
(defun total (bonus-calc base)
(+ (funcall bonus-calc base) base))
;; Good month
(total #'(lambda (x)(* 0.8 x)) 10000)
;; Bad month
(total #'(lambda (x)(+ (* 0.2 x) 10)) 10000)

9.
LISP – Well known dialects
• Scheme – 1970
• Common Lisp – 1984
• Racket – 1984
• Clojure – 2007
• Lisp Flavoured Erlang (LFE) – 2008 (v1 March
2016)

10.
Academic Research (1960 – 1985)
• ISWIM – If You See What I Mean – 1966
• SASL – St. Andrews Static Language – 1972
• ML – MetaLanguage – 1973 => Ocaml, F#
• Miranda – 1985 => Haskell

11.
Back to some Lambda Calculus
F(x) = x3
+4x //F(x) id a first-order function
//maps values to values
dF(x)/dx = 3x2
+ 4
//d/dx maps functions to functions
d/dx is an example of higher-order functions

12.
Higher-order Functions
A function is a higher-order function if:
• It takes at least one function as an argument OR
• It returns a function
All other functions are first–order functions!

13.
Erlang - 1984
Designed for massive scalable soft real time
systems
Fault-tolerance and concurrency

14.
Erlang
Multi-paradigm, but has a functional core
•First-class functions
Functions can be passed to functions
First-class citizens
=> Higher-order functions
•Immutable values
Immutable “variables” – creating new values instead
Minimizing moving parts has benefits

15.
Erlang – Higher-order functions
%base salaries
S = [10000, 30000, 40000, 15000].
%The Bonus calculator
Bonus = fun(X)-> X + X*0.2 + 1500 end.
%Total salaries
T = lists:map(Bonus, S)
>> [13500, 37500, 49500, 19500]

16.
Erlang – Higher-order functions
%find total salaries exceeding 30000
MoreThan30K = fun(Y) -> Y > 30000 end.
lists:filter(MoreThan30K,T).
>> [37500, 49500]
You just learnt “map” and “filter”. Let them sink in!

17.
Haskell - 1990
• Full blown functional language
• Algebraic data types and type classes
• No statements – the entire program is an
”expression”
• Pattern matching
• Lazy evaluation
• Purely functional – functions have no side effect

18.
Haskell – Algebraic Data Types (ADT)
• Derived from Type Theory
• A composite type - formed by combining other
types
data List a = Nil
| Cons a (List a)
data Tree a = Node a (Tree a) (Tree a)
| Nil

19.
Haskell – Pattern Matching
-- construct a List from an list
makeList (x:xs) = Cons x (makeList xs)
makeList [] = Nil
-- construct an list from a List
makeArr (Cons x (xs)) = x:(makeArr xs)
makeArr Nil = []

20.
Quiz
Why was the language named Haskell?

21.
Haskell Curry (1900 – 1982)

22.
Currying
Introduced by Shönfinkel
Lambda calculus deals with single argument
functions
What about multiple argument functions then?
If F(X, Y, Z) -> N, then
curry(F): X -> (Y -> (Z -> N))

23.
Lambda Calculus - Currying
F(X, Y, Z) = X + Y + Z
F(1, 2, 3) = Fcurried(1)(2)(3)
//apply only one argument at a time
Fcurried (1) = F’curried
F’curried(2) = F”curried
F”curried(3) = 6

24.
OCaml - 1996
• Multi-paradigm
• Derived from ML
• Static type system helps eliminate runtime
problems
• Emphasis on performance – good optimizing
compiler

25.
Currying in OCaml
# let plus x y z = x + y + z;;
# plus 1 2 3;;
- : int = 6
# let x = plus 1;;
val x : int -> int -> int = <fun>

26.
Currying in OCaml
# let y = x 2;;
val y : int -> int = <fun>
# y 3;;
- : int = 6
Cool, but what’s the use of all this?

27.
Currying in OCaml
Function to add 2 to all numbers of a list
let add2 x = x + 2
List.map add2 [1;2;3;4;5];;
Function to add 3 to all numbers of a list
let add3 x = x + 3
List.map add3 [1;2;3;4;5];;

28.
Currying in OCaml
With currying:
let add x y = x + y
List.map (add 2) [1;2;3;4;5]
List.map (add 3) [1;2;3;4;5]
•Better reuse of code
•Improved readability

29.
Quiz
What significant event occurred around 1995
in the Programming Languages space?

30.
Functional Programming on the JVM
(2004 – date)
• Groovy - 2003
• Scala - 2004
• Clojure - 2007
• Java 8 - 2014

31.
Scala
• Seamless integration with
Java
• Combines object oriented
programming and functional
programming
• Type inference
• Higher order functions
• Pattern matchingMartin Odersky

32.
Scala
Simple functional code to find the length of a list:
(no loops in functional programming!)
def listLength (list: List[_]): Int =
list match {
case Nil => 0
case _ => 1 + listLength(list.tail)
}
Any problems here?

33.
Scala
listLength(List.Range(0, 100000))
>> StackOverflow
Are loops better than recursive calls then?
Has functional programming hit a barrier here?

34.
Scala - TCO
No! You have tail recursion and tail-recursion
optimization (TCO)
def length(as: List[_]): Int = {
@tailrec
def length0(as: List[_], count: Int = 0): Int =
as match {
case Nil => count
case head :: tail => length0(tail, count+ 1)
}
length0(as)
}

35.
Scala - TCO
Simplistic essence of tail-call optimization
Execution state
Single, reusable
stack frame

36.
Clojure - 2007
Our fascination with LISP is never ending!
Rich Hickey
• LISP for the JVM
• Java-Clojure
interoperability
• Other implementations –
ClojureScript,
ClojureCLR
• Used in creative
computing!

37.
Clojure
(defn fib[n]
(condp = n
0 1
1 1
(+ (fib (- n 1)) (fib (- n 2)))))
user=> (time (fib 40))
"Elapsed time: 2946.136757 msecs"
165580141
user=> (time (fib 40))
"Elapsed time: 2882.10746 msecs"
165580141

38.
Clojure
Pure functions
•Referential Transparency
•No side effects – stateless programs
•Given an argument, the function must return the
same value! (fib 4) is always 3, for example.
=> Values (fib K) can be reused for all K
Speed up? Caching?

39.
Clojure - Memoization
(def m-fib
(memoize (fn [n]
(condp = n
0 1
1 1
(+ (m-fib (- n 1)) (m-fib (- n 2)))))))

40.
Clojure - Memoization
user=> (time (m-fib 40))
"Elapsed time: 0.823773 msecs"
165580141
user=> (time (m-fib 40))
"Elapsed time: 0.082013 msecs"
165580141

41.
Java 8 - 2014
The exciting times begin!
•Lambdas
•Stream Interface – lazy evaluation!
•Functional Interfaces
•Default methods – for backward compatibility
A mammoth like Java embracing the functional
paradigm is a big cue about the times to come.

42.
Lazy Evaluation
Laziness is not always bad

43.
Lazy Evaluation
• Evaluate an expression only when it’s use is
encountered
• Values are created only when needed
• Reduction in memory footprint
• Fast
• In combination with memoization, results in very
efficient functional code

44.
Problem
Find the number of first deliveries of overs, when a
batsman who scored at least five centuries and hit at
least 100 sixes, was out.

45.
Java 8 – Lazy Evaluation
allDeliveries.stream()
.filter(d -> d.deliveryNumber() == 1)
.filter(d -> d.wicket())
.map(d -> d.getBatsman())
.filter(b -> b.totalCenturies() >= 5)
.filter(b -> b.totalSixes >= 100)
.count() //terminal operation
•Lambdas
•Immutability
•Lazy evaluation, terminal operation
•Map/filter

46.
Java 8 - Parallelism
Parallel execution. Almost zero change to your code.
allDeliveries.parallelStream()
.filter(d -> d.deliveryNumber() == 1)
.filter(d -> d.wicket())
.map(d -> d.getBatsman())
.filter(b -> b.totalCenturies() >= 5)
.filter(b -> b.totalSixes >= 100)
.count() //terminal operation

47.
Java 8
• No intentions of becoming a full blown functional
language
• Lambdas and lazy evaluation provide a big boost
• Readability improved – anonymous classes not
needed
• Reusability improved – lambdas, functional
interfaces
• Java 9 – better Stream interface expected

48.
Idris – A peek into the future
• Data types are first class objects!
• You can generate data types, store them, pass
them around
• Dependent types were developed by Haskell
Curry to deepen the connection between
programming and logic (Curry-Howard
correspondence)
• Dependent types – types that depend on values!
• Influenced by Agda

49.
Idris – dependent types
ListType : (singleton : Bool) -> Type
ListType False = List Nat
ListType True = Nat
sumList : (singleton : Bool)->ListType singleton->Nat
sumList False (x :: xs) = x + sumList False xs
sumList False [] = 0
sumList True x = x

50.
Why Functional Programming
• Higher levels of behavioural abstraction – tell what
is to be done, not how to do it
• Agile Methodologies - Code reuse, readability
• Correctness
• Exploiting massively parallel hardware

51.
Challenges
• Paradigm shift in thinking needed
• Newer design patterns – no imperative design
patterns
• Performance evaluation difficult – recursive data
structures, recursive functions
• Runtime performance – garbage collection critical

52.
Recap
• Lambda Calculus
• Lambdas
• First-class functions, higher order functions
• Algebraic data types
• Pattern matching
• Currying

53.
Recap
• Tail-call recursion and TCO
• Pure functions, referential transparency
• Memoization
• Lazy evaluation
• Parallelism
• Dependent data types

54.
A programming language that does not change the way you
think is not worth knowing ~ Alan Perlis
Functional programming changes the way you think.
It’s worth knowing!

55.
(Thank you!)
(twitter @pushkar_nk)
(github pushkarnk)