by Alberto Di Martino | Released April 2018 | ISBN: 9781789130829

Write reliable, scalable and high-performance code for asynchronous applications, with state of the art techniques and frameworks straight out of Silicon Valley.About This VideoThis video covers the core principles of reactive programming techniquesGet practical learning using real-world examplesExplore the advantage of using reactive programming for asynchronous computation compared to other techniquesIn DetailReactive programming has become a trend for software companies, especially if they have services used by thousands of users in the cloud. Using asynchronous computation when deploying into the cloud is a must-have, as companies are billed by the second for CPU power.As a developer, you can write asynchronous code, but scaling problems and keeping control of concurrency makes it very challenging. It reduces the complexity of writing async code by using the functional programming paradigm. This allows you to write code in a manageable way with a high level of abstractions, making nested callbacks a thing of the past.In this practical course, you'll first learn how to view problems in a reactive way, and then build programs that leverage the best features of this exciting new programming paradigm. You'll then begin with the general concepts of reactive programming and then gradually move on to working with asynchronous data streams. You'll dive into advanced techniques such as customizing operators and providers and see how to use the concurrency model to control the asynchronicity of code and process event handlers effectively. You'll also explore Coroutines, another exciting topic.By the end of this course, you'll be able to bring these reactive programming techniques into play by writing code with reduced complexity, a high level of abstraction, and increased efficiency.The code bundle for this video course is available at- https://github.com/PacktPublishing/Getting-Started-with-Reactive-Programming-with-Kotlin Show and hide more

1. Chapter 1 : Get Started with Reactive Programming and RxJava
   • The Course Overview 00:02:05
   • What Is and When We Need Reactive Programming? 00:01:58
   • Reactive Programming Versus Other Approaches 00:05:51
   • RxJava and Kotlin 00:02:28
   • Setting Up Our Environment 00:02:51
   • Our First Reactive Application 00:09:13
2. Chapter 2 : Dive into Observables and Operators
   • RxJava Flowable/Observable 00:02:34
   • Diving Deep into Other RxJava Types – Single, Maybe, and Completable 00:13:23
   • When to Use Single Versus Flowable? 00:03:08
   • Covering the Main Rx Operators – map, flatMap, and filter 00:06:30
   • Diving into Reactive Operators 00:08:56
3. Chapter 3 : Explore Schedulers – Enabling Multithreading in RxJava
   • Why Do We Need Schedulers? 00:03:30
   • What Is a Scheduler? 00:03:30
   • Executing Our First Asynchronous Flowable 00:10:24
   • Types of Schedulers and When to Use Them 00:04:30
4. Chapter 4 : Error Handling in RxJava
   • Exceptions in RxJava (onError) 00:03:26
   • Changing the Imperative try-catch Blocks 00:06:01
   • How to Continue Our Streams after Failures? 00:05:49
   • What to Do When Nothing Happens? 00:04:49
5. Chapter 5 : Reactive Programming with Coroutines
   • What Are Kotlin Coroutines? 00:03:43
   • Setting Up Our Environment 00:02:12
   • Playing with Kotlin Coroutines 00:08:13
   • Combining Coroutines with RxJava 00:05:10
Show and hide more