Gain insights into reactive programming with RxJS 7, explore data streams, error handling, and multicasting to build a recipe app, and learn to test and optimize reactive applications.

angular.tar.gz

angular04

angular05

angular06

coderun

angular04-copy

test

angular07

angular09

angular10

angular11

angular12

angular13

angular13-test

The reactive programming paradigm is designed to make working with asynchronous events and data streams convenient. 

This course teaches you about the reactive programming paradigm and when to choose it over others. You’ll learn to use new RxJS 7 features to create a recipe book web application that lets users browse and share recipes. In this context, you’ll learn about data streams, error handling, and how to combine streams and transform one data stream into another. You’ll develop an understanding of multicasting and caching streams, how to share data between components, perform bulk operations such as file uploads, and perform real-time updates. Finally, you’ll learn how to test a reactive application. To assess your knowledge, there’s a project, coding challenges, and assessments.

After this course, you’ll be able to determine the utility of the reactive paradigm for any application and have mastery over new RxJS 7 features to create robust reactive applications.

Reactive Programming with Angular and RxJS 7

#
Now that we've learned about the advantages of using RxJS in Angular and how it makes dealing with some concepts smoother, let’s explore the marble diagram, which is very handy for understanding and visualizing the observable execution.

RxJS ships with more than 100 operators. Operators are one of the building blocks of RxJS. They are very useful for manipulating streams. All the reactive patterns discussed in this course are based on operators. And when it comes to explaining operators, it's better to refer to a visual representation. And that's why there are marble diagrams, thankfully!

# What is a marble diagram?

A **marble diagram** is a visual representation of the operator's execution. We'll be using the marble diagram in all chapters to understand the behavior of RxJS operators. At first it might seem daunting, but it's delightfully simple. First, we only have to understand the anatomy of the diagram, and then we can read and translate it. We'll be able to understand any RxJS operator. So marble diagrams represent the execution of an operator.

## Components of marble diagrams

 Every marble diagram will include the following:


- **Input observable:** This represents one or many observables given as input to the operator.
- **Operator:** This represents the operator to be executed with its parameters.
- **Output observable:** This represents the observable produced after the
operator's execution.



Learn about the marble diagram, a great tool to understand the execution of RxJS operators.

The Marble Diagram—Our Secret Weapon

Getting Started

The Power of the Reactive Paradigm

RxJS 7—The Major Features

A Walk-Through of the Application

Fetching Data as Streams

Error Handling

Combining Streams

Assessment 1

Transforming Streams

Multicasting Essentials

Caching Streams

Sharing Data between Components

Bulk Operations

Processing Real-Time Updates

Testing RxJS Observables

Assessment 2

Conclusion

The Marble Diagram—Our Secret Weapon

What is a marble diagram?