Reactive programming with kotlin pdf

Reactive Programming with Kotlin

Reactive Programming with Kotlin Ray Wenderlich Book Details

Title: Reactive Programming with Kotlin
Author: Alex Sullivan
Publisher: Ray Wenderlich
Language: English
No. of pages: 831
Format: EPUB, Source code

Recently I bought a set of Android Bundle include 10 Books from Ray Wenderlich. As you can see in the image above, which includes Reactive Programming with Kotlin. And now I want to transfer it to you for $ 60 (10 books) Payment Via Paypal or Bitcoin, All books are the latest version and have full source code, I will share it for you for $ 60 Includes PDF, EPUB file and full source code, you can download on Google Drive. When any book have new version i will get it free for you.

List bundle 10 books: Android Bundle:

Please contact me by Email: truonghang0207@gmail.com.

Section I: Getting Started with RxJava – Reactive Programming with Kotlin

In this part of the book, you’re going to learn about the basics of RxJava. You are going to have a look at what kinds of asynchronous programming problems RxJava addresses, and what kind of solutions it offers.
Further, you will learn about the few basic classes that allow you to create and observe event sequences, which are the foundation of the Rx framework.

You are going to start slow by learning about the basics and a little bit of theory. Please don’t skip these chapters! This will allow you to make good progress in the following sections when things get more complex.

Chapter 1: Hello, RxJava!
Chapter 2: Observables
Chapter 3: Subjects
Chapter 4: Observables & Subjects in Practice

Section II: Operators & Best Practices

Operators are the building blocks of Rx, which you can use to transform, process, and react to events emitted by Observables.

Just as you can combine simple arithmetic operators like +, -, and / to create complex math expressions, you can chain and compose together Rx’s simple operators to express complex app logic.
In this chapter, you are going to:

Start by looking into filtering operators, which allow you to process some events but ignore others.
Move on to transforming operators, which allow you to create and express complex data transformations. You can for example start with a button event, transform that into some kind of input, process that and return some output to show in the app UI.

Look into combining operators, which allow for powerful composition of most other operators.
Explore operators that allow you to do time based processing: delaying events, grouping events over periods of time, and more. Work though all the chapters, and by the end of this section you’ll be able to write simple RxJava apps!

Chapter 5: Filtering Operators
Chapter 6: Filtering Operators in Practice
Chapter 7: Transforming Operators
Chapter 8: Transforming Operators in Practice
Chapter 9: Combining Operators
Chapter 10: Combining Operators in Practice
Chapter 11: Time-Based Operators

Section III: Intermediate RxJava

Once you start writing complete apps with RxJava, you will also need to take care of more intermediate topics than simply observing for events and processing them with Rx.

In a full production-quality app, you will need to build an error handling strategy, do more advanced multi-threading processing, create a solid test suite, and more.

In this part of the Reactive Programming with Kotlin book, you will work through five challenging chapters, which will lift your Rx status from a rookie level to a battle-tested warrior.

Chapter 12: Error Handling in Practice
Chapter 13: Intro to Schedulers
Chapter 14: Flowables & Backpressure
Chapter 15: Testing RxJava Code
Chapter 16: Creating Custom Reactive Extensions

Section IV: RxJava Community Cookbook

RxJava’s popularity keeps growing every day. Thanks to the friendly and creative community that formed around this library, a lot of community-driven Rx projects are being released on GitHub.

The advantage of the community-built libraries that use RxJava is that unlike the main repository, which needs to follow the Rx standard, these libraries can afford to experiment and explore different approaches, provide non multi-platform specializations, and more.

In this section you are going to look into just a few of the many community open source projects. The section contains four short cookbook-style chapters that look briefly into four community projects that help you with binding Android Views, talking to your server with Retrofit, persisting preferences data, and handling user permissions.

Chapter 17: RxBinding
Chapter 18: Retrofit
Chapter 19: RxPreferences
Chapter 20: RxPermissions

Section V: Putting It All Together

The “easy” part of the Reactive Programming with Kotlin book is over. If you made it this far and are looking to learn even more in order to start creating production apps with RxJava, this section is for you.

The two chapters in this section are going to help you learn how to build real-life applications with RxJava.
The first chapter will cover integrating RxJava with the components of Android Jetpack, in particular, the Room database library and the Paging library. The chapter will build off of knowledge you’ve gained earlier in the book working with the ViewModel and LiveData components of Jetpack.

The second chapter, and the last one in this Reactive Programming with Kotlin book, is going to show you how to setup a reactive application architecture and how to convert callbacks to Rx Observables.

Once you finish working through this section, you will be one of the top RxJava developers out there. There is, of“course, more to know about Rx but at this point you will be able to figure out things further on your own.
Also, don’t forget to give back to the community! It would not have been possible for us to put this book together without all the amazing Rx folks sharing their knowledge, code, and good vibes.

Chapter 21: RxJava & Jetpack
Chapter 22: Building a Complete RxJava App

Источник

Saved searches

Use saved searches to filter your results more quickly

You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session. You switched accounts on another tab or window. Reload to refresh your session.

Reactive Programmin in Kotlin, published by Packt

License

PacktPublishing/Reactive-Programming-in-Kotlin

This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?

Sign In Required

Please sign in to use Codespaces.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching Xcode

If nothing happens, download Xcode and try again.

Launching Visual Studio Code

Your codespace will open once ready.

There was a problem preparing your codespace, please try again.

Latest commit

Git stats

Files

Failed to load latest commit information.

README.md

Reactive Programming in Kotlin

This is the code repository for Reactive Programming in Kotlin, published by Packt. It contains all the supporting project files necessary to work through the book from start to finish.

In today’s app-driven era, when programs are asynchronous and responsiveness is so vital, reactive programming can help you write code that’s more reliable, easier to scale, and better-performing. Reactive programming is revolutionary. With this practical book, Kotlin developers will first learn how to view problems in the reactive way, and then build programs that leverage the best features of this exciting new programming paradigm.

Instructions and Navigation

All of the code is organized into folders. Each folder starts with a number followed by the application name. For example, Chapter02.

The code will look like the following:

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

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)

Click here if you have any feedback or suggestions.

If you have already purchased a print or Kindle version of this book, you can get a DRM-free PDF version at no cost.
Simply click on the link to claim your free PDF.

About

Reactive Programmin in Kotlin, published by Packt

Источник

Reactive Programming in Kotlin [PDF]

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 to test 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, get 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.

What you need for this book

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).

Who this book is for

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.

You can also get this PDF by using our Android Mobile App directly:

Share this:

Источник