Subtotal 0,00 د.إ Subtotal: 0,00 د.إ
WHY ASYNC
Why Async Matters More Than Ever
Modern software waits. It waits for network responses, database queries, file reads, user input. How your language handles that waiting determines whether your app is silky smooth or frustratingly laggy.
Dart was designed from the ground up for asynchronous programming. It’s not bolted on like JavaScript’s Promises were — it’s woven into the language’s DNA through `Future`, `Stream`, `async/await`, and `Isolate`. And in 2027, with AI-native apps making concurrent API calls and processing real-time streams, understanding Dart’s async model deeply is non-negotiable.
Let’s go beyond the basics.
FUTURES
Under the HoodFutures and async/await
The Surface Level
Most developers learn `async/await` as syntactic sugar:
Future<String> fetchUsername(String userId) async {
final response = await http.get(Uri.parse('/users/$userId'));
return response.body;
}Clean. Readable. Works.
What's Actually Happening
Use `@db.VarChar(255)` and `@db.Text` to control MySQL column types explicitly. Without them, Prisma uses sensible defaults, but explicit types give you full control.
A common mistake — running async calls sequentially when they could run concurrently:
// Sequential — total time: 2s + 3s = 5s
Future<void> slowApproach() async {
final user = await fetchUser(); // 2 seconds
final posts = await fetchPosts(); // 3 seconds
// Total: 5 seconds
}
// Concurrent — total time: max(2s, 3s) = 3s
Future<void> fastApproach() async {
final [user, posts] = await Future.wait([
fetchUser(),
fetchPosts(),
]);
// Total: 3 seconds
}`Future.wait` is one of the most performance-impactful patterns you can apply in a real app.
STREAMS
The River of DataStreams
Single-Subscription vs Broadcast
A Stream is a sequence of asynchronous events. Dart has two types:
Single-subscription streams — like a water pipe. One listener. Once you’re done, it’s done. Used for: file reads, HTTP responses.
Broadcast streams — like a radio signal. Many listeners. Used for: user events, WebSockets, real-time data.
// Single-subscription (default):
Stream<int> countDown(int from) async* {
for (int i = from; i >= 0; i--) {
yield i;
await Future.delayed(const Duration(seconds: 1));
}
}
// Broadcast stream — multiple listeners can subscribe:
final controller = StreamController<String>.broadcast();
controller.stream.listen((msg) => print('Listener 1: $msg'));
controller.stream.listen((msg) => print('Listener 2: $msg'));
controller.add('Hello!');
// Both listeners receive "Hello!"Transforming Streams
The real power of Streams is their composability:
Stream<Stock> priceStream = getStockPrices();
priceStream
.where((stock) => stock.symbol == 'AAPL') // Filter
.map((stock) => stock.price) // Transform
.distinct() // Remove duplicates
.throttle(const Duration(milliseconds: 500)) // Rate limit
.listen((price) => updateUI(price));This is declarative, readable, and powerful. In Flutter, `StreamBuilder` consumes streams reactively to rebuild UI.
ISOLATES
True ParallelismIsolates
The Problem Dart Isolates Solve
Dart’s event loop runs on a single thread. For CPU-intensive work — image processing, JSON parsing of huge payloads, ML inference — blocking the event loop means a frozen UI.
Isolates are Dart’s solution: true parallel execution in separate memory spaces.
import 'dart:isolate';
// Compute-heavy work runs in its own Isolate — never freezes UI
Future<List<int>> sortHeavyData(List<int> data) async {
return await Isolate.run(() {
final sorted = List<int>.from(data)..sort(); // Runs in parallel
return sorted;
});
}
// In Flutter, use compute() for the same result with cleaner API:
final sorted = await compute(heavySortFunction, myList);Key insight: Isolates don’t share memory. They communicate via messages — this eliminates entire classes of concurrency bugs (race conditions, deadlocks) that plague multi-threaded languages.
“Dart’s isolates give you true parallelism without the nightmares of shared mutable state.”
Dart Documentation, Concurrency in Dart
When to Use Isolates
Use Isolates when a single task takes more than ~16ms (one frame budget). Common cases:
- Parsing large JSON responses
- Image manipulation / filters
- Cryptographic operations
- ML model inference
CONCURRENCY
Structured Concurrency Patterns
The Problem with Loose async Code
Without structure, async code becomes a web of floating Futures that are hard to cancel, hard to test, and easy to leak:
// Unstructured — what if the widget disposes? The Future keeps running!
void initState() {
super.initState();
loadData(); // Fire and forget — dangerous!
}Pattern 1: Cancellable Operations
class DataLoader {
bool _disposed = false;
Future<void> load() async {
final data = await fetchExpensiveData();
if (_disposed) return; // Guard against widget disposal
updateUI(data);
}
void dispose() => _disposed = true;
}Pattern 2: Timeout and Retry
Future<T> withRetry<T>(
Future<T> Function() operation, {
int maxAttempts = 3,
Duration timeout = const Duration(seconds: 10),
}) async {
for (int attempt = 1; attempt <= maxAttempts; attempt++) {
try {
return await operation().timeout(timeout);
} on TimeoutException {
if (attempt == maxAttempts) rethrow;
await Future.delayed(Duration(seconds: attempt)); // Exponential backoff
}
}
throw StateError('Should never reach here');
}
// Usage:
final user = await withRetry(() => fetchUser(id));ERROR HANDLING
Error Handling in Async Code
Async error handling in Dart is one of the most underappreciated topics. Errors in async code that aren’t caught can silently disappear — or worse, crash your app in unexpected places.
The Fundamental Rule
Always handle Future errors. Either with `try/catch` inside `async` functions, or with `.catchError()` on the Future chain.
// Clean async error handling with typed exceptions
Future<User> safeGetUser(String id) async {
try {
return await userRepository.getUser(id);
} on NotFoundException {
throw UserNotFoundError(id);
} on NetworkException catch (e) {
throw ServiceUnavailableError('Network failed: $e');
}
// Note: other exceptions bubble up naturally
}
// Zone-level error handling — catch unhandled async errors globally
runZonedGuarded(
() => runApp(const MyApp()),
(error, stackTrace) {
crashReporter.report(error, stackTrace);
},
);Stream Error Handling
// Always handle onError in stream subscriptions
myStream.listen(
(event) => processEvent(event),
onError: (error, stackTrace) {
logger.error('Stream error', error, stackTrace);
},
onDone: () => print('Stream completed'),
cancelOnError: false, // Keep listening after errors
);Dart’s async model is thoughtfully designed. The event loop gives you responsive apps. Streams give you reactive data flows. Isolates give you real parallelism without the complexity of mutexes and locks. Master these three, and you’ll build apps that are fast, responsive, and correct.
"Concurrency is not parallelism. Concurrency is the composition of independently executing processes. Parallelism is the simultaneous execution of computations."
Rob Pike, co-creator of Go
Explore project snapshots or discuss custom web solutions.
The art of programming is the art of organizing complexity.
Edsger W. Dijkstra,
A Discipline of Programming (1976)
FAQ's
Frequently Asked Questions
A Future represents a single async value (like a Promise in JS). A Stream represents a sequence of async values over time (like an Observable)
Use `async/await` for I/O-bound operations (network, file, database). Use Isolates for CPU-bound operations (sorting large lists, image processing, ML inference).
Through `ReceivePort` and `SendPort` — message passing. Since Isolates don't share memory, messages are either primitive types or deeply copied. Dart 3.x added support for sharing immutable data across isolates more efficiently.
The surface syntax (`async/await`) is similar, but Dart's microtask queue and event loop have slightly different priorities than JavaScript's. Dart's Isolates also provide true parallelism — something JavaScript's Web Workers approximate but don't match.
Always cancel `StreamSubscription` objects in `dispose()`. Better yet, use `StreamBuilder` widgets — they handle subscription lifecycle automatically.
Blogs
Comments are closed