Debugging memory leaks with Instruments in Swift - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a strong reference cycle that can cause a memory leak.

Swift

class Person {
    var name: String
    var apartment: Apartment? 
    init(name: String) {
        self.name = name
    }
}

class Apartment {
    var unit: String
    var tenant: Person? 
    init(unit: String) {
        self.unit = unit
    }
}

var john: Person? = Person(name: "John")
var unit4A: Apartment? = Apartment(unit: "4A")
john?.apartment = unit4A
unit4A?.tenant = [1]

Drag options to blanks, or click blank then click option'

Ajohn

Bunit4A

Cself

Dnil

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning the wrong variable to tenant, which does not create a cycle.

Using nil which breaks the reference.

Assigning john to unit4A?.tenant creates a strong reference cycle causing a memory leak.

2fill in blank

medium

Complete the code to break the strong reference cycle using a weak reference.

Swift

class Person {
    var name: String
    weak var apartment: [1]?
    init(name: String) {
        self.name = name
    }
}

Drag options to blanks, or click blank then click option'

AAnyObject

BPerson

CApartment

DString

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong class type for the weak reference.

Not using weak keyword causing the cycle to persist.

Declaring apartment as a weak reference to Apartment breaks the strong reference cycle.

3fill in blank

hard

Fix the error in the closure to avoid a memory leak by capturing self correctly.

Swift

class HTMLElement {
    let name: String
    let text: String?
    lazy var asHTML: () -> String = {
        [1] in
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }
    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }
}

Drag options to blanks, or click blank then click option'

Aself

B[weak self]

C[self]

D[unowned self]

Attempts:

3 left

💡 Hint

Common Mistakes

Not using a capture list causing a memory leak.

Using [self] which still strongly captures self.

Using [unowned self] in the closure capture list prevents a strong reference cycle by not strongly capturing self.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that filters and transforms data without causing memory leaks.

Swift

let words = ["apple", "bee", "cat", "dog"]
let filteredLengths = words.reduce(into: [:]) { dict, word in
    if word.count [1] 3 {
        dict[word.[2]()] = word.count
    }
}

Drag options to blanks, or click blank then click option'

A>

Blowercased

Cuppercased

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong comparison operator which filters incorrectly.

Using uppercased instead of lowercased causing inconsistent keys.

The code filters words with length greater than 3 and uses the lowercase version of the word as the key.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps uppercase keys to values filtered by a condition.

Swift

let data = ["a": 1, "b": 2, "c": 3, "d": 4]
let result = data.filter { $0.value [1] 2 }
                 .reduce(into: [:]) { dict, pair in
                     dict[[2]] = [3]
                 }

Drag options to blanks, or click blank then click option'

A<

Bpair.key.uppercased()

Cpair.value

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong comparison operator which filters incorrectly.

Assigning the wrong key or value in the dictionary.

The code filters entries with values greater than 2 and maps keys to uppercase with their values.

Practice

1. What is the main purpose of using Instruments to debug memory leaks in Swift apps?

easy

A. To check the app's network connections

B. To improve the app's user interface design

C. To write new Swift code faster

D. To find parts of the code where memory is not released properly

Solution

1. Step 1: Understand Instruments' role

   Instruments is a tool that helps find memory leaks by showing where memory is not freed.

2. Step 2: Identify the main goal

   The main goal is to find code parts causing memory leaks, not UI or network issues.

3. Final Answer:

   To find parts of the code where memory is not released properly -> Option D

4. Quick Check:

   Instruments finds memory leaks = A [OK]

Hint: Instruments shows where memory stays allocated [OK]

Common Mistakes:

• Thinking Instruments improves UI design
• Confusing memory leaks with network issues
• Believing Instruments helps write code faster

2. Which of the following is the correct way to start a memory leak analysis session in Instruments for a Swift app?

easy

A. Open Instruments, select the Leaks template, then run your app

B. Open Xcode, write code, then press Cmd+S

C. Use Terminal to run 'swift leak-check' command

D. Restart the device and open the app

Solution

1. Step 1: Know how to use Instruments

   Instruments has a Leaks template specifically for memory leak detection.

2. Step 2: Correct procedure

   You open Instruments, choose Leaks, then run your app to monitor memory usage.

3. Final Answer:

   Open Instruments, select the Leaks template, then run your app -> Option A

4. Quick Check:

   Start Instruments with Leaks template = D [OK]

Hint: Use Instruments Leaks template to start analysis [OK]

Common Mistakes:

• Trying to use a non-existent 'swift leak-check' command
• Confusing saving code with leak detection
• Restarting device does not start Instruments

3. Given this Instruments snapshot showing a persistent memory block, what does it most likely indicate?
Leaked Object: MyViewController
Size: 512 KB
Reference Count: 1

medium

A. MyViewController is properly released after use

B. MyViewController is still retained and causing a memory leak

C. The app is running out of CPU resources

D. The snapshot shows a network error

Solution

1. Step 1: Analyze the snapshot details

   The snapshot shows a leaked object with a reference count of 1, meaning it is still held in memory.

2. Step 2: Understand what a leak means

   If the object is not released when expected, it causes a memory leak.

3. Final Answer:

   MyViewController is still retained and causing a memory leak -> Option B

4. Quick Check:

   Leaked object with ref count 1 = A [OK]

Hint: Leaked object with ref count means memory not freed [OK]

Common Mistakes:

• Assuming ref count 1 means object is released
• Confusing memory leaks with CPU or network issues
• Ignoring the meaning of leaked objects in Instruments

4. You notice your Swift app leaks memory because a closure captures self strongly. How can you fix this leak?

medium

A. Remove the closure entirely

B. Increase the reference count of self inside the closure

C. Use [weak self] in the closure capture list

D. Call the closure on the main thread

Solution

1. Step 1: Identify the cause of the leak

   A closure capturing self strongly creates a retain cycle causing a memory leak.

2. Step 2: Apply weak capture to break retain cycle

   Using [weak self] in the closure capture list prevents strong reference cycles and fixes the leak.

3. Final Answer:

   Use [weak self] in the closure capture list -> Option C

4. Quick Check:

   Weak capture breaks retain cycles = B [OK]

Hint: Use [weak self] to avoid retain cycles in closures [OK]

Common Mistakes:

• Removing closure without replacing functionality
• Increasing reference count worsens leaks
• Thinking thread choice fixes memory leaks

5. You have a Swift app with multiple view controllers. Instruments shows a leak in a view controller that uses a delegate property declared as var delegate: MyDelegate?. What is the best way to fix this leak?

hard

A. Change the delegate property to weak var delegate: MyDelegate?

B. Make the delegate property a strong reference

C. Remove the delegate property completely

D. Assign delegate to nil only in deinit

Solution

1. Step 1: Understand delegate retain cycles

   Delegates should be weak to avoid retain cycles between view controllers and delegates.

2. Step 2: Fix the property declaration

   Changing delegate to weak breaks the strong reference cycle and prevents leaks.

3. Final Answer:

   Change the delegate property to weak var delegate: MyDelegate? -> Option A

4. Quick Check:

   Delegates must be weak to avoid leaks = C [OK]

Hint: Declare delegates as weak to prevent retain cycles [OK]

Common Mistakes:

• Making delegate strong causes leaks
• Removing delegate loses communication
• Only nil assignment in deinit does not fix leaks