iOS 75

Structs are value types and get copied. Classes are reference types and are shared.

Value semantics means each copy is independent; copy-on-write makes copies cheap by sharing storage until someone mutates it.

An optional either holds a value or nil; unwrap it with if let, guard let, ?? or optional chaining instead of force unwrapping.

Associated values let each enum case carry its own extra data, which is great for modeling states where only valid combinations are possible.

An escaping closure can be called after the function that received it returns, so it must be marked @escaping and you must think about what it captures.

A capture list, like [weak self] or [count], controls how a closure captures values, either by making references weak or by copying a value at creation time.

Functions mark failure with throws, callers handle it with do/catch, try? or try!, and Swift 6 adds typed throws for a fixed error type.

Protocol-oriented programming means building behavior from small protocols with default implementations, instead of deep class inheritance.

some is an opaque type that stands for one specific concrete type the compiler knows; any is a box that can hold any conforming type at run time.

Generics let you write one function or type that works with many types, and constraints limit those types to ones that have the abilities you need.

Swift uses static dispatch when it knows the exact method, table dispatch for class overrides and protocol requirements, and message dispatch for @objc dynamic.

ARC counts strong references to each class instance and frees the instance as soon as the count reaches zero, with retain and release calls inserted by the compiler.

A strong reference keeps an object alive, a weak reference does not and becomes nil when the object dies, and an unowned reference does not and crashes if used after the object dies.

A retain cycle happens when objects hold strong references to each other so their counts never reach zero; you break it by making one link weak or unowned.

Check that deinit runs, use Xcode's Memory Graph Debugger to see who holds an object, use the Leaks and Allocations instruments, and add tests that assert objects are freed.

GCD is a lightweight C-based API for running closures on queues, while OperationQueue is a higher-level Objective-C API built on GCD that adds dependencies, cancellation and concurrency limits.

An async function can pause at each await without blocking its thread, letting Swift run other work on that thread until the result is ready.

An actor is a reference type that protects its mutable state by running only one task at a time on it, and reentrancy means its state can change while one of its methods is suspended at an await.

@MainActor is a global actor that runs code on the main thread, and marking UI types and methods with it lets the compiler check that UI updates happen there.

Sendable marks types whose values can safely cross between concurrency domains, like tasks and actors, without causing data races.

Cancellation in Swift is cooperative; cancel() only sets a flag, and your code must check Task.isCancelled or call try Task.checkCancellation() to stop.

A deadlock is when threads wait for each other forever, a data race is unsynchronized access to the same memory with at least one write, and a race condition is a logic bug that depends on timing.

Run an action only after the calls stop for a short time, like a search box that waits until the user stops typing.

Run an action at most once per time window. The first call runs right away, and the last call in the window runs when the window ends.

Retry a failing async operation, and double the wait time after each failure.

Build a bank account as an actor so many tasks can deposit, withdraw and transfer at the same time without data races.

Transform an array with async work in parallel, keep the input order, and never run more than N tasks at once.

A view controller creates its view, loads it once in viewDidLoad, then gets appear and disappear callbacks every time it shows or hides.

The frame is the view's rectangle in its superview's coordinates, while bounds is the same view described in its own coordinates.

Auto Layout solves a set of constraint equations to find each view's frame, and hugging and compression resistance priorities decide which view grows or shrinks first.

A table view keeps a small pool of cells and reuses them for new rows, so you must fully reset each cell or you will see old data.

The @State wrapper owns data inside a view, @Binding gives a child read-write access to someone else's data, @Bindable makes bindings to an @Observable object, and @Environment reads shared values from above.

The @Observable macro makes a class track reads and writes of each property, so SwiftUI only updates views that read the changed property, while ObservableObject updates every observer on any change.

SwiftUI uses identity to decide if a view is the same one as before, and identity controls how long state lives and whether changes animate or reset.

MVC is simple but leads to huge view controllers, MVVM moves logic into a testable view model, VIPER splits a screen into many small roles, and TCA uses one state, actions and a reducer.

Dependency injection means an object gets its dependencies from outside instead of creating them, which makes code easy to test and change.

A coordinator owns navigation, so view controllers do not know about each other and screens become reusable and easy to test.

Build a small DI container that registers factories by type, supports singleton and transient scopes, and throws for missing types.

Parse custom-scheme deep links and universal links into a type-safe Route enum with URLComponents.

Build a URLRequest, call try await session.data(for:), check the HTTP status code, then decode the data, and choose a session configuration for caching, timeouts or background transfers.

Codable lets the compiler generate encoding and decoding code, and you customize it with CodingKeys, decoder strategies or a hand-written init(from:).

Let URLCache handle HTTP caching with Cache-Control and ETag headers, and add your own memory and disk cache for decoded, downsampled images.

Use UserDefaults for small settings, the Keychain for secrets, files for documents and caches, and SwiftData, Core Data or SQLite for structured data you query.

Decode a real-looking API response with snake_case keys, ISO 8601 dates, nested and optional fields, and an enum that survives new values.

Build an actor that loads pages for an infinite list, ignores duplicate loads while one is running, and stops at the last page.

Build a generic cache that drops the least recently used item when it is full. Every operation must be O(1).

An app moves between not running, inactive, active, background and suspended states, with AppDelegate handling process-level events and SceneDelegate handling each window's UI lifecycle.

Swift Testing uses @Test functions with expect and require macros, parameterized tests and parallel runs by default, while XCTest uses XCTestCase subclasses and XCTAssert functions, and both can live in the same target.

Hide each dependency behind a protocol or closure, inject it, and in tests pass a test double such as a stub that returns fixed data or a spy that records calls.

Stutters are hitches where a frame misses its deadline, usually from main thread work in cell setup, image decoding, layout or offscreen rendering, so you measure with Instruments and move or remove that work.

Find the two numbers in an array that add up to a target, in one pass.

Check that every bracket in a string is closed by the same type, in the right order.

Find the biggest profit from one buy and one later sell, in a single pass.

Use binary search to find the first broken CI build with as few checks as possible.

Reverse a singly linked list in place by turning every next pointer around.

Merge overlapping calendar events into busy blocks by sorting first, then scanning once.

Group words made of the same letters by using a dictionary with a smart key.

Count how often each hashtag is used and return the k most popular ones.

For each index, multiply every other number, without division, using prefix and suffix products.

Find the longest run of unique characters with a sliding window and a dictionary.

Find the closest view that contains two given views, using superview pointers.

Walk a view tree level by level with breadth-first search and return the names of each level.

Count connected regions of filled pixels in a mask with flood fill (the "number of islands" problem).

Build a prefix tree that returns sorted search suggestions without scanning every word.

Build an email and password form with live validation, a loading state, server errors and good keyboard focus.

Build a list that loads the next page before the user reaches the end, with loading, error and empty states.

Build a search screen that waits 300 ms after typing, cancels old requests, and shows results, empty and error states.

Build a paging carousel with page dots and an auto-advance timer that pauses while the user drags.

Build a 1–5 star control that shows half stars, reacts to taps, and works with VoiceOver.

Build a Kingfisher-style library with a memory and disk cache, shared in-flight requests, downsampling, and safe cancellation in reused cells.

Design a social feed with cursor pagination, prefetching, optimistic likes and an offline cache that opens instantly.

Design 1:1 and group chat with a WebSocket, server-side ordering, delivery states, an offline outbox and push notifications.

Design a notes app that works fully offline and syncs across devices with a local database, a push/pull sync engine and safe conflict resolution.

Design a typed, testable networking layer with endpoints, a middleware chain, single-flight token refresh, safe retries and clear errors.

Design a tiny, crash-safe analytics SDK that many apps embed, with batching, disk persistence, retries with backoff, and privacy controls.