Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.

Functional programming with Java 8

5,305 views

Published on

In this Meetup Victor Perepelitsky - R&D Technical Leader at LivePerson leading the 'Real Time Event Processing Platform' team , will talk about Java 8', 'Stream API', 'Lambda', and 'Method reference'.

Victor will clarify what functional programming is and how can you use java 8 in order to create better software.

Victor will also cover some pain points that Java 8 did not solve regarding functionality and see how you can work around it.

Published in: Technology

Functional programming with Java 8

  1. 1. Functional Programming with Java 8 Victor Perepelitsky slides: http://www.slideshare.net/victorperepelitsky/fun-with-java-8 twitter: @victor_perepel email: victor.prp@gmail.com git-hub: https://github.com/victor-prp/java8samples/
  2. 2. This presentation focuses on What functional programming is ? Why functional ? How to use java 8 for functional ?
  3. 3. Functional Programming In computer science, functional programming is a programming paradigm, a style of building the structure and elements of computer programs, that treats computation as the evaluation of mathematical functions and avoids changing state and mutable data. It is a declarative programming paradigm, which means programming is done with expressions.
  4. 4. Functional Programming Functions Avoids mutable data Declarative Expressions
  5. 5. Why Functional? Less code Expressive code Correct code It is FUN Performance*
  6. 6. Functional building blocks in java 8 Function Function reference Lambda Predefined Java8 functions - java.util.function Stream API p2
  7. 7. Basic Function Definition p1*
  8. 8. Basic Function Usage p1
  9. 9. Fun Reference - static fun p1
  10. 10. Fun Reference - static fun p1
  11. 11. Higher Order Function - Definition p1*
  12. 12. p1
  13. 13. pureFun doItTwice pureFun pureFun p1
  14. 14. java.util.function Function<T, R> accepts T, returns R BiFunction<T, U, R> accepts T and U, returns R Consumer<T> accepts T, returns void Supplier<T> accepts nothing, returns T Predicate<T> accepts T, returns boolean p1
  15. 15. Lambda - simple example p1
  16. 16. Lambda - formal definition Anonymous function (also function literal or lambda abstraction) is a function definition that is not bound to an identifier. Lambdas are often: 1. passed as arguments to higher-order functions, or 2. used to construct the result of a higher- order function that needs to return a function. p1
  17. 17. Lambda Anonymous function Passed as argument (common usage) In java 8 it is only syntactic sugar for function reference p1
  18. 18. Lambda p1
  19. 19. Monad In functional programming, a monad is a structure that represents computations defined as sequences of steps. A type with a monad structure defines what it means to chain operations, or nest functions of that type together http://en.wikipedia.org/wiki/Monad_%28functional_prog p3
  20. 20. In Java 8 Stream is a Monad Chaining stream operations forming a stream pipeline p3 menu filter sorted map collect how to filter how to sort how to map how to collect List<String >
  21. 21. Java 8 Stream ● A stream represents a sequence of elements and supports different kind of operations to perform computations upon those elements ● Stream operations are either intermediate or terminal. ● Intermediate operations return a stream so we can chain multiple intermediate operations. ● Terminal operations are either void or return a non-stream result. p3
  22. 22. Let’s see it again p3 menu stream filter sorted map collect how to filter how to sort how to map how to collect List<String > intermediate final
  23. 23. Stream vs Collection ● Like a collection, a stream provides an interface to a sequenced set of values of a specific element type ● Because collections are data structures, they’re mostly about storing and accessing elements with specific time/space complexities ● Streams are about expressing computations such as filter, sorted, and map that ● Collections are about data; streams are about computations p2
  24. 24. Basic building blocks summary Function Function reference Lambda Predefined Java8 functions - java.util.function Stream API p2
  25. 25. Why Functional? Less code Expressive code Correct code It is FUN Performance* p2
  26. 26. Imperative p5
  27. 27. Declarative p5
  28. 28. Referential transparency An expression is said to be referentially transparent if it can be replaced with its value without changing the behavior of a program (in other words, yielding a program that has the same effects and output on the same input). The opposite term is referential opaqueness. http://en.wikipedia.org/wiki/Referential_transparency_(com puter_science)p2**
  29. 29. Pure Function 1. Given same input, always provides same output 2. Execution does not cause observable side- effects 1+2 = Referential Transparency p2
  30. 30. Why pure functions? Allows automatic optimizations by a compiler Minimizes moving parts Easy to test Increases decoupling p2
  31. 31. Pure functions - is it enough? doIt1(..) and doIt2(..) - are pure functions? but we wrote them in two different ways?! p2
  32. 32. Imperative p5
  33. 33. Declarative p5
  34. 34. Refactor toward functional Let’s combine pure functions with declarative style Example: Design a system that returns top UK and US music albums p3
  35. 35. p3*
  36. 36. p3
  37. 37. p3
  38. 38. We want to search albums By Name and By Year p3*
  39. 39. version 1 p3
  40. 40. version 2 - pass behaviour p3
  41. 41. version 3 - compact naming p3
  42. 42. We want the data in specific form Example: get years of hits albums p3*
  43. 43. version 1 p3
  44. 44. version 2 p3
  45. 45. We want the data reduced Example: get the oldest album p3
  46. 46. version 1 p3
  47. 47. version 2 p3
  48. 48. So far we saw Pure functions vs Non pure... Declarative vs Imperative... Functions as building blocks… Passing behavior vs static behavior… Function reference vs Lambda...
  49. 49. Additional useful techniques Execution guarantee Builder pattern Composition Currying and Partial application p4
  50. 50. We want to Guarantee correct locking by Write it once and Let it use in multiple places p4*
  51. 51. Execution guarantee p4
  52. 52. Builder pattern StringBuilder is a good example: p4
  53. 53. How builder pattern helps? We already saw it - streams We can create our own builders to introduce fluent interfaces p4
  54. 54. Can we search by multiple filters? p4
  55. 55. We actually want this: p4*
  56. 56. How can we achieve this? p4
  57. 57. Composition p4
  58. 58. Partial Application p4
  59. 59. Search using match(...) p4
  60. 60. Search with Partial Application V1 p4
  61. 61. Search with Partial Application V2 p4
  62. 62. Why Functional? Less code Expressive code Correct code It is FUN Performance*
  63. 63. Performance - is it better in java8? Depends: ● Pure functions may be memoized ● Stream API may be heavier ● There are more considerations…. p5
  64. 64. Performance - example We have doIt1 and doIt2 using both imperative and declarative styles p5
  65. 65. Imperative p5
  66. 66. Declarative p5
  67. 67. Performance - example Let’s run it 1000 times Results: ● doIt1 took: 15ms ● doIt2 took: 63ms p5
  68. 68. Declarative - improved version p5
  69. 69. Performance - example Let’s run it 1000 times Results: ● doIt1 took: 15ms ● doIt2 took: 63ms ● doIt4 took: 30ms p5
  70. 70. Can Java 8 be used for functional programming? Function reference Composition Lambda Stream API Currying and Partial Application*
  71. 71. Any problems? We have to define an interface for a function Special treatment for functions with primitives Partial application is not straightforward Typed exceptions
  72. 72. Guidelines Aim to declarative Aim to immutability Aim to pure functions Consider function ref over lambda Be aware of performance when using stream Use multi paradigm programming
  73. 73. all sample are available at: https://github.com/victor-prp/java8samples

×