Why modern concurrency matters in Swift - See It in Action

Why Modern Concurrency Matters

📖 Scenario: Imagine you are building a simple app that fetches user data from the internet and then processes it. Without concurrency, the app waits for the data to load before doing anything else, making it slow and unresponsive. Modern concurrency helps your app stay fast and smooth by doing tasks at the same time.

🎯 Goal: You will create a Swift program that uses modern concurrency features to fetch and process user data asynchronously, showing why concurrency makes apps faster and more responsive.

📋 What You'll Learn

Create an array of user IDs

Create a delay time variable

Use async/await to fetch user data concurrently

Print the fetched user data

💡 Why This Matters

🌍 Real World

Modern apps often need to fetch data from the internet or perform tasks without freezing the screen. Using concurrency lets apps do many things at once, making them faster and smoother.

💼 Career

Understanding modern concurrency in Swift is essential for iOS developers to build responsive apps that handle network calls, animations, and user interactions efficiently.

1

Create an array of user IDs

Create a constant array called userIDs with these exact values: [101, 102, 103]

Swift

# Create a constant array called userIDs with values [101, 102, 103]
# Your code here

Hint

Use let to create a constant array named userIDs with the numbers 101, 102, and 103 inside square brackets.

2

Create a delay time variable

Create a constant called delaySeconds and set it to 2 to simulate network delay

Swift

let userIDs = [101, 102, 103]
# Create a constant delaySeconds and set it to 2
# Your code here

Hint

Use let delaySeconds = 2 to create a constant that holds the number 2.

3

Fetch user data concurrently using async/await

Write an async function called fetchUserData that takes an Int parameter userID and returns a String. Inside, use Task.sleep with delaySeconds to simulate delay, then return a string like "User data for ID \(userID)". Then, create an async function called loadAllUsers that uses await and async let to fetch data for all userIDs concurrently and collects the results into an array called results.

Swift

let userIDs = [101, 102, 103]
let delaySeconds = 2

// Write async function fetchUserData(userID: Int) -> String
// Write async function loadAllUsers() to fetch all user data concurrently
# Your code here

Hint

Use async and await keywords. Use Task.sleep to pause inside fetchUserData. Use async let to start multiple fetches at the same time.

4

Print the fetched user data

Call loadAllUsers() inside a Task and print each string in the returned array results on its own line

Swift

let userIDs = [101, 102, 103]
let delaySeconds = 2

func fetchUserData(userID: Int) async -> String {
    try? await Task.sleep(nanoseconds: UInt64(delaySeconds) * 1_000_000_000)
    return "User data for ID \(userID)"
}

func loadAllUsers() async -> [String] {
    async let first = fetchUserData(userID: userIDs[0])
    async let second = fetchUserData(userID: userIDs[1])
    async let third = fetchUserData(userID: userIDs[2])
    let results = await [first, second, third]
    return results
}

// Call loadAllUsers() inside Task and print each result
# Your code here

Hint

Use Task { ... } to run async code at the top level. Use a for loop to print each string in the results array.

Practice

1. What is the main benefit of using modern concurrency with async and await in Swift?

easy

A. It makes your app use more memory.

B. It allows your app to do many tasks at the same time without freezing.

C. It slows down your app to avoid errors.

D. It removes the need for functions.

Solution

1. Step 1: Understand what concurrency means

   Concurrency means doing multiple tasks at once, which helps apps stay responsive.

2. Step 2: Connect concurrency with async and await

   These keywords let Swift run tasks without waiting and freezing the app.

3. Final Answer:

   It allows your app to do many tasks at the same time without freezing. -> Option B

4. Quick Check:

   Modern concurrency = smooth multitasking [OK]

Hint: Remember: async/await = multitasking without freezing [OK]

Common Mistakes:

• Thinking concurrency slows the app down
• Confusing concurrency with more memory use
• Believing async/await removes functions

2. Which of the following is the correct way to declare an asynchronous function in Swift?

easy

A. func fetchData() async -> String

B. async func fetchData() -> String

C. func async fetchData() -> String

D. func fetchData() -> async String

Solution

1. Step 1: Recall Swift async function syntax

   In Swift, async comes after the function parentheses.

2. Step 2: Check each option's syntax

   Only func fetchData() async -> String places async correctly after the parentheses.

3. Final Answer:

   func fetchData() async -> String -> Option A

4. Quick Check:

   async keyword after () = correct syntax [OK]

Hint: Put async right after () in function declaration [OK]

Common Mistakes:

• Placing async before func
• Inserting async inside parameter list
• Putting async before return type

3. What will be printed by this Swift code using async/await?

func fetchNumber() async -> Int {
    return 10
}

Task {
    let number = await fetchNumber()
    print(number)
}

medium

A. Nothing prints

B. await fetchNumber()

C. Error: missing await

D. 10

Solution

1. Step 1: Understand async function behavior

   The function fetchNumber() returns 10 asynchronously.

2. Step 2: Check how Task and await work

   The Task runs the async code, and await waits for the result before printing.

3. Final Answer:

   10 -> Option D

4. Quick Check:

   await fetchNumber() returns 10 [OK]

Hint: await waits for async result before printing [OK]

Common Mistakes:

• Forgetting to use await
• Expecting print before result is ready
• Thinking async functions run instantly

4. Identify the error in this Swift async code:

func loadData() async -> String {
    return "Data"
}

func printData() {
    let result = await loadData()
    print(result)
}

medium

A. loadData should not be async

B. await cannot be used inside printData

C. Missing async keyword in printData function declaration

D. printData should return String

Solution

1. Step 1: Check where await is used

   The function printData() uses await inside its body.

2. Step 2: Confirm async requirement for await

   Any function using await must be marked async.

3. Final Answer:

   Missing async keyword in printData function declaration -> Option C

4. Quick Check:

   await requires async function [OK]

Hint: Add async to any function using await [OK]

Common Mistakes:

• Not marking function async when using await
• Thinking await can be used in normal functions
• Confusing async with return type

5. You want to fetch user data and user posts concurrently in Swift using async/await. Which approach best uses modern concurrency to improve speed?

hard

A. Use async let to start both fetchUser() and fetchPosts() at the same time, then await both results.

B. Run fetchUser() synchronously, then fetchPosts() asynchronously.

C. Call fetchUser() and fetchPosts() one after another with await each time.

D. Use DispatchQueue without async/await to run both tasks.

Solution

1. Step 1: Understand sequential vs concurrent calls

   Calling await one after another waits for the first to finish before starting the second.

2. Step 2: Use async let for concurrency

   Using async let starts both tasks simultaneously, improving speed.

3. Final Answer:

   Use async let to start both fetchUser() and fetchPosts() at the same time, then await both results. -> Option A

4. Quick Check:

   async let = concurrent tasks [OK]

Hint: Use async let to run tasks together, then await results [OK]

Common Mistakes:

• Awaiting tasks one by one causing delay
• Mixing synchronous and asynchronous calls incorrectly
• Using old concurrency methods instead of async/await