The document provides an overview of a talk on Functional Reactive Programming (FRP) and Kotlin. The key points covered include: - An introduction to FRP as a programming paradigm focused on reacting to streams of data changes. - Examples of FRP concepts like streams, functions composition, and reactive extensions operators like flatMap, scan, groupBy, and debounce. - An overview of Kotlin features like data classes, nullable types, default arguments, lambdas, and extension functions. - How RxKotlin allows combining FRP and Android using Observables to handle user input and events in a reactive way.

1. + ^
| | @giorgionatili
+-------------------------------------+--------------+
FRP + Kotlin
A journey into new programming paradigms
and magical operators

2. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
About Me
/ :
/ :'
.. / :'
( , '
|( '
( ` .---.
`
.-..-.
( _.._.--. `.
' '._`-._..-'``__ `-. '. ..7
'. ``` /``` `'. `-.-~-.`-/
.-.:>. __. '. | ( `'
( ( . . )
`'-._ `'(__. :
.7 (_. ( :
.' , '-
__--': . . `'
/ ,: ,/ /__. . .
'--'` `--' `' / | : /|
/ | |` |
/ | : (
.' .'| '. '
( / | : '.
( (
)./-
(` ,./.-''-:.
+ Engineering Manager at Akamai
(NG2 on desktop and mobile)
+ VP of Engineering at Sync Think
(Android, VR and Python)
+ Founder of Mobile Tea
(www.meetup.com/pro/mobiletea)
+ Leader of the Boston Twitter UG
+ Organizer of DroidCon Boston
(www.droidcon-boston.com)

3. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Agenda
+ Functional Reactive Programming
+ Kotlin in a nutshell
+ RxKotlin: FRP with Android
+ Kotlin and multithreading

4. + ^
| | @giorgionatili
+-------------------------------------+--------------+
Functional
Reactive
Programming

5. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
What the hell is FRP
+ FRP is a programming paradigm
+ It focuses on reacting to streams of
changes (data and events)
+ It favors function composition,
avoidance of global state and side
effects

7. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Programming Paradigm
+ Humans do not think like computer so
we add abstractions
+ FRP is an abstraction just like
imperative programming idioms are
abstractions for binary instructions
+ FRP is all about capturing evolving
values (aka Observer pattern on
steroids 🚀)

8. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Streams
+ a, b, c, d are emitted values
+ X is an error
+ | is the 'completed' signal
+ ---> is the timeline
+ --a---b-c---d---X---|->

9. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Functions
Composition
+ The values returned by any operator
are chain-able (functional magic 😎)
+ The original input is immutable
val strings = listOf("one", "two", "treee", "a", "four")
val filtered = strings.filter { it.length >= 3 }
.map { it.toUpperCase() }
println(filtered) // ONE, TWO, THREE, FOUR

11. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Disclaimer
RxJava and RxKotlin are not pure
FRP, in fact, FRP involves
continuos time whereas the Reactive
Extensions only deal with discrete
event over time.
Anyway, the implementation and the
chain-able operators make RxJava
and RxKotlin a good enough solution
for Android apps.

12. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Installation
compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
compile 'io.reactivex.rxjava2:rxjava:2.0.1'

13. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Observable<T>
+ An Observable represents a flowing
stream of values
+ UI events
+ Data processed in background
+ The most similar abstraction is
Iterable<T>

14. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Push vs Pull
+ Observable is push based, it decides
when to emit values
+ Iterable is pull based, it sits until
the some ask for the next() value

15. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Push vs Pull
// Java
Range range = new Range(1, 10);
Iterator<Integer> it = range.iterator();
while(it.hasNext()) {
int cur = it.next();
System.out.println(cur);
}
// RxJava
Observable.range(1, 10).subscribe({ println(it); });

16. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Observable Specs
Every Observable can emit an arbitrary
number of values optionally followed
by completion or error (but not both)
interface Observer < T > {
void onNext( T t) // Data
void onError( Throwable t) // Error
void onCompleted() // Stream completion
}

17. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Create an Observable
Observable are lazy, creation doesn’t
trigger any action
Observable < Tweet > tweets = Observable.create( s -> {
getDataFromServerWithCallback( args, data -> {
try {
s.onNext( data );
s.onCompleted();
} catch (Throwable t) {
s.onError(t);
}
});
});

18. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Subscribe to an
Observable
Subscription activates the Observable
Observable < Tweet > tweets = // ...
tweets.subscribe(
(Tweet tweet) -> {
println( tweet );
},(Throwable t) -> {
t.printStackTrace();
});

19. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Cold vs Hot
Observables
+ A cold Observable is entirely lazy
+ Hot Observables might already be
emitting events no matter how many
Subscribers they have
+ Hot Observables occur when we have
absolutely no control over the source
of events (aka taps)

20. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
FlatMap
Transform the items emitted by an
Observable into Observables, then
flatten the emissions from those into a
single Observable
// Returns a List of websites based on text search
Observable<List<String>> query(String text);
query("Hello, world!")
.flatMap(urls -> Observable.from(urls))
.subscribe(url -> System.out.println(url));

21. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Scan
Apply a function to each item emitted by
an Observable, sequentially, and emit
each successive value
+----1---2------3------4--------5-------------->
scan((x, y) -> (x + y));
+----1---3------6------10-------15------------->

22. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
GroupBy
Observable.from(NumbersGenerator.getList(1000))
.groupBy((i) -> 0 == (int)i % 2 ? "EVEN" : "ODD")
.subscribe((group) -> {
println("Key " + ((GroupedObservable)group).getKey());
((GroupedObservable)group).subscribe((x) ->
println(((GroupedObservable)group).getKey() + ": " + x));
});
Divide an Observable into a set of
Observables that each emit a different
group of items from the original
Observable, organized by key
😏

23. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Distinct
The Distinct operator filters an
Observable by only allowing items
through that have not already been
emitted
Observable < Integer > randomInts = Observable.create( subscriber -> {
Random random = new Random();
while (! subscriber.isUnsubscribed()) {
subscriber.onNext( random.nextInt( 1000 ));
}
});
Observable < Integer > uniqueRandomInts = randomInts
.distinct()
.take( 10);
😏

24. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Take
Emit only the first n items emitted by
an Observable
Observable.interval(1, TimeUnit.SECONDS)
.map { it.toInt() }
.take(20) 😏

25. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Buffer
Creates a new buffer starting with the
first emitted item from the source
Observable, and every skip items
thereafter, fills each buffer with count
items
+--1----2----3----------4-----5------6------->
buffer(count=2, skip|3)
+-----1---2-----------------4-----5--------->

26. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Debounce
Only emit an item from an Observable if
a particular timespan has passed without
it emitting another item
String[] items = {"one", "two", "three", "four", "five"};
Observable.from(items)
.debounce(item -> item.equals("one")
? Observable.empty()
: Observable.timer(1, TimeUnit.SECONDS));
😲
😏
😏

27. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
FRP Use Cases
+ Processing user (tap, swipe, etc.) and
system events (GPS, gyroscope, etc.)
+ Responding and processing any IO event
(asynchronously)
+ Handling events and data pushed from
other sources
+ Many, many, many others! :)

28. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Handling User Input
Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(final Subscriber<? super String> subscriber) {
editText.addTextChangedListener(new TextWatcher() {
@Override
public void beforeTextChanged(final CharSequence s,
final int start, final int count, final int after){}
@Override
public void onTextChanged(final CharSequence s,
final int start, final int before, final int count) {
subscriber.onNext(s.toString());
}
@Override
public void afterTextChanged(final Editable s) { }
});
}
})
.debounce(1000, TimeUnit.MILLISECONDS)
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1<String>() {
@Override
public void call(final String s) {
textView.setText("Output : " + s);
}
});
Create
Emit
Handle stream
Subscribe

30. + ^
| | @giorgionatili
+-------------------------------------+--------------+
Kotlin in a
Nutshell

31. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Why Kotlin
+ Data classes
+ Inferred datatypes
+ Nullable types
+ Arguments default value
+ Lambda expression and "elvis" operator
+ Extension functions

32. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Install the Plugin

33. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Kotlin and the JVM
* Interoperable 100%

34. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Nullable Types
Nothing can be null in Kotlin until is
not specified
val a : String = null // won't compile!
var b : Int // neither! must be initialized
val ok : String? = null // OK :)

35. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Data Classes
// Java
public class User {
private final String nickname;
public User(String nickname) {
this.nickname = nickname;
}
public String getNickname() {
return nickname;
}
}
// Kotlin
class User (val nickname: String)

36. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Custom Getters
class SubscribingUser(val email: String) {
val nickname: String
get() {
return email.substringBefore("@")
}
}
😏

37. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Inferred Datatypes
The data type can be inferred by the
context or by the first assignment
class LengthCounter {
var counter = 0
private set
fun addWord(word: String) {
counter += word.length
}
}

38. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Inline Functions and
Default Values
+ Functions can be declared outside of a
class and imported in others
+ Arguments can have default values
reducing the number of methods
overloads

39. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Elvis Operator
This is the name used for this
operator ?:, you can use it to
give an alternative value in
case the object is null
try {
// code...
} catch (e: Throwable) {
Log.e("TAG", e.message ?: "Error message")
}

40. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Lambas
+ Small chunks of code that can be
passed to other functions
+ The ability to treat functions as
values is part of the functional
programming paradigm
val people = listOf(Person("Alice", 29),
Person("Bob", 31))
println(people.maxBy { it.age }) 😏

41. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
The "apply" Function
+ The apply function allows to execute
multiple operations on the same object
+ The apply function converts its first
argument into a receiver of the lambda
passed as a second argument
fun alphabet() = StringBuilder().apply {
for (letter in 'A'..'Z') {
append(letter)
}
append("nNow I know the alphabet!")
}.toString()
😏

42. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
The "with" Function
The with function works like the apply
one and returns the object to which is
applied
fun alphabet() = with(StringBuilder()) {
for (letter in 'A'..'Z') {
append(letter)
}
toString()
}
😏

43. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
High-Order Functions
A higher-order function is a function
that takes functions as parameters, or
returns a function
fun <T> lock(lock: Lock, body: () -> T): T {
lock.lock()
try {
return body()
}
finally {
lock.unlock()
}
}

44. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Extension Functions
+ Functions that add a new behavior to a
class
+ It’s a way to extend classes which
lack some useful functions
fun String.lastChar(): Char = this.get(this.length - 1)

45. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Java to Kotlin
+ On the main menu, point to Code menu.
+ Choose Convert Java File to Kotlin
File

47. + ^
| | @giorgionatili
+-------------------------------------+--------------+
Recap

48. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
What We Got so Far
+ FRP is a programming paradigm
+ RxJava is a library for composing
asynchronous and event-based programs
using observable sequences for the
Java VM
+ Kotlin is a statically-typed
programming language that runs on the
Java Virtual Machine

49. + ^
| | @giorgionatili
+-------------------------------------+--------------+
RxKotlin: FRP
with Android

50. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Concise
+ The words extends and implement were
replaced by a colon :
+ Methods are defined with the fun
keyword, the return type is optional
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
}
}

51. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Click Listeners
The lack of lambdas in Java 7 is the
reason why listeners and callbacks are
so awful to write with Kotlin
myButton.setOnClickListener { navigateToDetail() }

52. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Toasts and Snacks
fun Context.toast(message: CharSequence, duration: Int = Toast.LENGTH_SHORT){
Toast.makeText(this, message, duration).show()
}
toast("Hello Kotlin!")
fun View.snack(message: String, length: Int = Snackbar.LENGTH_LONG,
f: Snackbar.() -> Unit) {
val snack = Snackbar.make(this, message, length)
snack.f()
snack.show()
}
view.snack("This is my snack")

53. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Composability
view.snack("Snack message") {
action("Action") { toast("Action clicked") }
}
fun Snackbar.action(action: String, color: Int? = null,
listener: (View) -> Unit) {
setAction(action, listener)
color?.let { setActionTextColor(color) }
}

54. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Android Extensions
+ By adding a specific import, the
plugin will be able to create a set of
properties for an activity, a
fragment, or even a view
+ The name of the properties will be the
ones defined in the XML you are
importing
import kotlinx.android.synthetic.main.activity_detail.*

55. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Inflate
fun ViewGroup.inflate(layoutId: Int): View {
return LayoutInflater.from(context)
.inflate(layoutId, this, false)
}
val view = container?.inflate(R.layout.news_fragment)

56. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
RxBindings
import kotlinx.android.synthetic.main.activity_detail.editText
RxTextView.afterTextChangeEvents(editText)
.debounce(1000, TimeUnit.MILLISECONDS)
.subscribe { tvChangeEvent ->
textView.text = "Output : " + tvChangeEvent.view().text
}

58. + ^
| | @giorgionatili
+-------------------------------------+--------------+
Multithreading
Made Simple

59. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
RxJava and
Parallelization
+ A common question about RxJava is how
to achieve parallelization, or
emitting multiple items concurrently
from an Observable.
+ This definition breaks the Observable
contract which states that onNext()
must be called sequentially and never
concurrently

60. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Schedulers
+ immediate(), creates and returns a Scheduler that
executes work immediately on the current thread
+ trampoline(), creates and returns a Scheduler
that queues work on the current thread to be
executed after the current work completes
+ newThread(), creates and returns a Scheduler that
creates a new Thread for each unit of work
+ computation(), creates and returns a Scheduler
intended for computational work
+ io(), creates and returns a Scheduler intended
for IO-bound work (unbounded, multiple threads)

61. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
subscribeOn()
The method subscribeOn() allows you to
move the execution of the Observable
code into another thread and with an
specific behavior
val subscription = newsManager.getNews()
.subscribeOn(Schedulers.io())
.subscribe ({}, {})

62. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
observeOn()
The observeOn() method allows to
specify where to execute the functions
provided in the subscribe() one
val subscription = newsManager.getNews()
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe ({}, {})

63. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Altogether Now
Observable.just("Hello World")
// each subscription is going to be on a new thread
.subscribeOn(Schedulers.newThread())
// observation on the main thread
.observeOn(AndroidSchedulers.mainThread()))
.subscribe(object:Subscriber<String>(){
override fun onCompleted() {
// Completed
}
override fun onError(e: Throwable?) {
// Handle error here
}
override fun onNext(t: String?) {
Log.e("Output",t);
}
})

65. + ^
| | @giorgionatili
+-------------------------------------+--------------+
Take Aways

66. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Functional Reactive
Programming
+ FRP doesn’t solve all the problems
+ FRP hide complexities and make our
code more readable
+ Getting started with FRP is simple and
fast

67. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
RxJava & RxAndroid
+ RxJava and RxAndroid are not a pure
FRP implementation (Sodium, Reactive-
banana are pure FRP)
+ RxExtensions are a tool to uniform
your programming paradigm

68. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Kotlin
+ Kotlin run on top of the JVM
+ Kotlin can help improving the
readability of your code
+ Kotlin is extremely functional, almost
everything is an expression

69. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Trade Off
“Programmers know the benefits of
everything and the tradeoffs of
nothing”
–Rich Hickey

70. +--------------X----X---X---X---X------------>
+---------------------------------#MobileTea->
Resources
+ https://github.com/miquelbeltran/rxjava-
examples
+ https://github.com/marukami/RxKotlin-
Android-Samples
+ https://github.com/JakeWharton/RxBinding
+ https://gist.github.com/GiorgioNatili/
d4a20d4513ee544c0700854d123360d7
+ https://nilhcem.github.io/swift-is-like-
kotlin/

71. Schedule
7:00 pm - 7:30 pm Welcome with beers and snacks
7:30 pm - 8:35 pm Screening of "Design Disruptors"
8:35 pm - 9:30 pm Networking moment and aperitif
Giovedì 1 Dicembre, ore 19:00 , Luiss Enlabs, Stazione Termini, Roma
DESIGN DISRUPTORS is a full-length documentary
featuring design leaders and product designers from
15+ industry-toppling companies—valued at more
than $1trillion dollars combined.
Free, but registration is required :)

72. –Giorgio Natili :)
“FRP programmers do it better.”