ReactiveX and RxJava address many problems that programmers face daily, allowing them to express business logic and spend less time engineering code. Have you ever struggled with concurrency, event handling, obsolete data states, and exception recovery? What about making your code more maintainable, reusable, and evolvable so it can keep up with your business? It might be presumptuous to call reactive programming a silver bullet that eliminates these problems, but it certainly is a progressive leap toward addressing them.

There is also a growing user demand to make applications responsive in real time. Reactive programming allows you to quickly analyze and work with live data sources such as Twitter feeds or stock prices. It can also cancel and redirect work, scale with concurrency, and cope with rapidly emitting data. Composing events and data as streams that can be mixed, merged, filtered, split, and transformed opens up radically effective ways to compose and evolve the code.

In summary, reactive programming makes many hard programming tasks easy, enabling you to add value in ways you might have thought impractical earlier. If you have a process written reactively and you discover that you need to run part of it on a different thread, you can implement this change in a matter of seconds. If you find network connectivity issues crashing your application intermittently, you can gracefully use reactive recovery strategies that wait and try again. If you need to inject another operation in the middle of your process, it is as simple as inserting a new operator.

Reactive programming models data/event processing as a modular chain of links that can be added or removed quickly. Such a chain is also called a processing chain or processing pipeline. In essence, RxJava allows applications to be tactical and evolvable while maintaining stability in production.

As stated earlier, RxJava is the ReactiveX port for Java. In this book, we will focus primarily on RxJava 3.0, but we will highlight the significant differences between RxJava 1.x, 2.x, and 3.0 where they exist. We will place a priority on learning to think reactively and leverage the practical features of RxJava. Starting with a high-level understanding, we will gradually move deeper into how RxJava works. Along the way, you will learn about reactive patterns and tricks to solve common problems that programmers encounter.

We will cover core Rx concepts and the three core entities of RxJava: Observable, Observer, and Operator. You will start writing reactive programs immediately and will acquire a solid foundation to build upon throughout the rest of the book. Then, we will explore more of the nuances of RxJava and how to effectively leverage concurrency. You will also learn the different ways to deal with reactive streams that produce data/events faster than they can be consumed.

Finally, we will touch on several miscellaneous but essential topics, including custom operators, as well as how to use RxJava with testing frameworks, Android, and the Kotlin language.