
## Day One

1. Introduction
   1. What is RxJS?
   2. What Does it Solve?
   3. Why use RxJS?
2. Observables
   1. From Promiseland
   2. To Observableland
   3. Exercise - Observables
   4. Solution - Observables
   5. New `Observable`
   6. Exercise - New Observable
   7. Solution - New Observable
3. Observer
   1. `Observer` Interface
   2. Next Notification
   3. Error Notification
   4. Complete Notification
   5. Exercise - Observer
   6. Solution - Observer
   7. Synchronous
   8. Asynchronous
4. Subscription
   1. `Subscription` Class
   2. Exercise - Subscription
   3. Solution - Subscription
   4. Unsubscribing
   5. Exercise - Unsubscribing
   6. Solution - Unsubscribing
5. Errors
   1. Errors in RxJS
   2. Emit Error Notification
   3. Exercise - Error
   4. Solution - Error
6. Operators
   1. The `pipe` method
   2. Pipeable Operators
   3. Exercise - Pipeable Operators
   4. Solution - Pipeable Operators
   5. Creation Operators
   6. Exercise - Creation Operators
   7. Solution - Creation Operators
   8. Filtering Operators
   9. Exercise - Filtering Operators
   10. Solution - Filtering Operators
   11. Transformation Operators
   12. Exercise - Transformation Operators
   13. Solution - Transformation Operators
   14. Mapping Operator Decision Tree
   15. Join Operators
   16. Exercise - Join Operators
   17. Solution - Join Operators


## Prereqs

Attendees should be familiar with the following technologies:

- JavaScript
- TypeScript

## Setup

There is no setup required for this workshop.
All content is available online, including exercises.


Joining more than one Observable together is a common practice for separate streams of data in an application. You'll know the 4 most common join operators and how to use them.

Joining operators

You'll also have a few utility operators at your disposal for those instances when you want to perform a side effect or ensure an Observable emits a next notification within a set period of time.

A few utility operators

You'll shift your approach from procedural to functional using streams of data and events with RxJS.

Understand the basics of reactive programming in JavaScript

At the heart of the RxJS library is the primitive Observable class. You'll learn what an Observable is, how to subscribe to an Observable, and how you can use the `pipe()` method for transforming notifications from an Observable.

Understand an Observable

A Subscription is created when an Observable is subscribed to. You'll learn the importance of unsubscribing, and how you can manage a collection of subscriptions.

Manage Subscriptions

You'll start to use operators and know how to use both pipeable and creation operators.

The world of operators

You'll know the 4 most common creation operators that can be used to create a new Observable.

Creating Observables

You'll know the 5 most common transformational operators, include the higher-order mapping operators. Most importantly, you'll have the knowledge to understand how the operators work and when to use which operator.

Transformation operators

You'll know the 8 most common filtering operators. Each filtering operator has a unique behavior that enables you to filter the stream of notifications from an Observable.

Filtering Operators

RxJS Fundamentals


## Day One

1. Subject
2. Recap `Observer`
   1. Observables are Unicast
   2. Exercise: Unicast
   3. Solution: Unicast
   4. Subjects are Multicast
   5. Exercise: Multicast
   6. Solution: Multicast
3. Multicasting Operators
   1. `multicast()` Operator
   2. Exercise: `multicast()` Operator
   3. Solution: `multicast()` Operator
   4. `refCount()` Operator
   5. Exercise: `refCount()` Operator
   6. Solution: `refCount()` Operator
   7. `publish()` Operator
   8. Exercise: `publish()` Operator
   9. Solution: `publish()` Operator
4. Subject Variants
   1. `AsyncSubject`
   2. Exercise: `AsyncSubject`
   3. Solution: `AsyncSubject`
   4. `BehaviorSubject`
   5. Exercise: `BehaviorSubject`
   6. Solution: `BehaviorSubject`
   7. `ReplaySubject`
   8. Exercise: `ReplaySubject`
   9. Solution: `ReplaySubject`
   10. `WebSocketSubject`
   11. Exercise: `WebSocketSubject`
   12. Solution: `WebSocketSubject`
5. Error Handling
   1. Error Notification
   2. Error Notification
   3. `throwError()` Operator
   4. Exercise: `throwError()` Operator
   5. Solution: `throwError()` Operator
   6. `catchError()` Operator
   7. Exercise: `catchError()` Operator
   8. Solution: `catchError()` Operator
   9. `finalize()` Operator
   10. Exercise: `finalize()` Operator
   11. Solution: `finalize()` Operator
   12. `retry()` Operator
   13. Exercise: `retry()` Operator
   14. Solution: `retry()` Operator
   15. `retryWhen()` Operator
   16. Exercise: `retryWhen()` Operator
   17. Solution: `retryWhen()` Operator
   18. `throwIfEmpty()` Operator
6. Custom Operators
   1. Higher Order Observables
   2. Exercise: Pipe Function
   3. Solution: Pipe Function
   4. Higher-order Function Operator
   5. Exercise: Higher-order Function Operator
   6. Solution: Higher-order Function Operator
7. Testing
   1. `TestScheduler`
   2. Marble Syntax
   3. Getting Started with Marble Tests
   4. Exercise: First Test
   5. Solution: First Test
   6. Exercise: Subscription
   7. Solution: Subscription
   8. Exercise: Error
   9. Solution: Error
   10. Flush
   11. Exercise: Test Custom Operator
   12. Solution: Test Custom Operator

## Prereqs

Students should be familiar with the following technologies:

- JavaScript
- RxJS Fundamentals


You already know what an Observable is and how to use. Now you'll know all the extending subjects from the Observable class, how each one behaves, and when to use a Subject.

Understand all classes in RxJS

It sounds a bit nuanced, but you'll be equipped with the knowledge to know why an Observable is unicast and the benefits of multicasting. You'll understand that multicasting can be important for the performance of your application.

Know the difference between unicasting and multicasting

You'll know how to create a multicasted Observable and how to manage reference counting.

How to create a multicasted Observable

There are 4 variants (and subclasses) of the Subject. You'll know what how each one behaves, when to use it, and how to wire up a WebSocket with RxJS.

Know all the variants of a Subject

Error handling is built into the core of Observables and RxJS. You'll be comfortable relying on Observables, and therefore RxJS, to provide the necessary guarantees to handle errors.

Trust RxJS to handle exceptions

You'll know what a higher-order Observable is and how to use the Pipe operator to create a custom operator, both using existing operators and building custom operators that do not use an existing operator.

Build custom operators

There is no need to write tests for RxJS itself. Trust us, it's already very well tested. But, you should write tests for custom operators. You'll know how to use the `TestScheduler` and marble syntax for asserting that your custom operators are behaving as expected.

Expert Led RxJS Workshops

RxJS Fundamentals

Advanced RxJS

Get Expert Led Training For Your Team