Functional Programming is a concept which treats functions as first class citizens. At the core of functional programming is immutability. It emphasizes on application of functions in contrast to imperative programming style which emphasizes on change in state.
https://www.jcp.org/aboutJava/communityprocess/final/jsr335/index.html

Exercises:

• Lambdas
• Difference between Lambda Expression and Anonymous class
• Monads
• Stream API
• Streams and Parallel Streams
• Functions & Primitives
• Currying vs Closures
• Pure function
• @FunctionalInterface
• Built-in Functional Interfaces
• Passing behaviours
• Function chaining

https://rosettacode.org/wiki/Rosetta_Code
http://www.learntosolveit.com/#java-programming-language
https://www.lucidchart.com/techblog/2016/11/22/tracking-data-in-complex-java-code-a-functional-programming-approach/
https://pawelwlodarski.gitbooks.io/functional-programming/content/functions_in_java_-_intro.html
https://github.com/PawelWlodarski/workshops-javafp
https://pawelwlodarski.gitbooks.io/functional-programming/content/workshop1.html

http://projectreactor.io/
It directly interacts with Java 8 functional API, Completable Future, Stream and Duration

It is necessary to create the landing for the first week.

https://www.airpair.com/java/posts/parallel-processing-of-io-based-data-with-java-streams

ReactiveX:
An API for asynchronous programming with observable streams

http://reactivex.io/
https://github.com/ReactiveX/RxJava
https://github.com/Reactive-Extensions/
http://rxmarbles.com/
https://en.wikipedia.org/wiki/Observer_pattern

The observer pattern is a software design pattern in which an object, called the subject, maintains a list of its dependents, called observers, and notifies them automatically of any state changes, usually by calling one of their methods.

                single items	                multiple items
synchronous	 T getData()	                Iterable<T> getData()
asynchronous	 Future<T> getData()	Observable<T> getData()

Observables Are Composable
Techniques like Java Futures are straightforward to use for a single level of asynchronous execution but they start to add non-trivial complexity when they’re nested.

It is difficult to use Futures to optimally compose conditional asynchronous execution flows (or impossible, since latencies of each request vary at runtime). This can be done, of course, but it quickly becomes complicated (and thus error-prone) or it prematurely blocks on Future.get(), which eliminates the benefit of asynchronous execution.

ReactiveX Observables, on the other hand, are intended for composing flows and sequences of asynchronous data.

https://gist.github.com/benjchristensen/4670979
https://gist.github.com/benjchristensen/4671081
https://gist.github.com/benjchristensen/4671081#file-futuresb-java-L163
https://gist.github.com/benjchristensen/4677544

Paste here the links about your developments.

https://spring.io/guides/gs/async-method/
https://geowarin.github.io/completable-futures-with-spring-async.html

https://github.com/mattboldt/typed.js/