Dart Programming Language

  1. Asynchronous Programming
    1. Concurrency in Dart
      1. Single-Threaded Model
        1. The Event Loop
          1. Event Queue
            1. Microtask Queue
              1. Task Scheduling
              2. Non-Blocking Operations
              3. Futures
                1. Understanding `Future` Objects
                  1. Creating Futures
                    1. `Future.value`
                      1. `Future.error`
                        1. `Future.delayed`
                          1. `Completer` Class
                          2. Future States
                            1. Uncompleted
                              1. Completed with Value
                                1. Completed with Error
                                2. Handling Futures with `.then()`
                                  1. Handling Errors with `.catchError()`
                                    1. The `.whenComplete()` Method
                                      1. Chaining Futures
                                        1. Future Combinators
                                          1. `Future.wait`
                                            1. `Future.any`
                                          2. `async` and `await`
                                            1. Defining `async` Functions
                                              1. Using `await` to Get Future Results
                                                1. Error Handling with `try-catch` in `async` Functions
                                                  1. Returning Values from `async` Functions
                                                    1. Sequential vs Parallel Execution
                                                      1. Best Practices
                                                      2. Streams
                                                        1. Concept of Streams
                                                          1. Stream Types
                                                            1. Single-Subscription Streams
                                                              1. Broadcast Streams
                                                              2. Subscribing to a Stream (`listen`)
                                                                1. Stream Events
                                                                  1. Data Events
                                                                    1. Error Events
                                                                      1. Done Events
                                                                      2. Creating Streams
                                                                        1. `StreamController`
                                                                          1. `Stream.fromIterable`
                                                                            1. `Stream.periodic`
                                                                            2. Generating Streams with `async*` and `yield`
                                                                              1. Consuming Streams with `await for`
                                                                                1. Stream Transformation and Manipulation
                                                                                  1. `map`
                                                                                    1. `where`
                                                                                      1. `expand`
                                                                                        1. `take`
                                                                                          1. `skip`
                                                                                          2. Stream Subscription Management
                                                                                            1. Backpressure Handling
                                                                                            2. Isolates
                                                                                              1. Concept of Isolates
                                                                                                1. True Parallelism in Dart
                                                                                                  1. Spawning an Isolate
                                                                                                    1. `Isolate.spawn`
                                                                                                      1. `compute` Function
                                                                                                      2. Communication Between Isolates
                                                                                                        1. Send Ports
                                                                                                          1. Receive Ports
                                                                                                            1. Message Passing
                                                                                                            2. Isolate Lifecycle
                                                                                                              1. Use Cases for Isolates
                                                                                                                1. CPU-Intensive Tasks
                                                                                                                  1. Background Processing
                                                                                                                  2. Isolate Groups

                                                                                                                Previous

                                                                                                                5. Collections

                                                                                                                Go to top

                                                                                                                Next

                                                                                                                7. Error Handling and Exceptions