The road to Senior iOS.

  let  (pen, sealed)          var  (pencil, refillable)
 ┌───────────────┐          ┌───────────────┐
 │  name = "Ali" │          │  score = 0    │
 └───────────────┘          └───────────────┘
        │                          │
   change it? ──► ❌ error    change it? ──► ✅ score = 10

let pi = 3.14159        // constant, type inferred as Double
var score = 0           // variable, can change
score = 10              // ✅ allowed
// pi = 3.0             // ❌ compile error: cannot assign to 'let'

let name: String = "Ali"   // explicit type (optional to write)

   Optional<Int>  =  a box that may hold an Int

   Some(5)                       None (nil)
 ┌──────────┐                 ┌──────────┐
 │   [ 5 ]  │                 │  (empty) │
 └──────────┘                 └──────────┘
      │                            │
  if let n = box  ──► n = 5    if let n = box ──► skipped (safe)
      │
  use n safely ✅

var age: Int? = nil          // empty box right now
age = 8

// Safe unwrap with if let
if let realAge = age {
    print("Age is \(realAge)")   // runs only if not nil
} else {
    print("No age given")
}

// guard let, exit early if missing
func greet(_ name: String?) {
    guard let name else { return }   // bail if nil
    print("Hi \(name)")             // name is safe below
}

// Nil-coalescing: provide a default
let shown = age ?? 0          // 8 if set, else 0

Array  [a, b, c]      index:  0   1   2     ordered, dupes ok
Dict   ["ali": 8]     key "ali" ──► 8        lookup by key
Set    {🍎,🍌}         contains 🍎? ──► true   unique, unordered

var fruits = ["apple", "pear"]      // [String]
fruits.append("plum")
print(fruits[0])                    // "apple"

var ages = ["Ali": 8, "Sam": 9]     // [String: Int]
print(ages["Ali"] ?? 0)             // 8 (optional lookup)
ages["Sam"] = 10                    // update

var seen: Set = [1, 2, 2, 3]        // {1, 2, 3} - dupes dropped
print(seen.contains(2))             // true

enum Light { case red, yellow, green }

      ┌─────┬────────┬───────┐
      │ red │ yellow │ green │   ← only these, ever
      └─────┴────────┴───────┘

enum Load { case idle, loading, done(String), failed(Error) }
                                  └─ carries data ─┘

enum Status {
    case idle
    case loading
    case done(String)        // carries the result text
    case failed(Error)       // carries the error
}

func handle(_ s: Status) {
    switch s {                       // must cover every case
    case .idle:           print("waiting")
    case .loading:        print("…")
    case .done(let text): print("got \(text)")
    case .failed(let e):  print("error \(e)")
    }
}

STRUCT (copy)                 CLASS (shared)
 a ─► [ x: 1 ]                 a ─┐
 b = a  (COPY)                    ├─► [ x: 1 ]   one object
 b ─► [ x: 1 ]                 b ─┘
 b.x = 9                       b.x = 9
 a.x = 1  ✅ unchanged          a.x = 9  ⚠️ also changed!

struct PointS { var x = 0 }
class  PointC { var x = 0 }

var a = PointS(); var b = a   // COPY
b.x = 9
print(a.x)   // 0 , a untouched

let c = PointC(); let d = c   // SAME object
d.x = 9
print(c.x)   // 9 , changed through d

   { (input) -> output in  ... steps ... }
        │            │            │
      params      returns       body

  let greet = { (name: String) in print("Hi \(name)") }
  greet("Ali")                    ──► runs the backpack now

  download(url) { data in ... }   ──► runs LATER, when done

// Stored in a variable, called later
let add = { (a: Int, b: Int) -> Int in a + b }
print(add(2, 3))     // 5

// Passed to a function (trailing-closure + shorthand $0)
let nums = [3, 1, 2]
let sorted = nums.sorted { $0 < $1 }   // [1, 2, 3]
let doubled = nums.map { $0 * 2 }      // [6, 2, 4]

// Captures surrounding state
func counter() -> () -> Int {
    var count = 0
    return { count += 1; return count }   // backpack keeps 'count'
}
let next = counter()
print(next(), next())   // 1 2

stored      var name = "Ali"        ← value sits in memory
computed    var area: Double {       ← recalculated on read
              width * height
            }
observer    var score = 0 {
              didSet { print("now \(score)") }  ← runs on change
            }
lazy        lazy var heavy = build()  ← built on first use only

struct Rectangle {
    var width = 0.0
    var height = 0.0
    var area: Double { width * height }   // computed (read-only)
}

class Player {
    var score = 0 {
        didSet { print("score changed to \(score)") }  // observer
    }
    lazy var profile = loadProfile()      // built on first access
}

Int  ──extension──►  now has .squared()

extension Int { var squared: Int { self * self } }
3.squared   ──►  9

extension MyView: Drawable { func draw() { ... } }  ← grouped conformance

extension Int {
    var squared: Int { self * self }
    func times(_ run: () -> Void) {       // add a method
        for _ in 0..<self { run() }
    }
}

print(4.squared)        // 16
3.times { print("hi") } // hi hi hi

// Group protocol conformance in its own extension
extension String: MyProtocol { /* ... */ }

protocol Drawable { func draw() }   ← the checklist

   Circle ──┐
   Square ──┼──► all promise draw() ──► used as 'Drawable'
   Robot  ──┘

   func render(_ shapes: [Drawable]) { for s in shapes { s.draw() } }
        └─ doesn't care about the concrete type, only the contract

protocol Greeter {
    var name: String { get }
    func greet()
}

extension Greeter {                 // default behaviour for all
    func greet() { print("Hi, I'm \(name)") }
}

struct Dog: Greeter { let name = "Rex" }      // gets greet() free
struct Robot: Greeter {
    let name = "R2"
    func greet() { print("BEEP \(name)") }   // or override it
}

let crowd: [Greeter] = [Dog(), Robot()]
crowd.forEach { $0.greet() }

   Stack<T>   ← T is a placeholder for "whatever type"

   Stack<Int>        Stack<String>
 ┌──────────┐      ┌────────────┐
 │ 3, 1, 2  │      │ "a", "b"   │
 └──────────┘      └────────────┘
   push/pop Int      push/pop String   (same code, type-safe)

struct Stack<T> {            // T = any type
    private var items: [T] = []
    mutating func push(_ x: T) { items.append(x) }
    mutating func pop() -> T? { items.popLast() }
}

var ints = Stack<Int>()
ints.push(1); ints.push(2)
print(ints.pop() ?? -1)      // 2

// Constraint: T must be Comparable
func biggest<T: Comparable>(_ a: T, _ b: T) -> T { a > b ? a : b }
print(biggest(3, 9))         // 9
print(biggest("a", "z"))     // "z"

do {
    try riskyStep()   ──fails──┐
    nextStep()        (skipped)│
} catch {                      │
    handle(error)   ◄──────────┘   jump straight here
}

try?  ► returns nil on failure        try!  ► crash on failure

enum LoginError: Error { case empty, tooShort }

func validate(_ pw: String) throws -> String {
    if pw.isEmpty { throw LoginError.empty }
    if pw.count < 6 { throw LoginError.tooShort }
    return pw
}

do {
    let ok = try validate("123")
    print("welcome \(ok)")
} catch LoginError.tooShort {
    print("password too short")
} catch {
    print("other error: \(error)")
}

let maybe = try? validate("hello123")   // String? (nil if it threw)

Healthy:  A ──strong──► B        B count 1 ─► drops to 0 ─► freed ✅

Cycle:    A ──strong──► B
          A ◄──strong── B         both counts stuck at 1 ─► leak ❌

Fix:      A ──strong──► B
          A ◄── weak ── B         weak doesn't bump count ─► freed ✅

class Person {
    let name: String
    var card: Card?
    init(name: String) { self.name = name }
    deinit { print("\(name) freed") }
}
class Card {
    weak var owner: Person?     // weak breaks the cycle
}

var p: Person? = Person(name: "Ali")
p?.card = Card()
p?.card?.owner = p
p = nil      // prints "Ali freed", no leak

// In closures, capture self weakly:
// download { [weak self] data in self?.update(data) }

Without async (blocks):
  [download.................] then UI  ← screen frozen 😖

With async/await:
  start ─► await download ···(buzzer)···► resume ─► update UI
            │ thread is free to do other work meanwhile │ 🙂

func fetchUser() async throws -> String {
    let url = URL(string: "https://example.com/me")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return String(decoding: data, as: UTF8.self)
}

Task {                              // start async work
    do {
        let user = try await fetchUser()
        await MainActor.run { label.text = user }   // UI on main
    } catch { print(error) }
}

actor Counter {                     // safe shared state
    private var n = 0
    func bump() { n += 1 }
}

MAIN queue (UI only, keep it free)
   │  hand off heavy work
   ▼
GLOBAL queue (background) ── download / parse ──┐
                                                │ done
   plate the result on screen  ◄── main.async ──┘

DispatchQueue.global(qos: .userInitiated).async {
    let data = heavyDownload()          // background, no UI freeze
    DispatchQueue.main.async {
        self.label.text = data          // back on main for UI
    }
}

// Serial queue = one task at a time (protects shared state)
let queue = DispatchQueue(label: "cache")   // serial by default

Swift value  ──JSONEncoder──►  JSON data   (upload)
   User                            {"name":"Ali"}

JSON data    ──JSONDecoder──►  Swift value  (receive)
{"name":"Ali"}                    User(name: "Ali")

struct User: Codable {
    let name: String
    let age: Int
    enum CodingKeys: String, CodingKey {
        case name
        case age = "user_age"      // map a different server key
    }
}

let json = #"{"name":"Ali","user_age":8}"#.data(using: .utf8)!
let user = try JSONDecoder().decode(User.self, from: json)
let back = try JSONEncoder().encode(user)   // -> Data

@State var count = 0
        │  change it
        ▼
  ┌──────────────┐   SwiftUI notices ─► re-runs body ─► UI updates
  │  body { ... }│◄──────────────────────────────────────┐
  └──────────────┘                                        │
    Button("tap") { count += 1 } ───────────────────────►─┘

import SwiftUI

struct CounterView: View {
    @State private var count = 0          // view-owned state

    var body: some View {                 // describe the UI
        VStack {
            Text("Count: \(count)")        // re-renders on change
            Button("Add") { count += 1 }   // mutate → auto update
        }
    }
}

// @Binding: child edits parent's value
struct NameField: View {
    @Binding var name: String
    var body: some View { TextField("Name", text: $name) }
}

Fixed frame  ──► breaks on a different screen size ❌

Constraints (relationships, solved at runtime):
 ┌─ screen ───────────────┐   leading = 16
 │        [ Button ]      │   centerX = superview.centerX
 │     top = safe + 20    │   width  ≥ 100
 └────────────────────────┘   ── fits ANY size ✅

box.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
    box.centerXAnchor.constraint(equalTo: view.centerXAnchor),
    box.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor,
                             constant: 20),
    box.widthAnchor.constraint(greaterThanOrEqualToConstant: 100),
])
// SwiftUI: VStack { ... }.padding() does the relating automatically.

Not running ──► Inactive ──► Active  (foreground, on screen)
                   ▲             │  user leaves
                   └─ Background ◄┘  (brief tasks)
                          │
                          ▼
                      Suspended  (frozen; may be killed)
   leaving Active? ──► save state + pause work

import SwiftUI

@main
struct MyApp: App {
    @Environment(\.scenePhase) private var phase
    var body: some Scene {
        WindowGroup { ContentView() }
            .onChange(of: phase) { _, newPhase in
                switch newPhase {
                case .active:     resume()       // back on screen
                case .inactive:   pauseLightly()  // transient
                case .background: saveState()      // may suspend next
                @unknown default: break
                }
            }
    }
}

Publisher ──► [map] ──► [filter] ──► Subscriber (sink)
 emits 1,2,3     ×2        keep even     receives 4,6
            1,2,3 ─► 2,4,6 ─► 4,6 ─────► drinks them

import Combine

final class SearchVM: ObservableObject {
    @Published var query = ""             // a publisher
    @Published var results: [String] = []
    private var bag = Set<AnyCancellable>()

    init() {
        $query
            .debounce(for: .milliseconds(300), scheduler: RunLoop.main)
            .map { $0.lowercased() }
            .sink { [weak self] q in self?.search(q) }
            .store(in: &bag)              // keep the subscription alive
    }
    func search(_ q: String) { /* ... */ }
}

App ──► APIClient ──► URLSession ──► Server
        (protocol)         │  data + status
 model  ◄── decode JSON ◄──┘
   app  ──► LiveAPIClient
   test ──► FakeAPIClient   (no network)

protocol APIClient {
    func fetchUser() async throws -> User
}

struct LiveAPIClient: APIClient {
    func fetchUser() async throws -> User {
        let url = URL(string: "https://api.example.com/me")!
        let (data, resp) = try await URLSession.shared.data(from: url)
        guard (resp as? HTTPURLResponse)?.statusCode == 200 else {
            throw URLError(.badServerResponse)
        }
        return try JSONDecoder().decode(User.self, from: data)
    }
}

   VIEW  ◄──observes──  VIEW MODEL  ◄──reads/writes──  MODEL
 (dining room)          (the waiter)              (kitchen+pantry)
     │  user taps           │  formats data            │ raw data,
     └──actions────────────►│  loads, validates        │ network, db
                            └─────────────────────────►│

import SwiftUI

@MainActor
final class ProfileVM: ObservableObject {
    @Published var title = "Loading…"      // View watches this

    func load() async {
        // ...fetch from Model layer...
        title = "Hello, Ali"               // change → View updates
    }
}

struct ProfileView: View {
    @StateObject private var vm = ProfileVM()
    var body: some View {
        Text(vm.title)
            .task { await vm.load() }       // ask the VM to work
    }
}

┌──────────────────────────────┐
│  Frameworks (UI · DB · Net)  │  outer
│  ┌────────────────────────┐  │
│  │  Use Cases (actions)   │  │
│  │  ┌──────────────────┐  │  │
│  │  │ Entities (core)  │  │  │  inner
│  │  └──────────────────┘  │  │
│  └────────────────────────┘  │
└──────────────────────────────┘
 dependencies point INWARD only ──►

// Core defines a protocol; it imports no UIKit, no database.
protocol UserRepository {                 // a boundary
    func load(id: Int) async throws -> User
}

struct FetchUser {                        // a use case
    let repo: UserRepository
    func run(id: Int) async throws -> User {
        try await repo.load(id: id)
    }
}
// The real repo (network/db) lives in the OUTER layer and conforms.

Delegate (1:1)   Cell ──asks──► delegate?.didTap()
Singleton (1)    Logger.shared  ← the only instance, everywhere
Observer (1:N)   event ──► [ listenerA · listenerB · listenerC ]

// Delegation
protocol RowTapHandler: AnyObject { func didTap(_ row: Int) }
final class List {
    weak var delegate: RowTapHandler?      // weak: avoid a cycle
    func tap(_ r: Int) { delegate?.didTap(r) }
}

// Singleton (use sparingly)
final class Logger { static let shared = Logger(); private init() {} }

// Observer
NotificationCenter.default.post(name: .init("didLogin"), object: nil)

S   one job per type
O   extend, don't modify
L   a subtype fits where its parent fits
I   small focused protocols  >  one fat one
D   depend on protocols, not concretes

// Bad: one fat protocol forces unused methods (breaks I + S)
protocol Worker { func code(); func test(); func deploy() }

// Better: small protocols, depend on the abstraction (I + D)
protocol Coder  { func code() }
protocol Tester { func test() }

struct CI { let coder: Coder }   // depends on a protocol, not a class

Monolith                  Modular (SPM)
┌───────────────┐         App
│  everything   │          ├─ FeatureLogin
│  one target   │          ├─ FeatureFeed
│  slow rebuild │          ├─ NetworkingKit  ← build/test alone
└───────────────┘          └─ CoreKit         reused everywhere

// Package.swift (a NetworkingKit module)
let package = Package(
    name: "NetworkingKit",
    products: [.library(name: "NetworkingKit", targets: ["NetworkingKit"])],
    targets: [
        .target(name: "NetworkingKit"),
        .testTarget(name: "NetworkingKitTests", dependencies: ["NetworkingKit"]),
    ]
)
// Only 'public' symbols are visible to the app that imports it.

Tight coupling:   ViewModel ──makes──► RealNetwork   (can't test)

Injected:         protocol API { func load() async -> Data }
                  ViewModel(api: API)
                       app  ──► RealAPI
                       test ──► FakeAPI   ← swap freely

protocol Weather {                       // the contract
    func today() async -> String
}
struct RealWeather: Weather {
    func today() async -> String { "sunny" }   // real network
}
struct FakeWeather: Weather {
    func today() async -> String { "test-data" } // for tests
}

final class ForecastVM {
    let api: Weather
    init(api: Weather) { self.api = api }    // injected
}

let appVM  = ForecastVM(api: RealWeather())
let testVM = ForecastVM(api: FakeWeather())  // swap in a fake

MEASURE ──► FIND HOTSPOT ──► FIX ──► MEASURE AGAIN
Instruments:
  Time Profiler  ─► where CPU time goes
  Allocations    ─► memory growth
  Leaks          ─► objects never freed
  Main-thread    ─► hitches / frozen scroll

// Quick timing in code
let start = CFAbsoluteTimeGetCurrent()
expensiveWork()
print("took \(CFAbsoluteTimeGetCurrent() - start)s")

// Keep the main thread free; cache instead of recomputing
DispatchQueue.global().async {
    let result = process(big)            // off main
    DispatchQueue.main.async { self.show(result) }
}

Arrange ─► Act ─► Assert
  set up    run     check expected == actual

func test_add() {
    let r = Calculator().add(2, 3)   // Act
    XCTAssertEqual(r, 5)             // Assert ✅ / ❌
}

import XCTest
@testable import MyApp

final class CalculatorTests: XCTestCase {
    func test_add_returnsSum() {
        let calc = Calculator()          // Arrange
        let result = calc.add(2, 3)      // Act
        XCTAssertEqual(result, 5)        // Assert
    }

    func test_fetch_usesFake() async {
        let vm = ForecastVM(api: FakeWeather())   // injected fake
        let text = await vm.api.today()
        XCTAssertEqual(text, "test-data")
    }
}