Most documentation on the internet doesn't communicate the essence of functional programming. This presentation is an attempt to convey the essence.

1. FP, simplified for java
programmers
Naveen Muguda

4. Programming Paradigms
• Wikipedia lists about 30+ paradigms

5. Programming Paradigms(..continued)
• Two paradigms are largely prevalent
• Procedural (vast majority)
• Object Oriented (occasional)
• Functional (old kid making a come back)

6. Procedural
OO
Functional
Structures
procedures
functions
types
objects

7. Paradigm:Data
Shared/Hidden Mutable/Immutable
Procedural Shared Mutable
Object Oriented Hidden Mutable
Functional Shared Immutable

8. Paradigm: snippets
• Find elements of a list
Procedural find(list)
Object Oriented list.find(y)
Functional list.filter(x -> (x == y));

10. Snippets(..continued)
even list.filter(x -> (x % 2) == 0)
odd list.filter(x -> (x % 2) != 0)
prime list.filter(Primes::isPrime)
Multiple of list.filter(x -> isMultiple(x, 4))

12. Building block: Function
• Functions return value vs stack.push()
• Functions are methods which have no side effects vs list.add()
• Functions always return the same value for the same input vs
stack.pop()
• Functions don’t access data in other contexts* vs list.size()

13. Side effects
• Have to be managed
• push():pop()
• lock():unlock()
• allocate():free()

14. Control abstractions
Have side effects Don’t have side effects
statement Expression
procedure function

15. Higher order functions
• x, f, f(x)
• filter(Predicate predicate)
• …
• if(predicate.test(x) == true)
• result.add(x)

16. Granularity
• filter(Predicate<X> predicate)
• map(Function<X, Y> mapper)
• fold(T zero, Bifunction<T, T>combiner)

17. parameterization
• fold(1, (x, y) -> (x * y))
• fold(0, (x, y) -> (x + y))
• fold(Integer.Minimum, (x, y)-> max(x, y))

18. composability
• f(g(h(x)))
• map(h).map(g).map(f)
• filter(m).find(f).map(g).orElse(y)

19. ..benefits
• Functions are easier to reason
• Functions are modular
• Functions are safer

21. Monad
• wrap data
• accept a chain of functions
• create a chain of monads
• Provide utility around wrapped data

22. Monad(..continued)
• wrap
• map
• flatMap

23. Monads
Monad Value
Identity storage
Stream parallelising pipeline
Promise deferring pipeline execution
Optional creates non-null and null pipelines,
provides null safety
Either creates two pipelines, usually happy
path and other path, encapsulates
concerns
Try Creates two pipelines, happy path and
exception path, encapsulates concerns

25. Modularization in non-FP world
Modularization in FP world

26. Where is FP being used?
• map/reduce
• Java Streams
• Reactive
• Spark
• Kafka

27. recommendations
• statements -> expressions
• procedures-> functions
• null check -> Optional
• if-else-> Either
• if-else-> ternary
• for-> stream
• try-catch-> Try

28. catch
• Sorting, inserting are all painful
• great for queries, figuring out for mutations