Functional programming with Java 8
19 likes6,928 views
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.
More Related Content
What's hot (20)
Viewers also liked (7)
Similar to Functional programming with Java 8 (20)
More from LivePerson (20)
![Apache Avro in LivePerson [Hebrew]](https://cdn.slidesharecdn.com/ss_thumbnails/apacheavroinliveperson2014-141027092641-conversion-gate02-thumbnail.jpg?width=560&fit=bounds)
Recently uploaded (20)
Functional programming with Java 8
- 1. Functional Programming with Java 8 Victor Perepelitsky slides: http://www.slideshare.net/victorperepelitsky/fun-with-java-8 twitter: @victor_perepel email: [email protected] git-hub: https://github.com/victor-prp/java8samples/
- 2. This presentation focuses on What functional programming is ? Why functional ? How to use java 8 for functional ?
- 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. Functional Programming Functions Avoids mutable data Declarative Expressions
- 5. Why Functional? Less code Expressive code Correct code It is FUN Performance*
- 6. Functional building blocks in java 8 Function Function reference Lambda Predefined Java8 functions - java.util.function Stream API p2
- 9. Fun Reference - static fun p1
- 10. Fun Reference - static fun p1
- 11. Higher Order Function - Definition p1*
- 12. p1
- 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. Lambda - simple example p1
- 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. Lambda Anonymous function Passed as argument (common usage) In java 8 it is only syntactic sugar for function reference p1
- 18. Lambda p1
- 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. 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. 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. 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. 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. Basic building blocks summary Function Function reference Lambda Predefined Java8 functions - java.util.function Stream API p2
- 25. Why Functional? Less code Expressive code Correct code It is FUN Performance* p2
- 26. Imperative p5
- 27. Declarative p5
- 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. Pure Function 1. Given same input, always provides same output 2. Execution does not cause observable side- effects 1+2 = Referential Transparency p2
- 30. Why pure functions? Allows automatic optimizations by a compiler Minimizes moving parts Easy to test Increases decoupling p2
- 31. Pure functions - is it enough? doIt1(..) and doIt2(..) - are pure functions? but we wrote them in two different ways?! p2
- 32. Imperative p5
- 33. Declarative p5
- 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. p3*
- 36. p3
- 37. p3
- 38. We want to search albums By Name and By Year p3*
- 39. version 1 p3
- 40. version 2 - pass behaviour p3
- 41. version 3 - compact naming p3
- 42. We want the data in specific form Example: get years of hits albums p3*
- 43. version 1 p3
- 44. version 2 p3
- 45. We want the data reduced Example: get the oldest album p3
- 46. version 1 p3
- 47. version 2 p3
- 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. Additional useful techniques Execution guarantee Builder pattern Composition Currying and Partial application p4
- 50. We want to Guarantee correct locking by Write it once and Let it use in multiple places p4*
- 52. Builder pattern StringBuilder is a good example: p4
- 53. How builder pattern helps? We already saw it - streams We can create our own builders to introduce fluent interfaces p4
- 54. Can we search by multiple filters? p4
- 55. We actually want this: p4*
- 56. How can we achieve this? p4
- 57. Composition p4
- 60. Search with Partial Application V1 p4
- 61. Search with Partial Application V2 p4
- 62. Why Functional? Less code Expressive code Correct code It is FUN Performance*
- 63. Performance - is it better in java8? Depends: ● Pure functions may be memoized ● Stream API may be heavier ● There are more considerations…. p5
- 64. Performance - example We have doIt1 and doIt2 using both imperative and declarative styles p5
- 65. Imperative p5
- 66. Declarative p5
- 67. Performance - example Let’s run it 1000 times Results: ● doIt1 took: 15ms ● doIt2 took: 63ms p5
- 68. Declarative - improved version p5
- 69. Performance - example Let’s run it 1000 times Results: ● doIt1 took: 15ms ● doIt2 took: 63ms ● doIt4 took: 30ms p5
- 70. Can Java 8 be used for functional programming? Function reference Composition Lambda Stream API Currying and Partial Application*
- 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. 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
- 76. all sample are available at: https://github.com/victor-prp/java8samples
Editor's Notes
- #8: part 1 - fun def