Reactive Angular Course (with RxJs)
4.6 (1,790 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
9,546 students enrolled

Reactive Angular Course (with RxJs)

Build Angular Applications in Reactive style with plain RxJs - Patterns, Anti-Patterns, Lightweight State Management
4.6 (1,790 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
9,546 students enrolled
Last updated 6/2020
English [Auto], Portuguese [Auto], 1 more
  • Spanish [Auto]
Current price: $104.99 Original price: $149.99 Discount: 30% off
5 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 5.5 hours on-demand video
  • 2 articles
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • Code in Github repository with downloadable ZIP files per section
  • Learn Lightweight State Management techniques (RxJs only)
  • Understand the Core Principles of Reactive Programming in general
  • Know how to build Applications in Angular in Reactive Style using RxJs
  • Learn a Catalog of RxJs Application Design Patterns and Anti-Patterns
Course content
Expand all 41 lectures 05:34:55
+ Stateless Observables Services
7 lectures 01:08:15
Consuming Observable-based services using the Angular async Pipe
Avoiding Angular duplicate HTTP requests with the RxJs shareReplay operator
Angular view Layer Patterns - Smart vs Presentational Components
Data Modification Example in Reactive Style (Stateless Application)
+ Reactive Component Interaction
15 lectures 02:18:43
Reactive Component Interaction - Section Introduction
Decoupled component communication using a shared Service
Loading Service Reactive API Design
Reactive Component Interaction using Custom Observables and Behavior Subject
Loading Indication Service - Reactive Implementation Finished
Understanding the Angular Component providers property
Error Handling and the Messages Component
Error Handling with the catchError RxJs operator
Messages Service - Implementation Finished and Demo
Local Error Handling in an Angular Material Dialog
Angular State Management - When is it Needed and Why?
Initial Implementation of a Store Service
Step-by-Step Implementation of an Angular Store Service
Store Optimistic Data Modification Operations - API Design
Store Optimistic Data Modifications - Step-By-Step Implementation
+ Authentication State Management
4 lectures 30:27
Authentication State Management - Section Introduction
Authentication Store - Step-By-Step Implementation
Adapting the UI according to the user Authentication status
Authentication Store - Browser Refresh support with Local Storage
+ Master-Detail UI Pattern (with built-in State Management)
4 lectures 25:10
Master-Detail UI Pattern - Section Introduction
Angular Master Detail Implementation - The Master Table
Angular Master Detail Implementation - The Detail Element
Angular Master Detail Implementation - Final Demo
+ The Single Data Observable Pattern
5 lectures 38:04
Consolidation Exercise - Implementing the Course Screen in Reactive Style
Course Component Finished - Introduction to the Single Data Observable Pattern
Reactive Angular - The Single Data Observable Pattern
Single Data Observable Pattern - Default Data Values
Refactoring an Angular Reactive Application to OnPush Change Detection
+ Conclusions and Course Summary
3 lectures 18:21
Other Courses
Bonus Lecture: Learn More About The Angular University And My YouTube Channel
Conclusion & Key Takeaways
  • Angular (beginner level)
  • Typescript
  • Some basics of RxJs

This Course in a Nutshell

This course is a catalog of commonly used design patterns (and some anti-patterns) that every Angular developer should know. The goal of the course is to teach you how to comfortably design and develop applications in Angular in Reactive style using just plain RxJs, and nothing more.

This course comes with a running Github repository with the the finished code, as well as starting points for different sections of the course in case that you want to code along, which we recommend as its the best way to learn.

This course answers the common question: how far can we go in Angular while using only plain RxJs and nothing more, without introducing any state management library?

It turns out that the simple set of techniques taught in this course are very well suited for a wide range of applications, especially in-house built enterprise applications.

In this course, you will learn exactly how to use RxJs to design and develop both the service and the view layers of your application, and you will understand both the advantages and the pitfalls of the reactive approach.

Particularly when it comes to state management, it turns out that we can already go very far by leveraging only plain Angular and RxJs techniques, without using an additional state management library like for example NgRx.

These simplified state management techniques are adequate and sufficient for a large range of applications,  and we believe that you should consider them first before thinking of adopting a full-blown state management solution.

How far can you go with these techniques? That's what you will find out in this course.

Course Overview

We are going to start our course by taking a small Angular application that is written in imperative style, and we are going to talk about some of the problems of that approach. Then, we are going to refactor the application and explain step-by-step how to implement it in reactive style instead.

We will explain in detail every RxJs operator that we come across in this course, the first time that we need each operator.

We are going to start with a fully stateless solution first, but later we are going to improve the user experience by applying some simple RxJs-only state management techniques. We are going to use these patterns in order to handle some of the data of the application, as well as the user authentication profile.

The key element needed to implement lightweight state management is RxJs behavior subjects so we will cover those in detail in the course. We will also provide step-by-step reactive style solutions for common UI functionality like loading indicators or error messages.

Table of Contents

This course covers the following topics:

  • Review of an application written in imperative style

  • Refactoring into stateless reactive style, understanding the benefits

  • Smart vs Presentational Components

  • Stateless Observable Services

  • The shareReplay Operator

  • Stateless UI updates (without state management)

  • Introduction to RxJs Subjects and BehaviorSubject

  • Decoupled component communication using shared observable services

  • Using Observables to have components interact at different levels of the component tree

  • Error Handling and error messages in reactive style

  • Loading Indicators in reactive style

  • Improving user experience with lightweight RxJs stores

  • Optimistic UI updates

  • Managing User Authentication state with plain RxJs

  • Local vs Global Services

  • Master Detail with cached master table in reactive style

  • The Single Data Observable Pattern: Avoiding nested ng-component tags

  • Refactoring a reactive application to OnPush change detection

  • Conclusion and key takeaways

What Will You Learn In this Course?

At the end of the course, you will feel comfortable designing and developing Angular applications in reactive style, by leveraging plain RxJs-only techniques. You will know how to apply simplified reactive state management techniques to different common use cases, and you will understand the advantages and the limitations of this approach.

You will be familiar with a series of commonly needed reactive design patterns, and you will also be familiar with a series of common pitfalls to avoid.

Who this course is for:
  • Web developers looking to learn how to build Angular Applications in Reactive Style
  • Angular Developers looking to learn lightweight state management techniques (using RxJs only)