Dicoding Developer Coaching merupakan webinar, yang membahas tuntas kendala maupun pertanyaan yang sering ditanyakan di Academy Dicoding. Tema kali ini adalah "Reactive Programming dengan RxJava & Flow" Reactive Programming adalah pemrograman yang berfokus pada asynchronous data stream. Asynchronous adalah proses di mana kita bisa mengeksekusi suatu perintah secara bersamaan, sedangkan kebalikannya yaitu Synchronous adalah proses eksekusi perintah secara berurutan. Dalam Reactive Programming di Android, terdapat 2 library yang wajib kalian ketahui yaitu ReactiveX dan Coroutine Flow.

1. Reactive Programming dengan
RXJava dan Kotlin Flow
Sidiq Permana
Co founder nbs.dev & Google Developer Expert

2. Apa yang akan kita pelajari?
● Reactive vs Imperative Programming
● Konsep Utama Reactive Programming
● Asynchronous dan Stream
● Observable - Operator - Observer
● Use Case Umum di Android
● Perbandingan Library
● Konklusi

3. Reactive vs Imperative
Programming
Dengan pendekatan imperatif, pengembang menulis kode yang
menentukan langkah-langkah yang harus diambil komputer untuk
mencapai tujuan. Ini kadang-kadang disebut sebagai pemrograman
algoritmik. Sebaliknya, pendekatan fungsional melibatkan penyusunan
masalah sebagai seperangkat aliran fungsi yang akan dijalankan untuk
memproses data.

4. Reactive vs Imperative
Programming

5. Reactive Programming
● Reactive Programming adalah istilah pemrograman umum yang berfokus
pada reaksi terhadap perubahan, seperti nilai data atau peristiwa (event).
● Dengan kata lain, pemrograman dengan aliran data asinkron yang
mengirimkan data ke konsumen (consumer) saat tersedia.
● Spreadsheet adalah contoh bagus dari pemrograman reaktif: sel yang
bergantung pada sel lain secara otomatis "bereaksi" saat sel lain itu
berubah.Resources.

6. Reactive Programming

7. Asynchronous dan Stream
Data
● Asynchronous adalah proses di mana Anda dapat menjalankan perintah
secara bersamaan.
● Stream Data adalah urutan data yang diurutkan dalam waktu

8. Observable - Operator -
Observer

9. Contoh

10. Urutan Pemrosesan Dengan
Chaining Operator

11. Urutan Pemrosesan Dengan
Chaining Operator

12. Hot dan Cold Stream
Cold Hot
Data
transmission
time
Lazy stream - new emitting process will start
when someone requests (subscribe)
Eager stream - the emitting process is always
broadcasted even no one asks
Number of
observer
Unicast - only has one observer Multicast - can have multiple observers
Location of data
created
Data is generated outside the stream Data is created in the stream
Simple analogy CDs that need to be played (request) first by
someone before listened
A radio that continues to broadcast even though no
one is listening. Many people can also listening

13. Contoh Hot Stream

14. Contoh Cold Stream

15. Contoh Cold Stream

16. Faedah menggunakan
Reactive Programming

17. Faedah Utama
● Aplikasi lebih reaktif terhadap event! Seperti memproses event
pengguna seperti ketuk dua kali, pencarian, tombol validasi, dan UX
kompleks lainnya.
● Mengakses data dari sumber data secara asinkron tanpa callback hell.
● Memproses data yang diperoleh dari API, seperti mengurutkan dan
memfilter data.
● Multi threading yang lebih baik.

18. Aplikasi Berasa Lebih Reaktif

19. Lebih Fokus Pada Hasil Akhir
Ketimbang Prosesnya
fun register(newUser: NewUser) {
val username: String = newUser.getUsername()
val password: String = newUser.getPassword()
api.register(newUser, object : Callback<Boolean>() {
fun onResponse(success: Boolean) {
if (success) {
api.login(username, password), object :
Callback<Token>() {
fun onResponse(token: Token) {
api.getUser(token, object :
Callback<UserDetails>() {
fun onResponse(userDetails:
UserDetails) {
// continue with app flow
}
})
}
})
}
}
})
}
fun register(newUser: NewUser) {
val username: String = newUser.getUsername()
val password: String = newUser.getPassword()
api.register(newUser)
.filter { success -> success }
.flatMap { success ->
api.login(username, password) }
.flatMap { token -> api.getUser(token) }
.subscribe { userDetails ->
// continue with app flow }
}

20. Lebih Fokus Pada Hasil Akhir
Ketimbang Prosesnya

21. Lebih Fokus Pada Hasil Akhir
Ketimbang Prosesnya

22. Multithreading yang lebih
cakep!
observeSomething()
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe { name -> println(name)}
CoroutineScope(Dispatchers.Main).launch {
observeSomething()
.flowOn(Dispatchers.IO)
.collect { name -> println(name) }
}

23. Reactive Library

24. Membuat Data Stream
Observable.just("1", "2", "3", "4", "5", "6")
.map { string -> string.toInt() }
.filter { number -> number%2 == 1 }
.subscribe { result -> println("$result is odd number") }
Dengan Observable RXJava
CoroutineScope.launch {
flowOf("1", "2", "3", "4", "5", "6")
.map { string -> string.toInt() }
.filter { number -> number % 2 == 1 }
.collect { result -> println("$result is odd number") }
}
Dengan Flow

25. Tipe Stream
RxJava
● Observable: to emits unlimited data streams.
● Flowable: to emits unlimited data streams with back pressure strategy.
● Single: to emits one data only.
● Maybe: same as Single, but it can be no data.
● Completable: stream which can only complete without emitting values.
Flow
● Flow: There is no separate implementations without and with back pressure
support in Kotlin Flow.

26. Backpressure
Backpressure is a situation where the Publisher provides excessive data so that
the Subscriber cannot accommodate it. There are several back pressure
strategies to choose :
● BUFFER: Processes received data and waits for other data in the queue.
● DROP: Processes received data and ignores other data.
● LATEST: Processes received data, but stores the last element in cache.
● MISSING: Processes without using Backpressure Strategy, so you have to
make your own custom.
● ERROR: Notifies MissingBackpressureException error if process is not
robust.

27. Multithreading
observeSomething()
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe { name -> println(name)}
CoroutineScope(Dispatchers.Main).launch {
observeSomething()
.flowOn(Dispatchers.IO)
.collect { name -> println(name) }
}

28. Common Schedulers and
Dispatcher
● io: to performs processes on the I/O Thread such as calling API and writing
databases.
● computation: to performs processes with high CPU requirements such as
converting bitmaps or compressing.
● main: to receives the result of the run on the Android Main/UI Thread.
● single: useful if you have multiple processes originating from different places
and want to merge them.
● custom: creates own custom scheduler with the help of Executor.

29. Perbandingan
RxJava Flow
Observable Types Observable, Flowable, Single, Maybe, Completable Flow (Only one)
Create Observable create, just, dll. flowOf
Get data subscribe collect
Context preservation subscribeOn, observeOn flowOn
Thread type Schedulers Dispatchers
Backpressure Manual By default handled by Flow
Request with Retrofit Need RxJava Adapter Can be used directly
Database with Room Need library Room RxJava Need library Room ktx
Lifecycle Management Using Disposable Using Scope

30. Kesimpulan
● RxJava dan Coroutine Flow memiliki kelebihan dan kekurangan dalam
implementasi terlebih dalam learning curve ketika adopsinya.
● Penggunaan tools tidak terlepas dari kebutuhan dan pemahaman yang
dimiliki kadang juga karena selera!
● Mempelajari dan memahami keduanya akan memperbanyak pilihan opsi
untuk penyelesaian masalah dengan tools yang tepat!
● Give it try and Enjoy!

31. Contact:
sidiq@nbs.co.id
THANKS!
Follow us: @dicoding