Preparing for an iOS interview today is very different from 5 years ago.
It’s no longer just about UIKit and delegates — now you’re expected to understand:

• Swift Concurrency
• Memory management
• Architecture
• Thread safety
• SwiftUI internals
• System design thinking

In this blog, I’ll cover the most commonly asked iOS interview questions and concepts, structured for quick revision and deep understanding.

---

Swift Fundamentals

1️⃣ Why is Swift called a POP language?

Swift promotes Protocol-Oriented Programming (POP).

Instead of relying heavily on inheritance (OOP), Swift encourages:

• Protocols
• Protocol extensions
• Value types (structs)

This improves:

• Code reusability
• Flexibility
• Testability

---

2️⃣ Equatable vs Comparable

• Equatable → allows ==
• Comparable → allows <, >, <=, >=

2️⃣ Equatable vs Comparable

• Equatable → allows ==
• Comparable → allows <, >, <=, >=

struct User: Equatable, Comparable {
    let age: Int    static func < (lhs: User, rhs: User) -> Bool {
        lhs.age < rhs.age
    }
}

---

3️⃣ some vs any (Opaque Types)

• some → Opaque return type (compiler knows the type)
• any → Existential type (runtime abstraction)

func makeView() -> some View { Text("Hello") }

---

🏗 Architecture & Design Patterns

Commonly Asked Patterns

• MVC
• MVVM
• MVP
• Redux
• Coordinator
• Singleton
• Factory

---

Redux in iOS

Unidirectional data flow:

• State
• Action
• Reducer
• Store

Benefits:

• Predictable state
• Easy debugging
• Better scalability

---

MVP vs MVVM

MVP	MVVM
Presenter handles logic	ViewModel handles logic
View is passive	Binding support
More manual wiring	Works great with SwiftUI

---

🔁 Delegates vs NotificationCenter

Delegate	Notification
One-to-one	One-to-many
Strong contract	Loose coupling
Compile-time safety	Runtime

Use delegate when one object must respond.
Use NotificationCenter for broadcasting events.

---

🧵 Concurrency & Multithreading

Modern interviews heavily focus on concurrency.

---

Async/Await vs Completion Handler

Completion Handler	Async/Await
Callback-based	Structured concurrency
Pyramid of doom	Clean code
Harder to read	Linear style

func fetch() async throws -> Data {
    try await URLSession.shared.data(from: url).0
}

---

Task Types

Task { }                    // inherits priority
Task.detached { }           // independent
Task(priority: .background) { }

---

Actor vs Class

Class	Actor
Not thread-safe	Thread-safe
Needs locks	Built-in isolation
Shared mutable state risky	Protected state

Actors solve thread safety cleanly.

---

Achieving Thread Safety in a Class

1️⃣ Using GCD

let queue = DispatchQueue(label: "safe")
queue.sync { }

2️⃣ Using NSLock

3️⃣ Using Actor (Recommended Modern Way)

---

Sendable & Swift 6

• Sendable ensures safe data transfer across threads.
• Swift 6 enforces stricter concurrency checks.

---

🔄 Continuations (Bridging Old APIs)

Convert callback APIs to async/await:

func fetchData() async -> String {
    await withCheckedContinuation { continuation in
        oldAPI { result in
            continuation.resume(returning: result)
        }
    }
}

Types:

• withUnsafeContinuation
• withCheckedContinuation
• Throwing variants

---

Memory Management

---

What is Retain Cycle?

When two objects hold strong references to each other.

Example:

class A {
    var closure: (() -> Void)?
}

Fix with:

[weak self] in

---

Weak vs Unowned

• weak → Optional, becomes nil
• unowned → Non-optional, crashes if nil

---

How to Detect Memory Leaks?

Use:

• Instruments
• Memory Graph Debugger
• Time Profiler

---

📱 App Lifecycle

States:

• Not Running
• Inactive
• Active
• Background
• Suspended

---

AppDelegate vs SceneDelegate

• AppDelegate → app-level lifecycle
• SceneDelegate → UI lifecycle (multi-window support)

---

🔔 Push Notifications

Payload Size

Maximum: 4 KB

Types

• Alert
• Silent
• VoIP
• Critical
• Background

Silent Notification Example

{
  "aps": {
    "content-available": 1
  }
}

---

🔐 Security

When to Use Keychain?

Store:

• Tokens
• Passwords
• Sensitive credentials

---

SSL Pinning

Validates server certificate locally to prevent MITM attacks.

---

API Handshake Flow

1. TCP handshake
2. TLS handshake
3. Certificate validation
4. Secure communication

---

🎨 SwiftUI vs UIKit

UIKit	SwiftUI
Imperative	Declarative
Mature	Modern
More control	Faster development

---

StateObject vs ObservedObject

StateObject	ObservedObject
Owns object	Just observes
Lifecycle managed	External