Search

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

• Issue #194

  RxJava - Maximizing Parallelization

  Thomas Nield's post focuses on computation parallelization where you really have to constrain the number of threads you use.
• Issue #194

  RxAndroid Basics: Part 1

  Kurtis Nusbaum explains some basic concepts of RxJava on Android.
• Issue #192

  A MVP Approach to Lifecycle Safe Requests with RxJava

  This post sheds some light on a networking architecture that can fit easily into the MVP pattern while also allowing our network requests to live beyond the life of an activity/fragment with very little effort
• Issue #192

  RxJava- Understanding observeOn() and subscribeOn()

  Thomas Nield takes a hand-on approach to understand observeOn() and subscribeOn().
• Issue #192

  Using Kotlin Extensions for Rx-ifying

  One of the main features of Kotlin that Vishnu Rajeevan fallen in love with is class extensions. This feature comes in handy quite often when working with APIs that are not yet RxJava compatible in a project that is using RxJava extensively.
• Issue #191

  Kotlin + RxJava = Functional Powerhouse

  Thomas Nield shares his experience using RxJava with Kotlin. He found RxJava works better with Kotlin than Java itself; it just expresses functional programming concepts so much better.
• Issue #191

  Use RxJava instead of Event Bus libraries

  This post explains why you should favour RxJava over event busses like Otto.
• Issue #190

  Server polling and retrying failed operations. With Retrofit and RxJava

  A very common case in developing rest application is server polling and retry. Danylo Volokh decided to write about that after he implemented server polling correctly with RxJava and Retrofit.
• Issue #190

  RxJava's repeatWhen and retryWhen

  repeatWhen and retryWhen are fairly baffling at first glance: they allow you to conditionally resubscribe to Observables that have terminated. Dan Lew recently studied how they worked and I want to try to explain them.
• Issue #188

  Metronome: Unit-Tested Rx-Based Reference Application

  Several months ago, as a way to get up to speed with using and unit-testing RxJava, Cain Wong developed and posted this reference application. This blog post describes the project.
• Issue #187

  Subscribe It While It's Hot: Cached Rest Requests With RxJava

  Here's an RxJava-based approach to loading cached data vs loading from a REST endpoint.
• Issue #186

  RxRelay

  Relays are RxJava types which are both an Observable and an Action1. Basically it's a Subject except without the ability to call onComplete or onError.
• Issue #184

  Android Developer @ Trello

  We have big plans for Trello and are looking for brilliant developers to help us. If you're a RxJava addict with experience making highly interactive applications, come join us!
• Issue #184

  How to think about Subjects in RxJava (Part 1)

  Kaushik Gopal starts a series of articles on the black magic of Rx Subjects.
• Issue #183

  Advanced RxJava: The new Completable API (part 1)

  David Karnok looks at the new and mysterious rx.Completable class. It has been merged into the 1.x branch (in @Experimental fashion) and will most likely be part of RxJava 1.1.1.
• Issue #182

  Android Application Architecture

  A nice journey from standard Activities and AsyncTasks to a modern MVP-based architecture powered by RxJava.
• Issue #180

  RxJava Operators - toList()

  Thomas Nield take a look at the Observable.toList() operator.
• Issue #180

  Improving UX with RxJava

  Here's an article on how to carefully use RxJava to handle events from your UI.
• Issue #179

  RxJava's Side Effect Methods

  RxJava’s Observable class has plenty of methods that can be used to transform the stream of emitted items. But there are other methods that do not change the stream of items in any way.
• Issue #179

  Get Reactive

  Wolfram Rittmeyer and Pascal Welsch get reactive with a presentation on RxJava for Android.
• Issue #178

  Frodo

  Frodo is an android library used for logging RxJava Observables and Subscribers outputs on the logcat.
• Issue #178

  Debugging RxJava on Android

  Fernando Cejas walks you through the way he debugs RxJava Observables and Subscribers.
• Issue #177

  Getting Started with RxJava and Android

  ReactiveX is an API that focuses on asynchronous composition and manipulation of observable streams of data or events by using a combination of the Observer pattern, Iterator pattern, and features of Functional Programming.
• Issue #177

  Get Reactive

  In these slides you will learn what RxJava is about, how to use it on Android and how RxAndroid can be used to build maintainable Android Apps from networking with Retrofit2 to UI with the new RxBinding and RxLifecycle libraries powered by MVP.
• Issue #176

  Advanced RxJava: ConnectableObservables (part 1)

  We learned about constructing cold (i.e., range) and hot observables (i.e., UnicastSubject) but nothing specific so far about how to convert between the two. Here's an article that describes the process.