Uses Angular 4 (formerly Angular 2) Learn RxJs, Observables + Build Angular Applications in Reactive Programming Style
- Know the core principles of RxJs and the Observable pattern
- Know how to build Applications in Angular in Reactive Style using RxJs and a Catalog of Reactive Patterns
- Angular (formerly known as Angular 2)
The course covers How To Build Angular Applications in Reactive Style using RxJs and the Observable Pattern, and its divided into two sections: the first is a deep dive into the Observable pattern as a way of understanding RxJs, and the second is a catalog of Angular Design Patterns that will allow us to build angular applications in Reactive Style.
Versions used: The code repository of this course uses the Angular 4 release, Typescript 2.2 and optionally the Yarn Package manager.
What is Your Biggest Difficulty While Learning Angular ?
RxJS and Reactive Programming can sometimes be seen as hard to get into. Although RxJs is optional in many parts of the Angular API and we can usually use Promises instead, one of the items of the Angular Project Roadmap is to allow to build reactive style applications, so clearly reactive programming is a topic that is close to the framework.
What is The Best Way To Learn RxJs ?
Why is RxJs and Reactive Programming sometimes seen as hard to get into ? The main reason for that could be that Observables and reactive programming are often presented as either a programming paradigm shift, an alternative to Promises or a generalization of functions, which are approaches that don’t help as much as we could think in the learning process.
We are going to take an alternative way for learning these concepts: we are going to see that RxJs and Observables are actually a very practical and effective solution to a very common set of problems that we face all the time while building asynchronous programs like user interfaces.
We are going to see that everything around RxJs and Reactive Programming revolves around one fundamental notion: The Observable Pattern.
The Best Way To Learn RxJs
We are going to approach reactive programming as a set of application development patterns, that are an evolution of previously existing solutions. So in the first section of the course we will cover the Observable pattern as a design solution for building asynchronous applications that scale well in complexity.
We are going to cover the multiple other satellite concepts around the Observable pattern, namely the Observer and the Subject, and we are also going to learn the benefits of writing applications in Reactive style by implementing our own simplified version of an event bus.
We are then going to see why that does not scale well in complexity, after that we will refactor the application into using the Observable pattern and see how it elegantly solves many of the problems of the initial implementation.
We will also introduce the Store Pattern, see how it relates to the Observable Pattern. At the of this section we will then introduce the RxJs library, which at this point will make a lot more sense given the previous presentation of the design patterns that its based upon.
What Patterns will be covered in this course ?
With the Observable pattern and its related concepts in place and having introduced the RxJs Library, we are going to see how it can be used to build Angular Applications in Reactive Style.
We are going to cover a set of reactive patterns for both the View Layer and the Service layer, by using a set of small applications with a ready to use backend built in either Firebase or a local HTTP server. The patterns will be introduced as either implementations from scratch of a given functionality, or via step-by-step refactorings.
The pattern catalog of the second part of the course will include: Stateless Observable Services, Smart vs Presentational Components, Observable Data Services, Nested Subscribe Anti-Pattern, Data Table Pagination, Local Services, Master Detail With Cached Master Table, Error Handling Components and Services, Router Data Pre-Fetching (with Loading Indicator), Container Components, Reactive Forms Draft Pre-Save.
This section also includes a couple of related discussions concerning application design, like how to avoid Event Bubbling over the local presentational component tree, and how to use deeply nested smart components with OnPush change detection.
What Will You Be Able To Do After Taking This Course ?
After taking this course you will be comfortable with Reactive Programming, the Observable Pattern and the RxJs library.
You will be able to reason much more easily about RxJs because you now know the fundamental concepts that it bases itself upon, as well as the design intentions behind it. You will be able to find your way around the documentation and know several commonly used operators. Most of all you know how to build Angular applications in Reactive Style using the RxJs library.
Content retrieved from: https://www.udemy.com/rxjs-reactive-angular-course/.