Functional programming principles and Java 8
Download as pptx, pdf7 likes1,533 views
The principles of functional programming with applications in Java 8. Streams, Functions, Default Methods, Optional
![OPTIONAL / NULL, THE BILLION DOLLAR MISTAKE
"I call it my billion-dollar mistake. It was the invention of the
null reference in 1965. [âŚ]
I couldn't resist the temptation to put in a null reference,
simply because it was so easy to implement.
This has led to innumerable errors, vulnerabilities, and system
crashes, which have probably caused a billion dollars of pain
and damage in the last forty yearsâ
Tony Hoare](https://image.slidesharecdn.com/functionalprogramming1-150427103651-conversion-gate02/85/Functional-programming-principles-and-Java-8-86-320.jpg)
More Related Content
What's hot (20)
Viewers also liked (20)
Similar to Functional programming principles and Java 8 (20)
Recently uploaded (20)
Functional programming principles and Java 8
- 1. FUNCTIONAL PRINCIPLES Introduction to Functional Programming and Java 8
- 2. WHY ?
- 3. WHY FUNCTIONAL PROGRAMMING ? / MOOREâS LAW
- 4. WHY FUNCTIONAL PROGRAMMING ? / MULTI CORE TREND
- 5. WHY FUNCTIONAL PROGRAMMING ? / SOME HISTORY
- 6. WHAT ?
- 7. ⢠A programming paradigm where functions are first-class entities ⢠The main concepts are: 1. programming with functions 2. avoid mutation ⢠A new way of thinking WHAT IS FP ?
- 8. ⢠Object Immutability ⢠Functions: â as first class citizens â no side effects (Pure functions) â Higher Order Functions ⢠No loops ⢠Lazy evaluation WHAT IS FP ? / FUNCTIONAL PRINCIPLES
- 9. ⢠Easier parallelization ⢠Less code ⢠Easy testing ⢠Results instead of steps ⢠Easy to understand code WHAT IS FP ? / WHAT YOU GET ?
- 10. HOW ?
- 11. IMMUTABILITY
- 12. An immutable object is an object whose state cannot be modified after it is created IMMUTABLE OBJECTS
- 13. âClasses should be immutable unless thereâs very good reason to make them mutable⌠If a class cannot be made immutable, limit its mutability as much as possibleâ Joshua Bloch IMMUTABLE OBJECTS
- 14. IMMUTABLE OBJECTS / JAVA
- 15. IMMUTABLE OBJECTS / DEFENSIVE COPY
- 16. IMMUTABLE OBJECTS / OTHER FUNCTIONAL LANGUAGES
- 17. IMMUTABLE OBJECTS / OTHER FUNCTIONAL LANGUAGES
- 18. IMMUTABLE OBJECTS / HOW TO CHANGE ?
- 19. IMMUTABLE OBJECTS / PARALLELISM
- 20. â˘are thread-safe â˘are simple to construct â˘easy to test â˘easy to use â˘favors caching IMMUTABLE OBJECTS / PROS
- 21. ⢠Large object graphs ⢠Memory consumption ⢠Extra garbage collection cycles needed IMMUTABLE OBJECTS / CONS
- 22. FUNCTIONS F : X â Y
- 24. HOF = functions that can take other functions as arguments and / or return other functions as result HIGHER ORDER FUNCTIONS / DEFINITION
- 25. HIGHER ORDER FUNCTIONS / FIRST CLASS CITIZENS
- 26. HIGHER ORDER FUNCTIONS / FUNCTIONS AS PARAMS
- 27. HIGHER ORDER FUNCTIONS / RETURN FUNCTIONS
- 28. HIGHER ORDER FUNCTIONS / HOFS EXAMPLE IN F#
- 29. HIGHER ORDER FUNCTIONS / BENEFITS
- 30. â˘Allows easy parallelism â˘Encourages abstraction â˘Reusing of common code â˘Isolates the essential parts â˘Allows easier unit testing HIGHER ORDER FUNCTIONS
- 31. HIGHER ORDER FUNCTIONS/ HOFS IN JAVA
- 32. HIGHER ORDER FUNCTIONS / JAVA CLASSES
- 33. HIGHER ORDER FUNCTIONS / USAGE OF JAVA 8 FUNC. CLS.
- 35. HIGHER ORDER FUNCTIONS / LAMBDA EXPRESSIONS ⢠A lambda expression is an anonymous method ⢠Lambdas favor HOFs ⢠more powerful libraries ⢠more expressive, more readable, less error-prone use code ⢠Boosts developer productivity ⢠key to an accessible parallelism strategy
- 36. HIGHER ORDER FUNCTIONS / LAMBDA EXAMPLES 1
- 37. HIGHER ORDER FUNCTIONS / LAMBDA EXAMPLES 2
- 38. HIGHER ORDER FUNCTIONS / HOF IN JAVA 8
- 40. HIGHER ORDER FUNCTIONS / FUNC. INTERFACE EXAMPLE
- 41. HIGHER ORDER FUNCTIONS / FUNCTION REFERENCES
- 42. CHECKPOINT
- 44. A function is said to be pure if 1. it returns same set of values for same set of inputs 2. It does not have any observable side effects PURE FUNCTIONS / DEFINITION
- 45. PURE FUNCTIONS / EXAMPLE 1
- 46. PURE FUNCTIONS / EXAMPLE 2
- 47. Impure functions / Side effects : 1. Alter parameters passed by ref 2. Alter members of passed objects 3. Alter external objects PURE FUNCTIONS / SIDE EFFECTS
- 48. PURE FUNCTIONS / EXAMPLE 2
- 49. ⢠sin(x) ⢠length(a) ⢠random() ⢠println(String s) ⢠Insert values(x, y, z) into DB_TABLE PURE FUNCTIONS / SAMPLE OF PURE AND IMPURE FNC
- 50. ⢠easier to understand ⢠easy maintenance ⢠easy testing / unit-testing ⢠favor concurrency PURE FUNCTIONS / PROS
- 51. PURE FUNCTIONS / BENEFITS
- 52. âNo side effectsâ is utopic PURE FUNCTIONS / CONS
- 54. FUNCTION COMPOSITION / MATH
- 55. FUNCTION COMPOSITION / SUPPORT IN JAVA 8
- 56. FUNCTION COMPOSITION / THE POWER OF COMPOSITION
- 57. CHECKPOINT
- 58. NO LOOPS
- 59. NO LOOPS / RECURSION
- 61. RECURSION / EXAMPLE OF AN ITERATIVE FUNCTION A recursive function is a function that calls itself during its execution
- 62. RECURSION / RECURSIVE VS. ITERATION
- 63. RECURSION / TAIL RECURSION Tail recursion = a recursive function calls itself as its last action
- 64. NO LOOPS / RECURSION - TAIL RECURSION
- 65. NO LOOPS / RECURSION - TAIL RECURSION OPTIMIZATION
- 66. NO LOOPS / RECURSION - RECURSION ENCOURAGED
- 68. NO LOOPS / FUNCTION CHAINING ⢠Similar to unix pipes : ps -ax | tee processes.txt | more ⢠Already used in java in fluent interfaces ⢠Eliminate the need for intermediate variables
- 69. NO LOOPS / FUNCTION CHAINING persons.stream() .filter(e -> e.getGender() == Person.Sex.MALE) .forEach(e -> System.out.println(e.getName())); for (Person p : persons) { if (p.getGender() == Person.Sex.MALE) { System.out.println(p.getName()); } }
- 70. NO LOOPS / AGGREGATE OPERATIONS ⢠They use internal iteration ⢠They process elements from a stream ⢠They support behavior as parameters
- 71. NO LOOPS / FUNCTION CHAINING EXAMPLE
- 72. NO LOOPS / FUNCTION CHAINING
- 73. NO LOOPS / FUNCTION CHAINING double average = persons.stream() .filter(p -> p.getGender() == Person.Sex.MALE) .mapToInt(Person::getAge) .average() .getAsDouble();
- 74. FUNCTION CHAINING / DEFAULT METHODS
- 75. FUNCTION CHAINING / DEFAULT METHODS
- 76. FUNCTIONS CHAINING / STREAMS IN JAVA 8 ⢠Streams do not provide a means to directly access or manipulate their elements ⢠are concerned with declaratively describing the computational operations which will be performed in aggregate on that source ⢠No storage: they carry values from a source through a pipeline ⢠Functional in nature ( operations do not modify its underlying data) ⢠Operations can be implemented lazily ( for single pass execution & efficient implementation of short-circuit operations) ⢠No bounds : streams can be infinite
- 77. FUNCTION CHAINING / STREAMS, OPTIONAL, LAZINESS
- 78. FUNCTION CHAINING / SEQUENTIAL REDUCE
- 79. FUNCTION CHAINING / SEQUENTIAL REDUCE
- 80. FUNCTION CHAINING / PARALLEL STREAMS
- 81. FUNCTION CHAINING / PARALLEL REDUCE
- 82. PERFORMANCE OF PARALLEL PROCESSING
- 83. FUNCTION CHAINING / OTHER EXAMPLES
- 85. OPTIONAL / WHY OPTIONAL ?
- 86. OPTIONAL / NULL, THE BILLION DOLLAR MISTAKE "I call it my billion-dollar mistake. It was the invention of the null reference in 1965. [âŚ] I couldn't resist the temptation to put in a null reference, simply because it was so easy to implement. This has led to innumerable errors, vulnerabilities, and system crashes, which have probably caused a billion dollars of pain and damage in the last forty yearsâ Tony Hoare
- 87. OPTIONAL / THE SOLUTION TO NULL java.util.Optional<T> : ⢠A class that encapsulates an optional value ⢠A single-value container that either contains a value or doesn't (empty)
- 88. OPTIONAL / HOW TO CREATE IT
- 89. OPTIONAL / HOW TO USE IT
- 90. OPTIONAL / THE MOST IMPORTANT METHODS
- 91. OPTIONAL / RETURN TO ORIGINAL EXAMPLE
- 92. OPTIONAL / BENEFITS ⢠Idiot proof / Clear intent ⢠Cleaner code (no more null checks) ⢠Encourages method chaining ⢠End of NullPointerException
- 93. OPTIONAL / CONS ⢠Performance ⢠Serialization - Optional is not ⢠Certain operations involving parametric polymorphism become cumbersome
- 94. CHECKPOINT
- 96. EVERYTHING CHANGES / THREADS WITH LAMBDAS
- 97. EVERYTHING CHANGES / ACTION LISTENERS W/ LAMBDAS
- 98. EVERYTHING CHANGES / COMPARATORS
- 99. EVERYTHING CHANGES / LIST ITERATION, FILTERING, ETC.
- 100. EVERYTHING CHANGES / READING FILES
- 101. EVERYTHING CHANGES / SPRING
- 102. CHECKPOINT
- 103. ⢠Immutability ⢠Higher Order Functions ⢠Pure functions ⢠No loops ( recursion, function chaining) ⢠Lazy evaluation ⢠Type inference ⢠Parallelism ⢠Easy coding / understanding RECAP / FUNCTIONAL PROGRAMMING
- 104. ⢠Introduced FP features ⢠Functional interfaces ⢠Function/Predicate/Producer/Consumer ⢠Default methods ⢠Lambda expressions ⢠Streams ⢠Map/Reduce/Filter/Collect ⢠Type inference RECAP / JAVA 8
- 105. ⢠Easier parallelization ⢠Less code ⢠Easy testing ⢠Results instead of steps ⢠Easy to understand code WHAT IS FP ? / WHAT YOU GET ?
- 106. QUESTIONS
- 107. THE END
- 108. ⢠Scheme, Lisp ⢠ML, OCaml ⢠Haskell ⢠Erlang ⢠Scala ⢠Clojure ⢠F# WHATâS NEXT ? / OTHER FUNCTIONAL LANGUAGES
- 109. â˘Retrolambda â backport of java 8 lambdas in Java 7,6,5 â˘functionaljava.org â˘Google Guava WHATâS NEXT ? / FP IN JAVA BEFORE JAVA8
- 110. â˘Reactive programming WHATâS NEXT ? / OTHER TECHNOLOGIES
Editor's Notes
- #2: Ce ne propunem ? Prezentarea este destul de ambitioasa pentru ca ataca doua tinte: functional programming si java8 most important features. Focusul va fi pe FP. Disclaimer: - codul in F#
- #4: The evolution of the clock speed over time. Unul din factorii care contribuiau la imbunatatirea puterii de calcul si-a oprit cresterea. Este prima data cand legea lui Moore este pusa sub semnul intrebarii.
- #5: Hardware-ul se schimba -> software-ul treâ sa se schimbe pentru a tine pasul. Articol: The free lunch is over : - processor manufacturers will focus on products that better support multithreading (such as multi-core processors) - software developers will be forced to develop massively multithreaded programs as a way to better use such processors (i.e: proasta calitate a codului, nu mai poate fi acoperita de imbunatatirea vitezei de calcul) Codul nostru va rula distribuit intre core-urile procesorului.
- #6: Evolutia limbajelor de programare. A se nota faptul ca limbajele functionale au aparut cu mult inaintea limbajelor OOP. Principiile din limbajele functionale se mapeaza mult mai bine pe ideea de multi threading / paralelism.
- #9: Principiile FP derivate din cele doua concepte prezentate anterior
- #10: Easier parallelization != No work for parallelization Results instead of steps -> SQL Verbe in locul substantivelor
- #14: Imutabilitatea nu e ceva nou. Este recomandata si-n OOP.
- #15: No setters Final fields Final class Java examples ?
- #16: Un exemplu mai complex. Unul din campurile clasei este mutabil. Ultima metoda returneaza o copie defensiva pentru a evita mutabilitatea.
- #17: Exemplu de clasa imutabila in Scala.
- #18: Exemplu de clasa imutabila in F#. Pentru a face un obiect mutabil trebuie utilizat cuvantul cheie âmutableâ
- #19: Talk about the memory consumption and the extra work to be done by the garbage collector. Extrapolate the example above to lists, trees, etc.
- #21: Other benefits: - don't need a copy constructor - don't need an implementation of clone - allow hashCode to use lazy initialization, and to cache its return value - don't need to be copied defensively when used as a field - make good Map keys and Set elements (these objects must not change state while in the collection) - always have "failure atomicity" : if an immutable object throws an exception, it's never left in an undesirable or indeterminate state
- #22: In loc de obiectul rational de mai devreme sa ne gandim ca avem o lista.add Garbage collection: ok atata timp cat nu lucrezi la Twitter.
- #25: This cannot be achieved in Java but ⌠talk about the new functional interfaces ; Predicate, Filter, âŚ
- #26: HOFs can be assigned to variables HOFs can be created at runtime and used Functions are just as any other data types
- #27: Sum accepts another function as input parameter
- #28: higherOrderFunction returns a function as a result
- #29: Functions as first class citizens Functions as parameters Functions as return values
- #30: sumOfSquares -> easy abstraction â> sum (f) Easy parallelism
- #32: A new package added in java8 In java everything is a class -> functions are classes
- #33: The most important java classes in the java.util.function package All introduced in Java8
- #34: Cam asa am fi utilizat clasele in Java 7
- #35: Note the lambda expression No boilerplate Explain the type inference
- #36: Remember the anonymous classes in java
- #37: Examples with the most important classes implemented as lambda expressions
- #40: Cum acoperim toate situatiile ? Prin annotation : FunctionalInterface A functional interface has only one abstract method. Instances of functional interfaces can be created with lambda or method references
- #41: This is how we use the Functional Interface annotation. Note: the lambda expression used to define an anonymous definition of a Functional Interface
- #42: Cum utilizam metodele deja existente ? De observat referintele la metodele din clasele Math, Integer.
- #43: HOF Lambda Function references
- #44: Pure functions = No side effects
- #46: Impure function - has side effects
- #47: Impure function -> it doesnât return the same values for the same inputs
- #50: Sin = pure Length = pure Random() = impure Println() = impure SQL Insert = impure
- #51: Easier to maintain: devs spend less time analyzing the impact Once tested all edge conditions we can be sure that the function behaves correctly Easy concurency: see next side/example
- #52: No side effects favorizeaza paralelismul The same input -> same output favorizeaza testarea si intelegerea
- #53: Any write to the console is a side-effect. Database updates or file writes on disk is a side-effect. So we cannot be 100% pure but the goal is to be as pure as possible. In an input â processâ output flow the goal is to keep the middle (process) functional.
- #55: g o f (c) = #
- #56: Metodele compose si andThen
- #58: Pure functions Function composition HOF Lambdas Function references
- #60: What is the problem ? Incurajeaza shared state (variabilele partajate) = nu bine pt. paralelism Mult boilerplate
- #61: Why avoid loops ? boilerplate code Incurajeaza partajarea state-ului deci nu este prietenos cu multi-threadingul.
- #63: In some cases ( most of them ? ) recursion is more intuitive then iteration. Functional languages have better implementations for recursion For OOP languages iteration is much faster than recursion The mantra of functional languages: CLARITY TRUMPS EFFICIENCY (preferam claritatea vs. eficienta)
- #64: the functionâs stack frame can be reused. Remember stiva de executie a unei functii.
- #65: After the call to factorial(n-1) there is still work to be done => not a tail recursive action
- #66: Note: Since the stack trace is optimized, when printing the stack trace one will only see the last call instead of the entire stack trace.
- #67: Functional languages have better support for recursion (see the list.head, list.tail) This is not possible with all lists in idiomatic java.
- #68: Function chaining = Un caz particular de compozitie
- #69: To be discussed here: Imperative approach vs. Functional approach : For vs. map-reduce State vs. stateless
- #70: Discussion about state / share state ( in a multi-threaded env.) : letâs sum the salaries of males in a multi-threaded env. Func. Chaining can be seen as a particular case of composition.
- #71: Discussion about state / share state ( in a multi-threaded env.) : letâs sum the salaries of males in a multi-threaded env. Func. Chaining can be seen as a particular case of composition.
- #72: Note the chaining of combinator methods : map, filter, reduce/foldLeft
- #73: The same functionality in Java8. Imperative vs. Declarative style / Ce face functia vs. Cum face functia / The SQL Example. Note 1: the stream() method Note 2: a method added to a the list interface (DEFAULT METHODS discussion) Discussion about map/filter/reduce Weâll come back to map/reduce/filter in a few moments
- #74: The average age of males in the persons list. When using streams we need the following components: 1 A source ( list ) 2.Zero or more intermediate operations ( filters, transformers) 3. A terminal operation ( average)
- #75: Default Method Discussion 2. Stream interface
- #76: The Stream interface and the map / reduce methods
- #77: Streams cannot be reused. Please check the Stream javadoc . http://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html#StreamOps
- #78: The stream could have been infinite I could have used only lambdas Note the findFirst method returning an optional (discussed later in this material) Re-start the map/reduce discussion
- #79: Reduce needs to be associative (a+b)+c = a+(b+c), i.e. the order in which the additions are performed doesn't matter.
- #80: How sequential reduce works.
- #81: Free parallelism but this doesnât happen every time Sum() is a particular form of reduce() â a shortcut for reduce(0, (a,b) -> a+b) reduce, collect, sum = terminal methods Note: Order of filtering matters
- #82: Note: the operation has to be associative otherwise the result will not be consistent (no compilation or runtime error) Example of a non associative operation: x*x + y*y Discussion about non-associative
- #83: Disclaimer: the table shows the test results in ideal conditions ( no other threads were running) - in production systems you wonât get this kind of difference
- #84: The power of collectors
- #87: The problem with null: Depending on the context, null means âno valueâ, other times it means âerrorâ or ânothingâ, but it can even mean âsuccessâ
- #88: Optional is inspired from Haskel and Scala
- #93: Idiot proof : It forces you to actively think about the absent case if you want your program to compile There are three ways to deal with the absence of a value in an Optional: to provide a substitute value, to call a function to provide a substitute value, or to throw an exception
- #95: Functional programming = no loops Recursivitate Function chaining Function composition Streams Map / reduce Default methods Optional
- #96: Functional programming = no loops Recursivitate Function chaining ( this is also related to composition) Streams Map / reduce
- #97: Lambda instead of a Runnable Runnable este o interfata functionala
- #98: Lambda instead of an Action Listener
- #99: Lambda instead of a Comparator. Why the Users type has been specified ? - where is the type inference ?
- #100: Method reference in a forEach method
- #101: BufferedReader.lines() returns a Stream Files.lines() returns a Stream as well. The examples shows how to use the stream in a try-with-resources ( it implements AutoClosable).
- #102: Spring jdbc template with lambda expressions ( instead of RowMapper.mapRow(ResultSet, int rowNum)
- #104: Outside the scope : Advanced Laziness Monads Function currying
- #105: Outside the scope : Java8 ------------------------------------ Type Annotations Date and time API Lambda translation to bytecode Nashorn Javascript engine
- #106: Easier parallelization != No work for parallelization What instead of How Verbe in loc de substantive
- #108: Some non-programming mistakes have been intentionally inserted into the presentation
- #111: Responsive: The system responds in a timely manner Resilient: The system stays responsive even in failure Elastic: The service allocates resources as needed ( according to the workload) Message Driven: Async message passing for loose coupling, isolation, transparency