Swift fundamentals
from first principles

The 60-second answer

Use this as the answer shell. The rest of the page explains why each sentence is true.

What Swift fundamentals are made of

Most “Swift questions” are really questions about one invariant. Name the invariant before naming the feature.

Model states, not boolean soup

Separate the shape of data from the screen’s state. A wire DTO may mirror an API; a domain model enforces product meaning; a UI model makes rendering decisions explicit.

struct UserDTO: Decodable {
    let id: Int
    let displayName: String?
}

struct User {
    let id: Int
    let name: String
}

enum LoadState<Value> {
    case idle, loading
    case loaded(Value)
    case failed(LoadError)
}

Loading state, live

Tap a state. The model makes the legal payload explicit instead of scattering flags across the view.

Copying is a semantic question before it is a performance question

Structs and enums have value semantics: assigning a value gives the program an independent value to mutate observably. Classes have identity: two variables can point at one instance. The compiler and standard library may optimize the physical representation.

struct Profile { var name: String }
var a = Profile(name: "Ada")
var b = a
b.name = "Grace"       // a.name is still "Ada"

final class ProfileBox { var name: String; init(_ name: String) { self.name = name } }
let x = ProfileBox("Ada")
let y = x; y.name = "Grace"   // x.name is now "Grace"

Mutation experiment

Copy-on-write: Array, Dictionary, Set and String can share storage until a mutation needs an independent buffer. That is an implementation strategy preserving value semantics, not a promise about every custom type.

Absence is data; unwrapping is policy

An Optional says “there may be a value.” The right syntax depends on what absence means here: branch, early exit, fallback, propagate, or programmer error.

func subtitle(for user: User?) -> String {
    guard let user else { return "Sign in to continue" }
    return user.name
}

let name = payload["name"] ?? "Unknown" // safe product fallback?
let value = try? decoder.decode(UserDTO.self, from: data) // loses why

Protocols are contracts; dependency injection is ownership of the choice

A protocol describes capability. Dependency injection decides who supplies the capability. A mock is valuable because the boundary is replaceable and the test owns the behavior, not because every type needs a protocol.

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

struct LiveUserService: UserServing { ... }
struct StubUserService: UserServing {
    let result: Result<User, Error>
    func fetchUser() async throws -> User { try result.get() }
}

struct ProfileModel {
    let service: any UserServing
}

Dependency choice, live

Protocol extensions can provide shared behavior, but a default implementation should not accidentally hide a required policy or make a mock harder to control.

Escaping is about lifetime; a cycle is about a retained loop

Ask one ownership question: who stores the closure? A one-shot service can retain a closure temporarily without forming a cycle. A repeating timer or an object-stored callback can close the graph.

// The object stores the closure; the closure captures the object.
final class Screen {
    var onTap: (() -> Void)?
    func connect() { onTap = { [weak self] in self?.submit() } }
}

load { [weak self] result in
    guard let self else { return }
    self.render(result)
}

// Use unowned only when the lifetime guarantee is real.
unowned let parent: Parent

Retain graph, live

Switch the capture policy, then release the external owner. The experiment shows why a strong capture can leak only when the object stores the closure.

Codable is a compatibility contract, not a magic API

Keep wire shape and app meaning separate when they change at different speeds. Synthesis handles ordinary mappings; CodingKeys, decoder strategies and custom decoding express explicit compatibility policy.

struct UserDTO: Decodable {
    let id: Int
    let displayName: String?

    enum CodingKeys: String, CodingKey {
        case id
        case displayName = "display_name"
    }
}

let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .iso8601
let users = try decoder.decode([UserDTO].self, from: data)

After decoding, map DTOs to domain models when the API’s optionality, naming, date representation or failure semantics should not leak into the rest of the app.

Choose the collection from the invariant

Start with the operation the product needs, then choose the representation. Complexity is a useful prediction under stated assumptions, not a universal speed guarantee.

var ids = Set<Int>()
let inserted = ids.insert(42).inserted // invariant: one 42

var byID: [Int: User] = [:]
byID[user.id] = user                  // keyed access

let visible = users.sorted { $0.name < $1.name } // order belongs to the view policy

Make mutually exclusive states impossible to confuse

Associated values attach the data that belongs to a case. Pattern matching with switch forces the code to account for the state space.

enum LoadState<Value> {
    case idle
    case loading
    case loaded(Value)
    case failed(Error)
}

switch state {
case .idle: showPlaceholder()
case .loading: showSpinner()
case .loaded(let users): show(users)
case .failed(let error): show(error)
}

If a state needs several unrelated booleans to explain its payload, the enum’s cases may be too broad. If two cases carry the same meaning, the model may be duplicating policy.

Failure is part of the API contract

Use throws when the caller should decide how to recover or propagate. Use Result when the success/failure value must be stored, transformed or passed as data. async throws combines possible suspension with failure propagation; it does not mean “runs in the background.”

enum ProfileError: Error { case offline, invalidPayload }

func loadProfile() async throws -> Profile { ... }

do {
    let profile = try await loadProfile()
    render(profile)
} catch ProfileError.offline { showOffline() }
  catch { showRetry(error) }

let result: Result<Profile, ProfileError> = ...

Reuse the operation while preserving type relationships

A generic parameter says several values share a concrete type relationship. A constraint says what operations are legal. That is different from accepting any value behind a protocol existential.

func decode<T: Decodable>(_ type: T.Type, from data: Data) throws -> T {
    try JSONDecoder().decode(type, from: data)
}

func first<T>(_ values: [T]) -> T? {
    values.first
}

// The caller keeps the concrete type relationship.
let user: UserDTO = try decode(UserDTO.self, from: data)

Ask who owns the state before choosing a wrapper

SwiftUI may reevaluate body; the wrapper determines where state lives and who can mutate or observe it. The choice is ownership and data flow, not a list of “modern” keywords.

// Value owned by the view; child receives a writable projection.
struct Parent: View {
    @State private var isOn = false
    var body: some View { ToggleRow(isOn: $isOn) }
}

// Observation model: ownership still matters; the macro does not choose it.
import Observation
@MainActor @Observable
final class ScreenModel { var state: LoadState = .idle }

Version note: @Observable belongs to the Observation framework and is available from iOS 17. This page is reviewed against the repo baseline of shipping Swift 6.3, Xcode 26.6 and iOS 26.5 SDK; availability and deployment targets still need checking in a real app.

Trace the failing invariant, not just the crashing line

When reading unfamiliar Swift, ask four questions in order: what state is legal, what can be absent or fail, who owns the value/closure/task, and which executor/lifecycle event is allowed to mutate or release it?

// Risky: three different failures are hidden.
func refresh() {
    let title = try? service.fetchTitle()  // error becomes nil
    label.text = title!                 // crash if nil
    Task { self.save() }                // inspect lifetime + executor
}

// Safer shape: explicit state, policy and ownership.
@MainActor
func refresh() async {
    state = .loading
    do { state = .loaded(try await service.fetchTitle()) }
    catch is CancellationError { }
    catch { state = .failed(.network) }
}

Don’t say this, say that

These are the shortcuts a red-team interviewer will usually probe.

Drill

Six follow-ups. Predict the result before you look for the rule.

Can you derive the answer?

Tick these off only when you can explain the why, not just repeat the phrase. Progress is saved in this browser.

Sources and further reading

Primary documentation used to verify the semantics and API roles in this page. Version-sensitive claims are marked in the page and should be rechecked during the repo’s annual platform refresh.