Download as PDF, PPTX
![+--------------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)); 😲 😏 😏](https://image.slidesharecdn.com/obtp2u6dqpmwmtcr7n2l-signature-ce6752bfde8fe9753130657f95f63ddf5f68bfe4161540393a8e3b969bd03315-poli-161129145534/75/Functional-Reactive-Programming-with-Kotlin-on-Android-Giorgio-Natili-Codemotion-Milan-2016-26-2048.jpg)
Uploaded byCodemotion
Functional Reactive Programming with Kotlin on Android - Giorgio Natili - Codemotion Milan 2016
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.
Functional Reactive Programming with Kotlin on Android - Giorgio Natili - Codemotion Milan 2016
- 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 ReactiveProgramming + 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 hellis 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 + Humansdo 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 valuesreturned 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 RxKotlinare 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.
- 13. +--------------X----X---X---X---X------------> +---------------------------------#MobileTea-> Observable<T> + An Observablerepresents 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 Observablecan 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 Observableare 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 Subscriptionactivates 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 itemsemitted 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 functionto 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 operatorfilters 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 thefirst 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 newbuffer 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 anitem 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(newObservable.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 + Dataclasses + Inferred datatypes + Nullable types + Arguments default value + Lambda expression and "elvis" operator + Extension functions
- 32.
- 33.
- 34. +--------------X----X---X---X---X------------> +---------------------------------#MobileTea-> Nullable Types Nothing canbe 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 publicclass 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(valemail: String) { val nickname: String get() { return email.substringBefore("@") } } 😏
- 37. +--------------X----X---X---X---X------------> +---------------------------------#MobileTea-> Inferred Datatypes The datatype 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 DefaultValues + 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 isthe 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 chunksof 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 Thewith 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-orderfunction 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 + Functionsthat 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 Gotso 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 wordsextends 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 lackof 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 funContext.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 + Byadding 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 + Acommon 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(), createsand 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() methodallows 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 + FRPdoesn’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 runon 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 knowthe 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 :) “FRPprogrammers do it better.”