Functional programming principles and Java 8

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