Reactive Programming

  1. Core Building Blocks
    1. The Observable (Stream)
      1. Definition and Purpose
        1. The Stream as a Timeline of Events
          1. Discrete Events
            1. Continuous Events
            2. Types of Events
              1. Next (Data Emission)
                1. Error (Termination)
                  1. Complete (Termination)
                  2. Observable Lifecycle
                    1. Creation
                      1. Factory Methods
                        1. Custom Observables
                        2. Subscription
                          1. Subscribing to Observables
                            1. Multiple Subscribers
                            2. Execution
                              1. Lazy Evaluation
                                1. Side Effects
                                2. Disposal (Unsubscription)
                                  1. Resource Cleanup
                                    1. Preventing Memory Leaks
                                3. The Observer (Subscriber)
                                  1. Role and Structure
                                    1. Handling onNext
                                      1. Processing Emitted Values
                                      2. Handling onError
                                        1. Error Propagation
                                          1. Error Recovery
                                          2. Handling onComplete
                                            1. Finalization Logic
                                          3. The Subscription
                                            1. Representing the Connection
                                              1. Managing Resources
                                                1. Automatic Unsubscription
                                                  1. Manual Unsubscription
                                                  2. The unsubscribe Method
                                                    1. Usage Patterns
                                                      1. Best Practices
                                                    2. Schedulers
                                                      1. Managing Concurrency and Threading
                                                        1. Purpose of Schedulers
                                                          1. Controlling Execution Context
                                                            1. Decoupling Producer and Consumer
                                                            2. Common Scheduler Types
                                                              1. Immediate/Trampoline
                                                                1. Synchronous Execution
                                                                2. IO-bound
                                                                  1. Asynchronous IO Operations
                                                                  2. Computation-bound
                                                                    1. CPU-intensive Tasks
                                                                    2. Main/UI Thread
                                                                      1. UI Updates
                                                                        1. Thread Safety

                                                                  Previous

                                                                  1. Introduction to Reactive Programming

                                                                  Go to top

                                                                  Next

                                                                  3. Operators: The Language of Streams