A presentation about what and why of functional programming

1. Functional Programming:
Why and What
Naveen Muguda

2. Software Development: Empathy
Business
Human
Infrastructure
Time

3. Breakfast?

4. Awareness test

5. Phone number test

6. Mental calculation test
• 39,865 / 17

7. pronunciation
• Hippopotomonstrosesquippedaliophobia

8. Humans
• can’t observe much
• can’t store much in short term memory
• can’t solve moderately complex problems
• are not detail oriented
=> we cant handle “more”
we need simplicity

9. Word origin
• simplex (adj.)
• "characterized by a single part," 1590s, from Latin simplex "single,
simple, plain, unmixed, uncompounded," literally "onefold"

10. Two poses

11. Word origin
• From late 14c. as "of or pertaining to one's family."

12. Simplicity vs Familiarity
Familiarity
Simplicity
Eagle pose
Standing Forward Bend pose
Standing Forward Bend pose(me)

13. semiformally
• simplicity = g(object)
• familiarity = h(object, person)

14. Simplicity vs Familiarity
Simplicity
Procedural
Object oriented
Functional
Familiarity

15. statement vs expression
• stack.push(..)
• stack.pop()

16. statements vs expressions
Egg egg ;
BoiledEgg boiledEgg = null;
PeeledEgg peeledEgg = null;
boilWater();
addEgg();
peel();

17. • implies a specific order of evaluation,
• which means that a statement cannot be understood without looking
at prior statements.

18. Expression oriented Programming
• Egg egg = ;
• BoiledEgg boiledEgg = boil(egg)
• BoiledAndPeeledEgg boiledAndPeeledEgg = peel(boiledEgg)

19. Expression oriented Programming
• Expressions promote local reasoning

20. Functional Programming
• Expression oriented programming

21. Which version is the best?
• for(int i = 0; i < a.length, i++)
vs
• for(int car = 0; car < a.length, car++)
vs
• for(int index = 0; index < a.length; index++)

22. Mirroring

23. Low Representational Gap
• The ”concept” being modelled should be mirrored by its software
representation.
• Keep the distance between concept and its representation low

24. functions
• Methods that always return the same result for the same input(s)

25. functions, functions every where
• sort
• search
• tree/graph traversal
• statistics

26. Real world constructs modelled as functions
• taxes
• scores
• search results
• data transformations

27. Expressions, Not functions
• stack.pop()
• Random.nextInt()
• time()

28. statements
expressions
functions

29. Functional Programming
• Expression oriented programming
• Functions as first class construct

30. Identify problems with this code
<A extends Comparable<A>> A max(A first, A second) {
return first.compareTo(second) > 0 ? first : second;
}

31. First pass
<A extends Comparable<A>> A max(A first, A second) {
synchronized(first) {
synchronized(second) {
return first.compareTo(second) > 0 ? first : second;
}
}
}

32. immutability
<A extends Comparable<A>> A max(A first, A second) {
return first.compareTo(second) > 0 ? first : second;
}

33. functions
• always return the same result for the same input
• doesn’t read mutable state
• doesn’t write to mutable state

34. Error prone

36. Functional Programming
• Expression oriented programming
• Functions as first class construct
• Programming with values

37. Another phone number
• 9731-691-691

39. • “I ran 5.23 kms today”

40. Composition
• backbone of (good) thinking/communication

42. • Function<Integer, Integer> f = x -> x + 1;
Function<Integer, Integer> g = x -> x * 2;
Function<Integer, Integer> h = g.compose(f);

43. composition

44. who/what are the underlined
• The weather was great in Baratang
• Jigme singye wangchuck was loved by his subjects

45. composability
• Locks don’t compose
• Functions compose

46. Functional Programming
• Expression oriented programming
• Functions as first class construct
• Programming with values
• Function composition as a first class mechanism

47. Communication|thinking test
• How do you get to the gym?
• How do you make a lemonade?
• Explain quicksort

48. Essence over ceremony

49. Guess what this function does
• public static int m(int i) {
i = i - ((i >>> 1) & 0x55555555);
i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
i = (i + (i >>> 4)) & 0x0f0f0f0f;
i = i + (i >>> 8);
i = i + (i >>> 16);
return i & 0x3f;
}

50. Inversions

51. int sum = 0;
for(Integer element:list)
sum += element;
int max = MIN_VALUE;
for(Integer element:list)
max = (max > element) ? max: element

52. Functions as values | Higher order Functions
• <U> U fold (U zero, BiFunction <U, T, U> combine);
• List<Integer> list = List.of(4, 2, 1, 6);
list.fold(0, (x, y) -> x + y); // sum
list.fold(MIN_VALUE, (x, y) -> (x > y)? x : y);//max

53. fold
• Search
• Sort
• Filter
• Reverse
• Count
• ……

54. for(String string: strings) {
if (string == null)
continue;
for(String word: split(string,"s" )){
if(word.length() > big.length())
big = word;
}
}

55. return strings
.filter(Objects::nonNull)
.flatMap(s -> split(s, "s"))
.fold("", (x, y) -> (x.length() > y.length()) ? x : y);

56. Functional Programming
• Expression oriented programming
• Functions as first class construct
• Programming with values
• Function composition
• Higher Order functions

57. Inversions
Play
Hello, World

58. IPL team isSpinner
Kohli RCB no
Chahal RCB yes
Kuldeep KKR yes
Pujara null no
Team Won IPL in
RCB null
KKR 2012, 2014

59. Different containers, different behaviors
• Optional.of(“pujara”). map(getIplTeam).map(firstWonIn) =>
Optional.empty
• Optional.of(“kohli”). map(getIplTeam).map(firstWonIn) =>
Optional.empty
• Set.of(“kohli”, “chahal”, “kulcha”).map(getIplTeam) => Set.of(“RCB”,
“KKR”)
• Set.of(“kohli”, “chahal”, “kulcha”).map(getIplTeam).flatMap(wonIn) =>
Set.of(2012, 2014)
• List.of(“kohli”, “chahal”, “kulcha”).map(getIplTeam) => List.of(“RCB”,
“RCB”, “KKR”)

60. Optional
List
Set
map
filter
flatmap
fold
7constructs vs 12

61. Containers
Optional Null Safety
List Ordered collection
Set Unique collection
Promise Async Programming
Task Computation

62. Functional Programming
• Expression oriented programming
• Functions as first class construct
• Programming with values
• Function composition
• Higher Order functions
• Behavior rich containers

63. Structure preserving operations
Set.of(“kohli”, “chahal”, “kulcha”)
.filter(isSpinner)
.map(getIplTeam)
.flatMap(wonIn) => Set.of(2012, 2014)

64. Functional Programming
• Expression oriented programming
• Functions as first class construct
• Programming with values
• Function composition
• Higher Order functions
• Behavior rich containers
• Structure preserving operations

65. Parallel fold

66. Procedural OO Functional
Reuse Low Low High
Time to Closure High Medium Low
Testability Low Medium High
Development time High Medium Low
# of Artifacts Low Medium HIgh