iOS & Swift Interview Handbook – Core Vocabulary

This flashcard set covers essential vocabulary and concepts from the 2025 iOS & Swift Interview Handbook, including Swift language features, memory management, concurrency, architectural patterns, testing, Git workflows, SwiftUI state management, Combine, networking, and security topics.

Optional

A Swift type that can hold a value or nil, written with a ? after the type name.

Optional Binding

Safely unwrapping an optional using if let or guard let to access its value only if it is non-nil.

Guard Statement

A Swift control-flow statement that exits the current scope when a condition fails; often used for early-exit optional binding.

Nil-Coalescing Operator (??)

Returns the wrapped value of an optional or a default value when the optional is nil.

Force Unwrapping

Using ! to access an optional’s value; crashes at runtime if the value is nil.

var

Keyword that declares a mutable variable whose value can change.

let

Keyword that declares an immutable constant whose value cannot change after assignment.

Struct

A Swift value type stored on the stack, copied on assignment, and lacking inheritance.

Class

A Swift reference type stored on the heap, passed by reference, and supporting inheritance and deinit.

Actor

A reference type introduced for Swift concurrency that provides data isolation and thread safety by serializing access.

Stored Property

A property that stores a constant or variable value directly in an instance.

Computed Property

A property that calculates its value every time it is accessed, using get / set.

Type Inference

Swift’s ability to deduce the data type of a constant or variable from its initial value.

mutating Keyword

Marks a struct/enum method that changes the instance’s stored properties.

Extension

Adds new functionality to an existing type without subclassing or modifying the original source.

Protocol

A blueprint of properties and methods that a type can adopt to provide specific functionality.

Codable

A type alias for Encodable & Decodable that allows automatic JSON encoding/decoding.

Access Control – open

Highest visibility; accessible and subclassable outside the defining module.

Access Control – public

Accessible outside the module but not subclassable/overridable there.

Access Control – internal

Default level; accessible anywhere inside the same module.

Access Control – fileprivate

Accessible only within the same source file.

Access Control – private

Accessible only within the enclosing declaration.

Protocol-Oriented Programming (POP)

Swift design style that favors protocols and value types over inheritance.

Delegation

One-to-one communication pattern where an object hands off tasks to another object via a protocol.

NotificationCenter

Broadcast mechanism for one-to-many communication inside an app.

Associated Type

A placeholder type declared in a protocol and specified by conforming types.

Generic

A reusable function or type that works with any type that meets given constraints.

Single Responsibility Principle

Each class or module should have only one reason to change.

Open-Closed Principle

Software entities should be open for extension but closed for modification.

Liskov Substitution Principle

Subtypes must be substitutable for their base types without altering correctness.

Interface Segregation Principle

Clients should not be forced to depend on methods they do not use; prefer fine-grained protocols.

Dependency Inversion Principle

Depend on abstractions, not concrete implementations.

Automatic Reference Counting (ARC)

Swift’s compile-time memory management that tracks strong references to class instances.

Strong Reference

Default ownership that increments an object’s reference count and prevents deallocation.

Weak Reference

A non-owning reference that does not keep an object alive and becomes nil when the object deallocates.

Unowned Reference

A non-owning, non-optional reference assumed to outlive the referencing property; crashes if accessed after deallocation.

Retain Cycle

A memory leak where two objects hold strong references to each other, preventing deallocation.

Grand Central Dispatch (GCD)

C-level API that manages concurrent tasks using dispatch queues.

OperationQueue

Higher-level concurrency abstraction over GCD that supports dependencies, cancellation, and KVO.

async/await

Swift concurrency keywords that allow writing asynchronous code in a linear, readable style.

DispatchGroup

GCD construct that synchronizes multiple asynchronous tasks and notifies when all complete.

Auto Layout

Constraint-based system that dynamically calculates view sizes and positions for different screen sizes.

frame

A view’s position and size in its superview’s coordinate space.

bounds

A view’s position and size in its own coordinate space.

Storyboard

Visual interface file that contains multiple view controllers and segues in Interface Builder.

XIB

Interface Builder file representing a single view or view controller’s layout.

Programmatic UI

Building user interfaces entirely in Swift code without storyboards or XIBs.

viewDidLoad

UIViewController lifecycle method called once after the view is loaded into memory.

viewWillAppear

Lifecycle method called just before a view becomes visible.

viewDidAppear

Lifecycle method called immediately after a view becomes visible.

UITableView

UIKit component that displays a single-column, vertically scrolling list.

UICollectionView

UIKit component for grid or custom-layout scrolling content using cells and supplementary views.

prepare(for:sender:)

UIViewController method to configure destination view controller before a segue.

Diffable Data Source

Modern API for table/collection views that applies snapshot diffs for automatic, animated updates.

URLSession

Foundation API for HTTP networking tasks such as data, download, and upload requests.

Combine

Apple’s reactive framework that uses publishers and subscribers to process asynchronous events.

Publisher

Combine type that emits values over time to subscribed observers.

Subscriber

Combine object that receives values and completion events from a publisher.

UserDefaults

Persistent storage for small key-value pairs like settings and preferences.

Core Data

Apple framework for object graph management and persistence using SQLite under the hood.

Realm

Third-party mobile database offering fast object storage with simple APIs and built-in sync.

Model-View-Controller (MVC)

Classic architecture where controllers mediate between data (Model) and UI (View).

Model-View-ViewModel (MVVM)

Architecture that adds a ViewModel layer to format data for views, improving testability.

VIPER

iOS architecture dividing modules into View, Interactor, Presenter, Entity, and Router for high modularity.

Singleton Pattern

Creational pattern that ensures a class has only one shared instance throughout the app.

Keychain

Encrypted storage service for sensitive data like passwords and tokens.

Deep Linking

Ability to open a specific screen in an app via a custom URL or universal link.

App Transport Security (ATS)

iOS security feature enforcing secure HTTPS connections by default.

Unit Test

Automated test that verifies the behavior of a small piece of code, typically a single function or class.

UI Test

Automated test that simulates user interactions to verify the UI behaves correctly.

TestFlight

Apple distribution platform for beta testing iOS apps with external users.

App Clip

Lightweight, fast subset of an iOS app (<10 MB) launched via QR, NFC, or link for quick tasks.

Property Wrapper

A generic structure/class that adds custom getter/setter logic around a property using @ syntax.

@State

SwiftUI property wrapper for view-local, mutable state that triggers UI updates.

@Binding

SwiftUI wrapper that creates a two-way connection to another state value.

@StateObject

SwiftUI wrapper that instantiates and owns an ObservableObject for the view’s lifetime.

@ObservedObject

SwiftUI wrapper that observes an external ObservableObject and updates the view when it changes.

@EnvironmentObject

SwiftUI wrapper that injects a shared ObservableObject into the environment for descendant views.

@Published

Property wrapper in Combine that marks a property for publisher updates when it changes.

@MainActor

Swift concurrency attribute that guarantees annotated code runs on the main thread.

Task

Structured concurrency unit that performs asynchronous work and is cancelled with its parent scope.

TaskGroup

API for running multiple child tasks concurrently under structured concurrency.

DetachedTask

Unstructured concurrency task that runs independently of the parent context.

Thread.sleep

Blocks the current thread for a time interval; not cooperative with Swift concurrency.

Task.sleep

Suspends an async task for a duration without blocking its underlying thread.

Race Condition

Bug that occurs when multiple threads access shared data at the same time causing unpredictable results.

Deadlock

State where two or more threads wait indefinitely for resources locked by each other.

Feature Branch

Git branching strategy where each new feature is developed in its own branch.

Pull Request (PR)

GitHub/GitLab workflow step where code is reviewed and discussed before merging.

Git Flow

Branching model with main, develop, feature, release, and hotfix branches for organized collaboration.

Fastlane

Command-line toolchain that automates building, signing, testing, and releasing iOS apps.

CI/CD

Continuous Integration/Continuous Deployment pipelines that build, test, and deliver code automatically.

SwiftLint

Static-analysis tool that enforces Swift style and best-practice rules.

KeyPath

Type-safe reference to a property of a type, usable for dynamic access.

inout Parameter

Function parameter modifier that allows a value to be modified inside the function and written back to the caller.

Escaping Closure

Closure that outlives the function call, marked with @escaping.

Non-Escaping Closure

Default closure parameter that must complete during the function call.

Function Builder / @resultBuilder

Swift feature for building nested DSL structures (e.g., SwiftUI View hierarchies) from declarative syntax.

@autoclosure

Attribute that automatically wraps an expression passed to a function into a closure.

Any

Type-erased container that can hold a value of any type (value or reference).