Ios Interview Prep

Interview Question: When would you choose a struct over a class?

• Structs for: Data models, coordinates, small objects, when you need copy semantics
• Classes for: Identity matters, inheritance needed, shared mutable state, Objective-C interop

Closures and Capture Lists

class DataManager {
    var data: [String] = []
    var onComplete: (() -> Void)?

    func fetchData() {
        // WRONG: Strong reference cycle
        networkCall {
            self.data = $0
            self.onComplete?()
        }

        // CORRECT: Weak capture
        networkCall { [weak self] result in
            guard let self else { return }
            self.data = result
            self.onComplete?()
        }
    }
}

Interview Question: Explain [weak self] vs [unowned self]

• weak: Optional reference, becomes nil when object deallocates (safe)
• unowned: Non-optional, crashes if object deallocates (use when you're certain about lifecycle)

2. Memory Management (ARC)

The Retain Cycle Problem

class Parent {
    var child: Child?
    deinit { print("Parent deallocated") }
}

class Child {
    var parent: Parent?  // Creates retain cycle!
    // Should be: weak var parent: Parent?
    deinit { print("Child deallocated") }
}

var parent: Parent? = Parent()
var child: Child? = Child()
parent?.child = child
child?.parent = parent

parent = nil  // Neither deallocates!
child = nil   // Memory leak

Common Interview Questions:

1. What causes a retain cycle? How do you detect them?
2. When does ARC insert retain/release calls?
3. How does autoreleasepool work?
4. What's the difference between strong, weak, and unowned?

3. Swift Concurrency (Modern)

Actors and Data Races

// Actor provides automatic synchronization
actor BankAccount {
    private var balance: Double = 0

    func deposit(_ amount: Double) {
        balance += amount
    }

    func withdraw(_ amount: Double) -> Bool {
        guard balance >= amount else { return false }
        balance -= amount
        return true
    }

    func getBalance() -> Double {
        return balance
    }
}

// Usage requires await at isolation boundary
let account = BankAccount()
await account.deposit(100)
let balance = await account.getBalance()

Interview Question: What problem do actors solve?

• Actors protect mutable state from data races
• All access to actor state is serialized
• The await keyword marks potential suspension points

Task Groups and Structured Concurrency

func fetchAllUsers() async throws -> [User] {
    let userIDs = ["1", "2", "3", "4", "5"]

    return try await withThrowingTaskGroup(of: User.self) { group in
        for id in userIDs {
            group.addTask {
                try await fetchUser(id: id)
            }
        }

        var users: [User] = []
        for try await user in group {
            users.append(user)
        }
        return users
    }
}

4. UIKit Fundamentals

View Controller Lifecycle

1. init(coder:) or init(nibName:bundle:)
2. loadView() - only override if creating views programmatically
3. viewDidLoad() - one-time setup, views are loaded
4. viewWillAppear(_:) - every time view is about to appear
5. viewDidAppear(_:) - view is visible, start animations
6. viewWillDisappear(_:) - save data, stop timers
7. viewDidDisappear(_:) - cleanup

Interview Question: Where would you make a network request?

• viewDidLoad() for initial data
• Or viewWillAppear() if data needs refreshing each time
• Never in loadView() - that's for view creation only

5. SwiftUI Modern Patterns

@Observable vs ObservableObject

// NEW: @Observable (iOS 17+) - Simpler, automatic tracking
@Observable
class UserViewModel {
    var name: String = ""
    var email: String = ""
    var isLoading: Bool = false
}

struct ProfileView: View {
    var viewModel: UserViewModel  // No wrapper needed!

    var body: some View {
        if viewModel.isLoading {
            ProgressView()
        } else {
            Text(viewModel.name)
        }
    }
}

// OLD: ObservableObject - Explicit publishing
class LegacyViewModel: ObservableObject {
    @Published var name: String = ""
}

struct LegacyView: View {
    @StateObject var viewModel = LegacyViewModel()
}

Property Wrapper Decision Tree:

• @State: Simple value types owned by the view
• @Binding: Two-way connection to parent's state
• @Environment: System or custom environment values
• @Observable model: Pass directly, no wrapper needed
• @StateObject: Create and own an ObservableObject
• @ObservedObject: Receive an ObservableObject from parent

6. Networking and Data

URLSession Best Practices

func fetchUser(id: String) async throws -> User {
    let url = URL(string: "https://api.example.com/users/\(id)")!
    var request = URLRequest(url: url)
    request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")

    let (data, response) = try await URLSession.shared.data(for: request)

    guard let httpResponse = response as? HTTPURLResponse,
          200..<300 ~= httpResponse.statusCode else {
        throw NetworkError.invalidResponse
    }

    return try JSONDecoder().decode(User.self, from: data)
}

7. Common Gotchas

Main Thread Violations

// WRONG: UI update on background thread
URLSession.shared.dataTask(with: url) { data, _, _ in
    self.imageView.image = UIImage(data: data!)  // Crash!
}

// CORRECT: Dispatch to main
URLSession.shared.dataTask(with: url) { data, _, _ in
    DispatchQueue.main.async {
        self.imageView.image = UIImage(data: data!)
    }
}

// BEST: Use @MainActor
@MainActor
func updateUI(with image: UIImage) {
    imageView.image = image
}

Practice Session Formats

1. Quick Fire Round: 10 rapid questions, test breadth
2. Deep Dive: Pick one topic, explore thoroughly
3. Code Review: I show code with issues, you identify problems
4. Mock Interview: Full 45-minute simulation

Key Topics Checklist

• Swift value vs reference types
• ARC and memory management
• Closures and capture lists
• Protocol-oriented programming
• Generics and associated types
• Swift Concurrency (async/await, actors)
• UIKit view controller lifecycle
• Auto Layout and constraints
• SwiftUI state management
• Core Data / SwiftData
• Networking with URLSession
• Unit testing with XCTest
• Dependency injection patterns

How to Use

Ask me to:

• "Quiz me on Swift concurrency"
• "Explain retain cycles like I'm interviewing"
• "Give me a code review exercise"
• "Run a mock iOS interview"