Why async/await simplifies concurrent code in iOS Swift - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding async/await benefits

Which of the following best explains why async/await makes concurrent code easier to write and read in Swift?

A It replaces all functions with blocking calls to simplify logic.

B It automatically parallelizes all code without developer control.

C It allows writing asynchronous code that looks like normal sequential code, avoiding nested callbacks.

D It forces all code to run on the main thread, preventing concurrency issues.

💡 Hint

Think about how async/await changes the way you write asynchronous code compared to completion handlers.

Async/await lets you write asynchronous code in a style that looks like normal, linear code. This avoids deeply nested callbacks and makes the code easier to understand and maintain.

❓ ui_behavior

intermediate

Async function UI update behavior

Consider this Swift async function that fetches data and updates a label. What happens to the UI while the data is loading?

iOS Swift

func loadData() async {
  let data = await fetchData()
  DispatchQueue.main.async {
    label.text = data
  }
}

A The UI remains responsive and updates the label after data loads.

B The UI freezes until fetchData() completes.

C The label updates immediately with empty text and then changes after loading.

D The app crashes because UI updates must be on the main thread.

💡 Hint

Async functions suspend without blocking the main thread.

Using async/await suspends the function without blocking the main thread, so the UI stays responsive. After data loads, the label updates on the main thread.

❓ lifecycle

advanced

Async/await and task cancellation

What happens if a Swift async task is cancelled while awaiting a long-running operation?

iOS Swift

Task {
  try Task.checkCancellation()
  let result = await longRunningOperation()
  print(result)
}

A The task ignores cancellation and completes normally.

B The task throws a CancellationError and stops execution immediately.

C The task crashes the app due to unhandled cancellation.

D The task restarts the longRunningOperation automatically.

💡 Hint

Check how Swift handles cancellation in async tasks.

When a task is cancelled, calling Task.checkCancellation() throws a CancellationError, stopping the task's execution cleanly.

❓ navigation

advanced

Async/await impact on navigation flow

In a SwiftUI app, how does using async/await inside a button action affect navigation transitions?

iOS Swift

Button("Load") {
  Task {
    await loadData()
    navigationPath.append("DetailView")
  }
}

A Navigation happens only after loadData() completes, ensuring data is ready.

B Navigation happens immediately, before loadData() finishes.

C Navigation never happens because async code blocks UI updates.

D Navigation causes a deadlock due to awaiting inside the button action.

💡 Hint

Async/await lets you wait for data before changing navigation state.

Using await inside Task suspends until loadData() finishes, so navigation happens after data is ready, improving user experience.

🔧 Debug

expert

Diagnosing async/await deadlock

What is the cause of this Swift code deadlocking the UI?

iOS Swift

func fetchData() async -> String {
  // Simulate network delay
  try? await Task.sleep(nanoseconds: 1_000_000_000)
  return "Data"
}

func load() {
  let data = try! await fetchData()
  print(data)
}

// Called from main thread
load()

A Using try! causes a runtime error if fetchData throws.

B Task.sleep causes the app to crash due to invalid nanoseconds value.

C The print statement is outside the async context causing a compile error.

D Calling await fetchData() directly from a synchronous function blocks the main thread causing deadlock.

💡 Hint

Check how async functions must be called from async contexts.

Awaiting an async function directly inside a synchronous function blocks the main thread, causing a deadlock because the async code cannot resume.