Introduction to functional programming, outlining the big ideas, and emphasising how it gives us things we all want in our software.

1. (= (good (functional programming))
(good programming))
@KenScambler

2. What is functional
programming?

3. λx → x+1

4. What is a functional
programming
language?

5. (lambda (x)
(+ x 1))

6. do |x|
x + 1
end

7. new Function<Integer,Integer>() {
@Override
public Integer apply(Integer x) {
return x + 1;
}
};

8. You can do FP in any
language!

9. John McCarthy
1927 - 2011
Lisp, 1958
(DEFUN FAC (N)
(IF (= N 0)
1
(* N (FAC (- N 1)))))
• Value-oriented
• Garbage collection
• Lambda functions

10. Guy Steele
1954-
Scheme, 1970
(define (fac n)
(if (= n 0)
1
(* n (fac (- n 1))))))
• Lexical scope
• Tail call optimization
• Continuations
Gerald Sussman
1947-

11. Robin Milner, et al
1934 - 2010
ML, 1973
fun fac (0 : int) : int = 1 |
fac (n : int) : int =
n * fac (n - 1)
• Statically typed
• HM type inference
• ADTs, Pattern matching

12. Haskell Committee
Haskell, 1990
fac :: (Integral a) => a -> a
fac n = if n < 2
then 1
else n * fac (n-1)
• Purity
• Lazy evaluation
• Monads

13. Why do I care?

14. The things that make FP good
are the same things that make
good software good

15. Simple Modular Local reasoning
Extensible Testable

16. Think better thoughts
Your design ideas are hi-res

17. Think better thoughts
Your ideas expressed in a
language are low-res

18. If you only think “in a
language”, then your ideas
are already low res

19. Functions & composition
Immutability Purity & types
The big ideas
λ
Laziness

20. Functionsλ

23. Composition

24. A  B

25. A  B
B  C

26. A  B
B  C
C  D

27. A  C
C  D

28. A  D

29. Equational reasoning
5 + (3 * 4)

30. Equational reasoning
5 + 12

31. Equational reasoning
17

32. Equational reasoning
process(
expensiveThing(),
expensiveThing(),
expensiveThing())

33. Equational reasoning
val x = expensiveThing()
process(x,x,x)

34. Referential Transparency
“An expression is said to be
referentially transparent if it can be
replaced with its corresponding value
without changing the program's
behavior.”
- Wikipedia

35. It’s just good sense!
Being able to reason about software is
just good programming!

36. Immutability

37. case class Point(
x: Int,
y: Int)
• Immutable
• Instances are values
• Simple!

38. case class Point(
var x: Int,
var y: Int)
• Mutable
• Instances are identities that track a
series of Point states over time, where
you only get to see the latest one
• Not simple

39. "Classes should be immutable unless there's a
very good reason to make them mutable....If a
class cannot be made immutable, limit its
mutability as much as possible."
- Joshua Bloch
Effective Java

40. “But the real world is mutable!”
- Programmers

41. Entities vs value types
“Some objects are not defined primarily by
their attributes. They represent a thread of
identity that runs through time and often
across distinct representations.”
- Eric Evans
Domain Driven Design

42. Entities vs value types
samuel_l_jackson.hairstyle
samuel_l_jackson.occupation

43. Entities vs value types
samuel_l_jackson.hairstyle
samuel_l_jackson.occupation
=> “bald”
=> “actor”

44. Entities vs value types
samuel_l_jackson.hairstyle
samuel_l_jackson.occupation
=> “bald”
=> “actor”
in 2017…

45. Entities vs value types
samuel_l_jackson.hairstyle
samuel_l_jackson.occupation
=> “afro”
=> “student”
1960s:

46. “Samuel L
Jackson”
H: “bald”
O: “actor”
H: “afro”
O: “student”
Identity
1960 1970 1980 1990 2000 2010

47. Persistent collections

48. Immutability is just good
programming!

49. Purity & types

50. Null is a 3rd world problem
Cake cake = null;
cake.cut();

51. Cake cake = null;
cake.cut();

52. Sum types
Maybe<A>
Just(A a)
NothingOR

53. Sum types (Haskell)
data Maybe a =
Just a | Nothing

54. Sum types (Scala)
sealed trait Maybe[+A]
case class Just[A](a: A)
extends Maybe[A]
case object None
extends Maybe[Nothing]

55. Sum types (Java)
public class Maybe<A> {
private Maybe() {}
public abstract <B> B fold(Function<A,B> ifPresent, Supplier<B> ifAbsent);
public static class Just<A> extends Maybe<A> {
private final A a;
public Just(A a) {
this.a = a;
}
public <B> B fold(Function<A,B> ifPresent, Supplier<B> ifAbsent) {
ifPresent.apply(a);
}
}
public static class Nothing<A> extends Maybe<A> {
public <B> B fold(Function<A,B> ifPresent, Supplier<B> ifAbsent) {
ifAbsent.get();
}
}
}

56. Optional<Cake> cake =
Optional.empty());
cake.ifPresent(Cake::cut);

57. public Session login(
String userName,
String pwd) throws
AuthenticationException

58. public Session login(
String userName,
String pwd) throws
AuthenticationException

59. public Either<AuthError, Session>
login(
String userName,
String pwd)

60. Make illegal states
unrepresentable

61. Eradicable 3rd world diseases
Nulls
Exceptions
Fall-through cases

62. What can we know from a type?
process :: a
-> (a -> Bool)
-> WriterT Log (Reader Config) a
• Takes a predicate that operates only on the given item
• We do nothing with the “a” value other than filter it and return it
• No side effects are performed
• We might write an accumulating “Log” value
• The code declares what will take place, but does not execute it when called
• A “Config” will be required before the code can be eventually executed

63. Laziness

64. Separation of concerns!
Planning
Composition
Declaration
vs
Execution
Evaluation
Interpretation

65. (define (sum-primes a b)
(define (iter count accum)
(cond ((> count b) accum)
((prime? count)
(iter (+ count 1)
(+ count accum)))
(else (iter (+ count 1) accum))))
(iter a 0))
Sum primes, iteratively
from SICP

66. (define (sum-primes a b)
(define (iter count accum)
(cond ((> count b) accum)
((prime? count)
(iter (+ count 1)
(+ count accum)))
(else (iter (+ count 1) accum))))
(iter a 0))
Sum primes, iteratively
Test each number to see if
it is a prime

67. (define (sum-primes a b)
(define (iter count accum)
(cond ((> count b) accum)
((prime? count)
(iter (+ count 1)
(+ count accum)))
(else (iter (+ count 1) accum))))
(iter a 0))
Sum primes, iteratively
Accumulate total sum

68. (define (sum-primes a b)
(define (iter count accum)
(cond ((> count b) accum)
((prime? count)
(iter (+ count 1)
(+ count accum)))
(else (iter (+ count 1) accum))))
(iter a 0))
Sum primes, iteratively
Efficiency 👍
• The number range is only
traversed once
Modularity 👎
• Prime test and summation all
smooshed together in loop

69. (define (sum-primes a b)
(accumulate +
0
(filter prime?
(enumerate-interval a b))))
Sum primes, with list ops
Efficiency 👎
• The number list is traversed
several times
Modularity 👍
• Prime test impl & summation
impl just plug in together

70. (define (sum-primes a b)
(accumulate +
0
(stream-filter prime?
(enumerate-stream-interval
a b))))
Sum primes, with lazy stream ops
Modularity 👍
• Prime test impl & summation
impl just plug in together
Efficiency 👍
• The number range is only
traversed once

71. “Lazy evaluation is perhaps the most
powerful tool
for modularization in the functional
programmer’s repertoire..”
- John Hughes
Why Functional
Programming Matters

72. Living the dream
Imagine a world where…
You don’t have to chase down
runtime stack traces in the logs,
because they can’t happen

73. Living the dream
Imagine a world where…
Testing software is really easy

74. Living the dream
Imagine a world where…
You can write software by clicking
typed functions together like Lego

75. Living the dream
Imagine a world where…
You can reason about one thing at
a time without cramming the
whole world in

76. User groups
Melbourne Functional User Group
https://www.meetup.com/en-AU/Melbourne-Functional-User-
Group-MFUG/
Melbourne Scala User Group
https://www.meetup.com/en-AU/Melbourne-Scala-User-Group/
Melbourne Haskell Users Group
https://www.meetup.com/en-AU/Melbourne-Haskell-Users-Group/
clj-melb
https://www.meetup.com/en-AU/clj-melb/