RxJS Masterclass
This workshop is for developers who want to step up their RxJS skills! After exploring all core concepts and basic building blocks in great detail, we will explore advanced RxJS techniques to develop sustainable solutions for complex real world use cases.
Agenda
Understanding RxJS Primitives
Comparison of Subject and Observable
Converting other APIs (e.g. promise to observable)
Where and when to subscribe
Types of Subject: Subject vs. ReplaySubject vs. BehaviorSubject vs. AsyncSubject
Subscription Handling
RxJS Core Concepts & Marble diagrams
RxJS learning tools
The concept of operators
How to read marble diagrams
Observable types
Operator types
RxJS Operator Groups
Creation Operators
Join Creation Operators
Transformation Operators
Error Handling Operators
Filtering Operators
Multicasting Operators
Utility Operators
Rate Limiting & Scheduling
Performance optimizations with rate limiting
Run smooth animations
Run processes in the background
Multicasting
Hot vs Cold Observables
The misuse of share operators
Understand the difference between publish, connect & share
Effective Error Handling with RxJS
Isolating error-prone code
Fully resilient error management
Retry on error
Custom Operators
Limitations of using pipe
Leveraging the observable lifecycle hooks
Write custom operators
Testing
Testing with async helpers
Virtualize time with Marble testing
Implement maintainable & readable asynchronous test cases
Higher order composition
Understand higher order observables
Learn combination & flattening operators
Use “All” operators like mergeAll
Understand the power of groupBy
Description
Dive into the world of RxJS with our intensive workshop designed to equip you with all the necessary knowledge and tools to harness the power of reactive programming:
Understanding RxJS Primitives: Uncover the difference between Subject and Observable, convert Promise APIs to Observable, and learn about optimal subscribing strategies and the execution context of Observables.
Maintainable error handling and resilient data streams are a difficult but essential part of every vital application. The way we shape our state and the derived data streams is admittedly a matter of deep architecture knowledge, but also it involves dealing with the low-level problems of multicasting and shared state.
To ensure we are safe from regressions, different testing approaches should be employed. Therefore, we will take a closer look at those and implement marble tests to cover teardown logic and avoid memory leaks over tests.
Concepts & Marble Diagrams: Explore useful RxJS learning tools, understand how to read marble diagrams, and delve into various observable and operator types.
Operator Groups: Get hands-on with transform operators, learn about filtering, completion, error handling, and explore the top 4 flattening operators.
Subjects: Understand the producer-consumer pattern with Observers and Subscribers and explore the basic Subject types including Subject and BehaviorSubject.
Reactive Building Blocks: Discover how to manage state with streams, notify with events, and execute logic based on state or events. We'll also discuss the difference between RxJS and Signals.
Custom Sections: Get practical with live-coding sessions in our repositories and in-depth code reviews to refine your understanding and application of RxJS.
Jump in and start your journey into mastering reactive programming with RxJS today!
Takeaways
Understanding RxJS from scratch to expert level
Effectively handling errors across RxJS applications
Creating reusable custom operators beyond using
pipe
Testing approaches protecting a code base against regressions
Marble testing with RxJS
Multicasting operators in RxJS7
Advanced error handling
Error-prone code encapsulation
A deep dive into Subjects
Multicasting with observables
Understand combination & flattening Operators
Stateful reactive programming