Functional programming principles and Java 8
Download as PPTX, PDF7 likes1,534 views
The document provides an introduction to functional programming, particularly in the context of Java 8, emphasizing principles such as immutability, first-class functions, and the avoidance of side effects. It covers key concepts including higher-order functions, lambda expressions, and the use of streams for operations, all aimed at enhancing code efficiency and maintainability. Additionally, it discusses the benefits of functional programming, such as easier parallelization and testing, while also touching upon challenges like null references.
![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)
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