Asynchronous Basics

Asynchronous Basics Interview with follow-up questions

1. What is asynchronous programming in Flutter?

Asynchronous programming lets your app start long-running work — network calls, file I/O, database queries — and keep the UI responsive instead of freezing while it waits. In Dart you express it with Future (a single eventual value), Stream (zero or more values over time), and the async/await syntax.

The crucial point interviewers want — and the one most people get wrong — is that async is not multithreading. Dart runs your code on a single thread per isolate with an event loop. await doesn't spin up a thread; it suspends the current function and lets the event loop run other work, then resumes when the awaited result is ready. The event loop drains two queues: the microtask queue (e.g. completed-future callbacks) which has priority, and the event queue (timers, I/O, gestures).

Future loadUser() async {
  final response = await http.get(uri); // suspends, UI stays responsive
  return User.fromJson(jsonDecode(response.body));
}

Follow-ups and gotchas:

  • Because it's single-threaded, CPU-bound work still blocks the UI even if marked async. Offload heavy computation to another isolate with compute() or Isolate.run().
  • Always handle errors (try/catch around await) — an unhandled async error can crash or be silently swallowed.
  • await only works inside an async function.
↑ Back to top

Follow-up 1

How does it differ from synchronous programming?

In synchronous programming, each task is executed one after the other, blocking the execution of subsequent tasks until the current task is completed. This means that if a task takes a long time to complete, the entire program will be blocked and unresponsive until that task finishes. On the other hand, asynchronous programming allows tasks to be executed concurrently, without blocking the main thread. This means that multiple tasks can be executed simultaneously, improving the overall performance and responsiveness of the application.

Follow-up 2

Can you give an example where asynchronous programming is beneficial?

One example where asynchronous programming is beneficial is when making network requests in Flutter. When you make a network request, it may take some time to receive a response from the server. If you were to make the request synchronously, the entire application would be blocked and unresponsive until the response is received. However, by using asynchronous programming, you can make the network request in the background, allowing the application to remain responsive and continue executing other tasks while waiting for the response.

Follow-up 3

What are the challenges in asynchronous programming?

Asynchronous programming can introduce some challenges, such as managing the order of execution, handling errors and exceptions, and coordinating the results of multiple asynchronous tasks. It requires careful handling of callbacks, futures, and streams to ensure that tasks are executed in the correct order and that errors are properly handled. Additionally, debugging asynchronous code can be more complex compared to synchronous code, as the flow of execution may not be linear.

Follow-up 4

How does Flutter handle these challenges?

Flutter provides a rich set of APIs and tools to handle the challenges of asynchronous programming. It offers built-in support for asynchronous operations through the use of futures and streams. Futures represent the result of an asynchronous operation that may complete with a value or an error. Streams, on the other hand, allow you to handle a sequence of asynchronous events. Flutter also provides various utility functions and classes to simplify working with asynchronous code, such as async/await syntax for writing asynchronous code in a more synchronous style, and the FutureBuilder and StreamBuilder widgets for easily updating the UI based on the result of asynchronous operations.

2. What is the role of the 'async' keyword in Flutter?

The async keyword marks a function as asynchronous. Two things happen when you add it:

  1. The function implicitly returns a Future (or a Stream, if you use async*). Even if you return 5;, callers receive a Future.
  2. Inside the function you may use await to suspend until a Future completes, then resume with its value — without blocking the thread.
Future fetchName() async {
  final response = await http.get(uri); // suspends here, thread free
  return response.body;                 // wrapped in a Future automatically
}

Interview follow-ups and gotchas:

  • async doesn't make code run in parallel or on another thread. Dart is single-threaded per isolate; async/await just lets the event loop interleave other work while one task waits. CPU-bound work still needs an isolate (compute/Isolate.run).
  • The function body runs synchronously up to the first await, then returns a Future to the caller. People are surprised that code before the first await executes immediately.
  • async/await doesn't catch errors by itself — wrap awaited calls in try/catch.
  • async* (with yield) produces a Stream; sync* (with yield) produces an Iterable.
↑ Back to top

Follow-up 1

Can you give an example of its usage?

Sure! Here's an example of a function that makes an asynchronous network request using the 'async' and 'await' keywords:

Future fetchData() async {
  // Simulate a network request
  await Future.delayed(Duration(seconds: 2));
  return 'Data fetched from the network';
}

void main() async {
  print('Fetching data...');
  String data = await fetchData();
  print('Data fetched: $data');
}

In this example, the 'fetchData' function is marked as 'async', allowing us to use the 'await' keyword to pause the execution of the function until the network request is complete. The 'main' function is also marked as 'async' to allow the use of 'await' when calling 'fetchData'.

Follow-up 2

What happens if we don't use the 'async' keyword where it's needed?

If we don't use the 'async' keyword where it's needed, we won't be able to use the 'await' keyword to pause the execution of the function. This means that the function will execute synchronously, blocking the UI and potentially causing the app to freeze or become unresponsive if the operation is time-consuming. It's important to use the 'async' keyword when performing asynchronous operations to ensure a smooth user experience.

Follow-up 3

Can 'async' be used with any function?

No, the 'async' keyword can only be used with functions that return a Future or Stream. This is because the 'await' keyword can only be used within an 'async' function to pause its execution until the awaited Future or Stream is complete. If a function doesn't return a Future or Stream, there is no need to use the 'async' keyword.

3. What is the 'await' keyword in Flutter?

await pauses an async function until the Future it's waiting on completes, then resumes with that future's value (or throws its error). It only works inside a function marked async.

Future load() async {
  final user = await fetchUser();   // resumes with the User
  print(user.name);                 // runs only after fetchUser completes
}

The key insight interviewers probe: await suspends, it does not block. The thread isn't frozen — control returns to the event loop, which keeps handling other tasks (UI, gestures, other futures); your function resumes later when the result is ready. That's why awaiting a network call doesn't jank the UI.

Follow-ups and gotchas:

  • await unwraps errors as exceptions, so wrap it in try/catch rather than using .catchError.
  • Sequential vs parallel: awaiting futures one by one runs them in series. To run independent futures concurrently, start them together and use await Future.wait([f1, f2]).
  • Context after await: in widgets, an await is an "async gap" — the widget may be unmounted when it resumes, so guard with if (!context.mounted) return; before touching BuildContext.
  • You can await any Future, including ones returned by other async functions.
↑ Back to top

Follow-up 1

How does it work in conjunction with 'async'?

When a function is marked with the 'async' keyword, it can contain one or more 'await' expressions. When an 'await' expression is encountered, the function pauses its execution and waits for the Future to complete. Once the Future completes, the function resumes its execution from where it left off.

Follow-up 2

What happens if we don't use the 'await' keyword where it's needed?

If the 'await' keyword is not used where it's needed, the code will continue to execute immediately without waiting for the Future to complete. This can lead to unexpected behavior or errors, especially if the subsequent code relies on the result of the Future.

Follow-up 3

Can 'await' be used without 'async'?

No, the 'await' keyword can only be used inside a function marked with the 'async' keyword. Attempting to use 'await' outside of an 'async' function will result in a compilation error.

4. What is the 'Future' class in Flutter?

A Future represents a value (of type T) that will be available later — the result of an asynchronous computation such as a network request, file read, or database query. It's Dart's promise of a single eventual result.

A Future is in one of these states:

  • Uncompleted — the work is still in progress.
  • Completed with a value — succeeded; you get a T.
  • Completed with an error — failed; it carries an error and stack trace.

You consume it with async/await (preferred) or the callback API:

Future answer = Future.delayed(const Duration(seconds: 1), () => 42);

final value = await answer;            // 42, after the delay
// or:
answer.then((v) => print(v)).catchError((e) => print('failed: $e'));

Interview follow-ups and gotchas:

  • Future vs Stream: a Future yields one value; a Stream yields zero or more over time. Don't reach for a Future when data arrives repeatedly.
  • It completes once — you can't reset or re-emit it.
  • Run concurrently with Future.wait([...]) rather than awaiting independent futures one after another.
  • A future is eager: the work starts when the future is created, not when you await it.
  • In Flutter, FutureBuilder rebuilds UI from a future's snapshot.
↑ Back to top

Follow-up 1

Can you give an example of its usage?

Sure! Here's an example of using 'Future' to fetch data from a network:

Future fetchData() async {
  // Simulate a network delay
  await Future.delayed(Duration(seconds: 2));
  return 'Data fetched from the network';
}

void main() {
  print('Fetching data...');
  fetchData().then((value) {
    print('Data received: $value');
  });
  print('Program continues...');
}

In this example, the 'fetchData' function returns a 'Future' object. The 'await' keyword is used to wait for the network delay, and then the function returns the fetched data. The 'then' method is used to handle the completed 'Future' and print the received data.

Follow-up 2

How does it relate to 'async' and 'await'?

The 'async' and 'await' keywords are used in conjunction with 'Future' to write asynchronous code in a more synchronous style. The 'async' keyword is used to mark a function as asynchronous, and the 'await' keyword is used to wait for a 'Future' to complete. By using 'async' and 'await', you can write asynchronous code that looks similar to synchronous code, making it easier to read and understand.

Follow-up 3

What are the common methods used with 'Future'?

Some of the common methods used with 'Future' are:

  • 'then': Used to handle the completed 'Future' by providing a callback function.
  • 'catchError': Used to handle errors thrown by the 'Future'.
  • 'whenComplete': Used to specify a callback function that will be called when the 'Future' completes, regardless of whether it completed with a value or an error.
  • 'timeout': Used to specify a duration after which the 'Future' should be considered as timed out if it hasn't completed yet.

These methods allow you to handle the different states of a 'Future' and perform actions accordingly.

5. How does error handling work in asynchronous programming in Flutter?

With async/await, an async error surfaces as a thrown exception, so the idiomatic approach is a plain try/catch (optionally finally for cleanup):

Future load() async {
  try {
    final user = await fetchUser();
    print(user.name);
  } on SocketException catch (e) {
    print('network error: $e');        // catch specific types first
  } catch (e, stackTrace) {
    print('failed: $e\n$stackTrace');  // catch-all with stack trace
  } finally {
    setLoading(false);
  }
}

For the callback style there's future.then(...).catchError(...), and .whenComplete(...) for finally-like cleanup — but prefer try/catch with await; mixing the two is a common source of swallowed errors.

Interview follow-ups and gotchas:

  • Streams report errors through the onError callback of listen, or via try/catch inside await for; one error doesn't necessarily end the stream (cancelOnError controls that).
  • Capture the stack trace — catch (e, st) — for useful logs.
  • Unawaited futures swallow errors: if you don't await (or attach catchError), the failure becomes an unhandled async error. Use unawaited() deliberately and still attach error handling.
  • For app-wide safety nets, runZonedGuarded / FlutterError.onError catch errors that escape.
↑ Back to top

Follow-up 1

What happens when an error occurs in an async function?

When an error occurs in an async function, the function stops executing and the error is propagated to the nearest error handler. If there is no error handler, the error will cause the application to crash.

Follow-up 2

How can we catch and handle these errors?

To catch and handle errors in async functions, we can use try-catch blocks. By wrapping the code that may throw an error in a try block, we can catch the error in the catch block and handle it accordingly.

Follow-up 3

Can you give an example?

Sure! Here's an example of catching and handling an error in an async function:

void fetchData() async {
  try {
    // Code that may throw an error
    var data = await fetchDataFromServer();
    print(data);
  } catch (e) {
    // Error handling
    print('An error occurred: $e');
  }
}

Live mock interview

Mock interview: Asynchronous Basics

Intermediate ~5 min Your own free AI key

Your voice and your AI key never touch our servers; the key stays in this browser and is sent only to Google. Only your round scores are saved to track progress.