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.

RxJS Logo
Level.Intermediate
Duration.1-3 days

Get ready to step up your RxJS skills to the next level! This workshop is targeted at developers who want to step up their RxJS skills or want to learn RxJS entirely from scratch!

Understand everything: from core concepts, simple operators and the basic building blocks all the way to best practices, custom operators, higher order observables and marble testing.

Based on real-world examples, we will explore, evaluate, and use advanced RxJS techniques to develop sustainable solutions for complex use cases. Push your knowledge to the upper reaches and improve your ability to effectively handle tricky issues with RxJS.

Agenda

  • RxJS Logo

    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 Logo

    RxJS Core Concepts & Marble diagrams

    • RxJS learning tools

    • The concept of operators

    • How to read marble diagrams

    • Observable types

    • Operator types

  • RxJS Logo

    RxJS Operator Groups

    • Creation Operators

    • Join Creation Operators

    • Transformation Operators

    • Error Handling Operators

    • Filtering Operators

    • Multicasting Operators

    • Utility Operators

  • RxJS Logo

    Rate Limiting & Scheduling

    • Performance optimizations with rate limiting

    • Run smooth animations

    • Run processes in the background

  • RxJS Logo

    Multicasting

    • Hot vs Cold Observables

    • The misuse of share operators

    • Understand the difference between publish, connect & share

  • RxJS Logo

    Effective Error Handling with RxJS

    • Isolating error-prone code

    • Fully resilient error management

    • Retry on error

  • RxJS Logo

    Custom Operators

    • Limitations of using pipe

    • Leveraging the observable lifecycle hooks

    • Write custom operators

  • RxJS Logo

    Testing

    • Testing with async helpers

    • Virtualize time with Marble testing

    • Implement maintainable & readable asynchronous test cases

  • RxJS Logo

    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

Your trainers for this workshop