iOS / Swift 6.2 Interview Question Bank (August 2026)

Flashcards covering core vocabulary for Swift 6.2, memory management, concurrency, SwiftUI, and iOS system design based on the 2026 baseline transcript.

Structs

Value types with copy semantics that live inline in their container; they do not support inheritance, deinit, or identity (===).

Classes

Reference types where assignment copies the pointer to a shared heap-allocated instance; lifetime is managed by ARC and they support inheritance, deinit, and identity.

Copy-on-write (COW)

An optimization for structs (like Array and String) that ensures the heap buffer is only copied when a mutation occurs and the buffer is not uniquely referenced.

isKnownUniquelyReferenced(_:)

A Swift function used to implement custom COW by checking if a native Swift class instance has exactly one strong reference.

InlineArray

A fixed-size array shipped in Swift 6.2 where storage is inline in the value, eliminating heap allocation and reference counting.

Span

A non-escapable, memory-safe view over contiguous memory that provides unsafe-pointer performance with compiler-checked lifetime safety.

some Shape (Opaque Type)

A type where the implementation picks one specific concrete type; it is statically dispatched and does not require heap boxing.

any Shape (Existential)

A type where the concrete type is erased and can differ per value; it uses dynamic dispatch through a witness table and may require heap boxing.

Existential Container

A memory layout (roughly five words) used for 'any P' types, containing an inline value buffer, a pointer to type metadata, and witness table pointers.

Wtable (Protocol Witness Table)

A table mapping protocol requirements to concrete implementations; used for calls through existentials or unspecialized generics.

Vtable (Virtual Table)

A table of function pointers used for non-final method dispatch on classes.

Message Dispatch

Dispatch used by the Objective-C runtime for @objc dynamic members, supporting swizzling and KVO through objc_msgSend.

Primary Associated Types

Associated types declared in angle brackets (e.g., protocol Container) that can be constrained at the use site using 'some' or 'any'.

ReferenceWritableKeyPath

A type-safe reference to a property that can write through a 'let' root because the root is a class instance.

@dynamicMemberLookup

An attribute allowing a type to resolve arbitrary member accesses at compile time via a subscript method.

Property Wrapper

A type annotated with @propertyWrapper that provides custom logic for property access and storage through synthesized code.

Result Builder

A type that transforms a sequence of expressions in a closure into a single composed value, used for DSLs like SwiftUI's View bodies.

Swift Macros

Compile-time plugins (freestanding or attached) that take an AST and return a new AST to add declarations or members.

@Observable

A Swift 6 macro that turns stored properties into computed properties that report reads and writes to an ObservationRegistrar for per-property invalidation.

~Copyable (Noncopyable Types)

A type that suppresses implicit Copyable conformance, allowing it to model unique ownership of resources like file handles.

Typed Throws

A Swift 6 feature allowing functions to specify the concrete error type they throw using the 'throws(E)' syntax.

inout

A parameter passing mechanism that semantically executes as copy-in/copy-out, granting the callee exclusive write access to a variable.

@inlinable

An attribute that exposes a function body in the module interface, allowing cross-module callers to inline and specialize the code.

Never

An uninhabited enum used as a return type for functions that do not return, which also expresses non-failing generic contexts.

ARC (Automatic Reference Counting)

A compile-time memory management system that inserts retain and release calls for class instances and deallocates them when the strong count hit zero.

Side Tables

Separate runtime allocations used by ARC to store the weak count and reference counts for an object when a weak reference is first formed.

Abandoned Memory

Memory that is still referenced and reachable but will never be used again, distinct from a leak where all references are lost.

Autorelease Pool

An Objective-C mechanism where objects are released at the end of a run loop iteration; still relevant in Swift when using certain Foundation APIs.

Structured Concurrency

A concurrency model where child tasks have a clear relationship with their parent, ensuring cancellation propagates and children do not outlive their scope.

Actor Reentrancy

The behavior where an actor can suspend at an 'await' point and start executing other queued work, meaning state must be re-validated after each suspension.

Sendable

A marker protocol indicating that a value can safely cross concurrency isolation boundaries without risk of data races.

nonisolated(nonsending)

A Swift 6.2 feature for async functions that ensures the function remains on the caller's actor, avoiding unnecessary thread hops and Sendable constraints.

Structural Identity

SwiftUI view identity derived from the view's position, type, and hierarchy within the View tree.

Explicit Identity

SwiftUI view identity determined by a stable identifier provided via '.id()' or 'Identifiable' conformance.

Layout Negotiation

The three-step SwiftUI process: parent proposes size, child chooses its size, and parent places the child.

GeometryReader

A greedy view that expands to fill all proposed space and provides its own size and coordinate information to its children.

PreferenceKey

A mechanism for flowing values from children views up the hierarchy to an ancestor View.

Hit Testing

The process of walking down the view hierarchy using 'hitTest(_:with:)' to find the deepest subview containing a given touch point.

Hitch

A frame displayed later than intended, subdivided into 'commit hitches' (app work was slow) and 'render hitches' (GPU work was slow).

Jetsam

The iOS system mechanism that kills processes based on priority to reclaim memory under pressure.

dSYM

A debug symbol bundle produced at build time that allows memory addresses in crash reports to be mapped to source code names.

JSI (JavaScript Interface)

A React Native New Architecture layer that allows JS to hold references to native objects and call them synchronously via C++.