Search

You can now search through our archive !
Please specify a keyword

• Issue #418

  Fueled Reactive apps with Asynchronous Flow — Part 1

  Raul Hernandez Lopez prepares to migrate an RxJava + Java application to Kotlin + Coroutines/Flows. In this first part, he writes about the use case & migration strategy.
• Issue #415

  Android Unidirectional Data Flow — Kotlin Flow vs. RxJava

  Adam Hurwitz compares and contrasts implementing unidirectional data flow in RxJava vs Kotlin Coroutines' Flow.
• Issue #415

  Understanding RxJava Create and fromCallable Operator

  Amit Shekhar compares the RxJava Create and fromCallable operators to help understand when to use each on your use-case.
• Issue #413

  Kotlin Flow benefits over RxJava

  Antoni Castejón García is quite familiar with using RxJava for reactive flows, but has recently found benefits to using Kotling Coroutines' Flow instead.
• Issue #412

  Comparing Kotlin Coroutines with Callbacks and RxJava

  In this blog post, Lukas Lechner shows you code implementing a simple use case with coroutines, callbacks and RxJava so that you can compare them.
• Issue #400

  From RxJava to Kotlin Flow: Backpressure

  Vasya Drobushkov provides a quick comparison between backpressure solutions in RxJava and Kotlin Flow.
• Issue #398

  From RxJava 2 to Kotlin Flow: Threading

  In this article, Vasya Drobushkov gives a short recap on threading in RxJava 2 (with some basic caveats on its usage) and then takes a look at how threading works in Kotlin Flow.
• Issue #397

  RxJava to Coroutines: end-to-end feature migration

  In this article, Vadims Savjolovs guides you through the end-to-end feature migration from RxJava to coroutines.
• Issue #394

  What the Flow?

  Project Reactor and RxJava are two popular reactive libraries that allow you to program with asynchronous data streams. Shelby Cohen looks at how these libraries can be replaced, or used together with Kotlin's new Flow implementation.
• Issue #394

  rxbilling

  RxJava binding APIs for Google Play Billing.
• Issue #387

  RxRequester

  Simple & Clean RxJava requester for Android
• Issue #387

  Working with RxJava Disposables in Kotlin\

  In this tutorial, Lawrence Tan teaches the basics of RxJava Disposables. You will be building an app from scratch that retrieves real-time cryptocurrency data.
• Issue #386

  Operator fusion in RxJava 2

  In order to minimize overhead in RxJava, there are a number of optimizations, which are called “operator fusion”. Vasya Drobushkov talks about them in this article.
• Issue #383

  formula

  A functional reactive framework for managing state and side effects based on RxJava.
• Issue #382

  Chasing Swallowed Exceptions

  After a while, Ralf Wondratschek noticed suspicious stack traces in the error log for several tests. The stack traces looked like normal crashes as one would expect using RxJava, but the tests were successful nonetheless.
• Issue #378

  RxJava vs Kotlin Coroutines: A New Hope

  A presentation by Pamela Hill and Jacques Smuts at JavaConf Johannesburg 2019. They compare RxJava, Coroutines and Star Wars for Android Development.
• Issue #378

  Testing RxJava, Debugging and More

  Donn and Kaushik talk about testing RxJava streams with a Kotlin extension method and how and when to test various scenarios.
• Issue #373

  Improving RxJava stack traces with RxDogTag

  The RxDogTag library can make stack traces more useful, which provides for a more pleasant experience when debugging. Jamie Lynch shows you how to use it.
• Issue #369

  On Sale Now: Reactive Programming with Kotlin

  450+ pages of essential tutorial-style content to hone your reactive programming skills. Use RxJava to create complex reactive apps on Android and solve common application design issues by using RxJava, RxAndroid and RxKotlin. Reactive Programming with Kotlin is sale for the next 24 hours only!
• Issue #367

  I bet your RxJava is on the wrong thread

  Dionysis Lorentzos created some Rx puzzles to test how well you know RxJava's subscribeOn and observeOn. You will find all the answers at the bottom of the page.
• Issue #365

  A Short History of Android and Reactive Programming: Coroutines Edition

  Ash Davies provides an extensive overview of the history and appropriate use of Kotlin Coroutines vs RxJava.
• Issue #364

  RxJava Observable to Single – ProAndroidDev

  Vasya Drobushkov delves into the various strategies for converting Rx Observables to Single.
• Issue #362

  RxDogTag

  Automatic tagging of RxJava 2 originating subscribe points for onError() investigation
• Issue #360

  LiveDataReactiveStreams: Where RxJava meets LiveData

  In this post, Bryan Lindsey explores how LiveDataReactiveStreams works, as well why (or why not) you might want to use it to bring RxJava and LiveData together.
• Issue #357

  How to use WorkManager with RxJava

  In this article, Paulina Sadowska shows you how to use WorkManager with RxJava and what problems you may encounter.