RxJS: Reactive Programming in JavaScript

Learn reactive programming from the ground up with RxJS using practical examples.

Description

We expect our applications to be responsive, resilient, and robust. But how do we accomplish this? By leveraging reactive programming!

RxJS is the library for reactive programming in JavaScript. This course will teach you what it is and how to use it, all using the latest RxJS release and the TypeScript programming language.

You will first learn about the problem that RxJS is solving for you. Next, we will learn about observables, the most fundamental part of RxJS.

With that knowledge, you are ready to understand the concept of composing streams using operators. We are not focussing on memorizing the endless list of operators by heart but instead learning you will learn how to find the right operator for the job. You will even learn to implement your custom operator.

Then we will turn our focus on resiliency: how can we make our app fault-tolerant?-- You learn the different strategies for handling the errors and retrying them.

Finally, you will learn the notion of subjects and what problem they are trying to solve. We will look at several variants here, focusing on the BehaviorSubject, as we will be using that to implement a typical reactive pattern: a centralized store.

Subjects

1. Context
2. Observables
3. Operators
4. Error handling
5. Subjects

In this chapter, you will learn what where RxJS came from and what problem it is trying to solve.

• Learn the origin of Reactive Programming
• Know who is behind RxJS at the moment
• Understand which desing patterns relate to reactive programming.
• Learn the differences between a Promise and an Observable

In this chapter, you will learn what an Observable is and how it relates to "streams". We will be creating our own Observables and learn about creation operators.

• Learn what streams are and how to recognize them in your JS application.
• Learn how a stream relates to an Observable
• Know how to create our own Observables using the contructor.
• Learn some of the creation operators, like from and fromEvent, and use them to create Observables
• Know what the "Observable contract" is and what guarantees it brings.
• Know what an arrow function is and why we use them instead of methods.
• Implement HTTP calls using your own observables.

In this chapter you will learn what operators are and how to select the right operator for the job.

• Know why we use operators
• Learn to implement a reactive design.
• Learn what an operator is exactly.
• Learn some common operators like map, filter, switchMap, mergeMap and combineWithLatest
• Learn the different ways of implementing our own custom operators.
• Implement a search-as-you-type use case in an application where you combine everything you've learned.

In this chapter you will learn the different kinds of error handling strategies.

• Know what happens when we don't handle error.
• Learn 3 error handling strategies and how to implement them
• Implement your own retry mechanism.

In this chapter you will earn what a Subject is and when it is useful. You will end by learning a very common reactive pattern: the store pattern.

• Know what problem RxJS subjects solve.
• Learn what the different variants of subjects are.
• Focus on the BehaviorSubject as a way to hold our application's state
• Learn what a "Store pattern" is and how to implement it in a JS application.
• Implement your own store in a JS application using subjects.
• Implement a Router using RxJS observables and subjects.