Chapter 1, A Short Introduction to Reactive Programming, helps you understand the context, thinking pattern, and principles of reactive programming.

Chapter 2, Functional Programming with Kotlin and RxKotlin, chapter walks you through the essential concepts of functional programming paradigms and their possible implementations on Kotlin so that you can understand functional reactive programming easily.

Chapter 3, Observables, Observers, and Subjects, enables you to gain a grip on the base of RxKotlin—Observables, Observers, and Subjects lay at the core of RxKotlin.

Chapter 4, Introduction to Backpressure and Flowables, introduces you to Flowables, which enable you to use Backpressure—a technique in RxKotlin that prevents producers from outpacing consumers.

Chapter 5, Asynchronous Data Operators and Transformations, introduces you to operators in RxKotlin.

Chapter 6, More on Operators and Error Handling, gets your grip stronger on operators, and introduces how to combine producers and how to filter them with operators. This chapter will also help you handle errors more efficiently in RxKotlin.

Chapter 7, Concurrency and Parallel Processing in RxKotlin with Schedulers, enables you to leverage the benefits of Schedulers to achieve concurrent programming.

Chapter 8, Testing RxKotlin Applications, walks you through the most crucial part of application development—testing—which is a bit different in RxKotlin as reactive programming defines behaviors instead of states. This chapter starts with the basics of testing, enabling you to learn testing from scratch.

Chapter 9, Resource Management and Extending RxKotlin, helps you learn how to manage resources in Kotlin—resources could be database instances, files, HTTP accesses, or anything that needs to be closed. You will also learn how to create your own custom operators in RxKotlin in this chapter.

Chapter 10, Introduction to Web Programming with Spring for Kotlin Developers, gets you started with Spring and Hibernate so that you can leverage its benefits while writing APIs in Kotlin.

Chapter 11, REST APIs with Spring JPA and Hibernate, introduces you to the Reactor framework, the reactor-kotlin extension, so that you can apply reactive programming with Spring in Kotlin.

Chapter 12, Reactive Kotlin and Android, the last chapter of this book, gets you started with reactive programming in Android with Kotlin.

We will be using Java 8 and Kotlin 1.1.50 for the programs in this book, so Oracle's JDK 1.8 along with Kotlin 1.1.50 (this can be skipped downloading if you're using IntelliJ IDEA) will be required. You will need an environment to write and compile your Kotlin code (I strongly recommend Intellij IDEA, but you can use anything of your choice), and preferably a build automation system such as Gradle or Maven. Later in this book, we will use Android Studio (2.3.3 or 3.0). Everything you need in this book should be free to use and not require commercial or personal licensing (we are using the IntelliJ IDEA Community Edition).

This book is for Kotlin developers who would like to build fault-tolerant, scalable, and distributed systems. A basic knowledge of Kotlin is required; however, no prior knowledge of reactive programming is assumed.

In this book, you will find a number of text styles that distinguish between different kinds of information. Here are some examples of these styles and an explanation of their meaning.

Code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles are shown as follows: "Let's first take a look at the init block of the ReactiveCalculator class"

A block of code is set as follows:

   async(CommonPool) { 
        Observable.range(1, 10) 
          .subscribeOn(Schedulers.trampoline())//(1) 
          .subscribe { 
              runBlocking { delay(200) } 
              println("Observable1 Item Received $it") 
          } 
 

When we wish to draw your attention to a particular part of a code block, the relevant lines or items are set in bold:

abstract class BaseActivity : AppCompatActivity() { 
       final override fun onCreate(savedInstanceState: Bundle?) { 
         super.onCreate(savedInstanceState) 
         onCreateBaseActivity(savedInstanceState) 
        } 
        abstract fun onCreateBaseActivity(savedInstanceState: Bundle?) 
       } 

Any command-line input or output is written as follows. The input command might be broken into several lines to aid readability, but needs to be entered as one continuous line in the prompt:

$ git clone https://github.com/ReactiveX/RxKotlin.git$ cd RxKotlin/$ ./gradlew build

New terms and important words are shown in bold.  Words that you see on the screen, for example, in menus or dialog boxes, appear in the text like this: "Go to Android Studio | Settings | Plugins."

Feedback from our readers is always welcome. Let us know what you think about this book—what you liked or disliked. Reader feedback is important for us as it helps us develop titles that you will really get the most out of.

To send us general feedback, simply e-mail [email protected], and mention the book's title in the subject of your message.

If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, see our author guide at www.packtpub.com/authors.

Now that you are the proud owner of a Packt book, we have a number of things to help you to get the most from your purchase.