Question 1

How does Automatic Reference Counting work in Swift, and what are the three most common patterns that produce retain cycles in real iOS codebases? Walk me through how you detect and fix each one.

Accepted Answer

A strong answer explains that ARC inserts retain/release calls at compile time rather than runtime, then covers delegate cycles (strong delegate property), closure captures (capturing self strongly inside a stored closure on self), and parent-child object graphs (two objects holding strong references to each other). Candidate should name weak and unowned, explain when each is safe, and mention the Memory Graph Debugger or Instruments Allocations to detect leaking objects.

Question 2

You have a codebase that uses DispatchQueue heavily. A colleague wants to migrate to async/await. What are the concrete differences in thread ownership, stack suspension, and error propagation, and what would you actually migrate versus leave alone?

Accepted Answer

A strong answer covers: async/await suspends the logical call stack without blocking a thread (cooperative threading), GCD blocks an OS thread while waiting, structured concurrency with TaskGroup vs. DispatchGroup, and how async/await throws propagates naturally while GCD needs Result callbacks or semaphores. The migration advice should flag callback-heavy networking and URLSession as easy wins, while noting that code relying on DispatchQueue-specific ordering guarantees or C interop may be better left alone.

Question 3

A user reports your app's memory climbs every time they navigate to a detail screen and back. Walk me through exactly how you use Xcode's Memory Graph Debugger to find the leak, from launching the app to pinpointing the retain cycle.

Accepted Answer

A strong answer covers: profile in debug build with MALLOC_STACK_LOGGING, navigate the leaking path several times, tap the memory graph icon in the debug bar, filter by class name, inspect the reference graph to find the cycle, hover over edges to see reference kinds (strong/weak), and correlate with the call stack from the allocation backtrace. Candidate should mention that dismissing a view controller that stays alive is the classic symptom.

Question 4

Why does UIKit require all view updates to happen on the main thread, what actually goes wrong at the framework level if you violate this, and how do you audit a large codebase for accidental background UIKit calls?

Accepted Answer

A strong answer explains that UIKit's internal data structures are not thread-safe (no locks), that concurrent mutations cause crashes or rendering artifacts rather than clean errors, and that the run loop and CoreAnimation transaction commits are tied to the main thread's display link. Auditing options: Main Thread Checker in Xcode diagnostics (catches at runtime), static analysis, or wrapping UIView subclasses with a custom assertion in debug builds.

Question 5

A label and an image view sit side-by-side in a horizontal stack. Sometimes the label truncates and sometimes the image shrinks. Explain content compression resistance and content hugging priorities and walk me through exactly which priority values you would set to fix this layout.

Accepted Answer

A strong answer defines compression resistance as resistance to being squished below intrinsic size (default 750) and hugging as resistance to growing beyond intrinsic size (default 250). To keep the image at its natural size and let the label compress: raise the image's compression resistance above the label's (e.g. 751 vs 750) or lower the label's. To prevent the image from stretching: raise the image's hugging priority. Candidate should mention that equal priorities cause ambiguity warnings at runtime.

Question 6

You receive a JSON payload where the date is a Unix timestamp integer, nested address fields need to be flattened into your model, and some keys differ from your Swift property names. How do you handle all three with Codable without writing a completely custom init(from:)?

Accepted Answer

A strong answer covers: dateDecodingStrategy = .secondsSince1970 on JSONDecoder for timestamps, CodingKeys enum for key renaming, and a custom init(from:) using a nested container (container.nestedContainer(keyedBy:forKey:)) to flatten nested address without reimplementing all other properties. Candidate should mention AnyCodingKey as a technique for dynamic key names.

Question 7

Explain the practical difference between value and reference semantics in Swift, describe how copy-on-write works for Array and Dictionary, and give an example where accidentally sharing reference semantics caused a subtle bug.

Accepted Answer

A strong answer contrasts struct (copied on assignment, no shared state) with class (reference counted, shared state), explains CoW as the optimization where Array/Dictionary share a buffer until a mutation is attempted then copy, and gives a concrete bug like passing a class containing a mutable array and mutating it in a closure thinking a copy was made. Candidate should know isKnownUniquelyReferenced for implementing custom CoW types.

Question 8

Walk me through exactly how SwiftUI's diffing and update mechanism works. When a @State variable changes, what happens under the hood before pixels change on screen?

Accepted Answer

A strong answer covers: @State change triggers an invalidation of the owning view, SwiftUI calls body again to produce a new view value (a value type description, not a real view tree), the framework diffs the attribute graph rather than a view hierarchy, only changed subtrees are committed to the render tree, and layout plus drawing happen on the main thread. Candidate should distinguish the attribute graph from UIKit's layer tree and explain why making body cheap is critical to frame rate.

Question 9

Explain how Swift actors work at the concurrency level. What guarantees do they provide, what are their limits, and how do you access actor-isolated state from a non-isolated context?

Accepted Answer

A strong answer explains that actors serialize access to their mutable state through an executor, that accessing actor-isolated properties from outside requires await, that the compiler enforces isolation at the call site, and that actors do not protect value types passed in or out (Sendable matters here). Candidate should mention MainActor as a special global actor and the difference between actor reentrancy and true thread safety.

Question 10

What is Swift's Optional type actually? Describe its representation, how the compiler handles optional chaining at the IR level, and what nil-coalescing compiles down to.

Accepted Answer

A strong answer explains Optional is a generic enum with .none and .some(Wrapped) cases, that the compiler can optimize away the discriminant for pointer types using spare pointer bits (making Optional zero-cost for class references), and that optional chaining desugars to if-let bindings with early exits. Nil-coalescing compiles to a branch that returns the wrapped value or the default expression.

Question 11

Explain the difference between a generic function, a function taking a protocol existential (any P), and one returning an opaque type (some P). When would each approach give you better performance or cleaner API?

Accepted Answer

A strong answer distinguishes: generics are monomorphized by the compiler giving static dispatch and potential inlining, existentials carry a runtime type box and use dynamic dispatch, opaque types (some P) are reverse generics where the caller does not know the concrete type but the compiler does. Performance preference: generics greater than opaque types for return values greater than existentials in hot paths. API preference flips when you need heterogeneous collections (existentials) or want to hide implementation details.

Question 12

Your app has a background import of thousands of objects into Core Data while the main context drives a table view. Walk me through the correct concurrency pattern and what goes wrong when developers get it wrong.

Accepted Answer

A strong answer covers NSManagedObjectContext concurrency types (mainQueueConcurrencyType, privateQueueConcurrencyType), that NSManagedObject instances are not thread-safe and must only be used on their owning context's queue, the parent-child context pattern where a private child imports and saves to the parent main context, and NSFetchedResultsController for reacting to changes. Common errors: passing managed objects across contexts causing crashes or stale data, forgetting to call performBlock.

Question 13

Compare the @Observable macro introduced in iOS 17 with the earlier ObservableObject protocol. What problem does @Observable solve, and what migration pitfalls should you watch for in an existing codebase?

Accepted Answer

A strong answer explains that ObservableObject publishes changes at the object level (any @Published property change re-renders all subscribers), while @Observable uses per-property observation so only views that actually read a property re-render. Migration pitfalls: removing @Published annotations, @State replaces @StateObject for @Observable types, @ObservedObject/@EnvironmentObject drop the wrapper but the injection pattern changes. Candidate should note iOS 17 minimum deployment requirement.

Question 14

Your app's cold launch time is 3.2 seconds and users are complaining. Walk me through the phases of app launch, where time is most commonly lost, and which Instruments template or metric you use to find the bottleneck.

Accepted Answer

A strong answer names pre-main time (dyld loading dynamic libraries, running +load methods, static initializers) and post-main time (application:didFinishLaunchingWithOptions, first frame render). Tools: App Launch instrument or MetricKit. Fixes for pre-main: reduce dynamic frameworks, move +load to +initialize, use fewer singletons with static initializers. Fixes for post-main: defer non-critical work, use background threads, pre-render with snapshot APIs.

Question 15

You need to fetch data for fifty user profiles in parallel, but you want at most ten requests in flight at once and the whole operation should cancel cleanly if the enclosing task is cancelled. How do you structure this with Swift's structured concurrency?

Accepted Answer

A strong answer uses withThrowingTaskGroup(of:) adding child tasks, checks task cancellation via try Task.checkCancellation() or isCancelled inside each child, and throttles concurrency by only adding the next task after collecting a result (a semaphore-style approach using the for-await loop over group). Cancellation of the parent task propagates to all child tasks automatically in structured concurrency.

Question 16

A junior engineer stores an OAuth access token in UserDefaults because it is simple. What security risks does that introduce on iOS, and what would you use instead? What Keychain access control options would you set for a token that should not be accessible when the device is locked?

Accepted Answer

A strong answer notes UserDefaults is a plist stored in the app sandbox without encryption, accessible in unencrypted device backups and in principle readable by tools on a jailbroken device. Keychain items are encrypted by the Secure Enclave keying infrastructure and have data protection classes. For a token that should be inaccessible when locked: kSecAttrAccessibleWhenUnlockedThisDeviceOnly with kSecAccessControlBiometryCurrentSet or UserPresence. Candidate should mention SecItemAdd/SecItemCopyMatching API.

Question 17

Walk me through how you write XCTestCase tests for a function marked async throws in Swift. How do you test error paths, timeout behavior, and actor-isolated code?

Accepted Answer

A strong answer covers marking test functions async throws (XCTest handles the expectation pump automatically), using XCTAssertThrowsError for error paths (noting you need the async variant via do/catch with XCTFail), and testing actor-isolated code by calling await actor.method() directly. For timeout behavior: wrap with Task { try await Task.sleep(nanoseconds:) } or use the newer swift-testing #expect(throws:) API. Candidate should mention that older await-in-test patterns using XCTestExpectation are still valid but verbose.

Question 18

A scroll view is dropping frames. Describe step-by-step how you use the Time Profiler instrument to find what is burning CPU, how you read the call tree, and how you separate your own code from system frameworks.

Accepted Answer

A strong answer covers: profile on device (not simulator), use Time Profiler with the Display template to correlate with frame drops, look for the highest self-time entries in the call tree, enable Hide System Libraries to isolate app code, and look for cell reuse path, image decoding, or JSON parsing as typical culprits. Candidate should mention the Core Animation instrument alongside Time Profiler to see commit and render times separately.

Question 19

Explain the UIScene lifecycle introduced in iOS 13, how it differs from AppDelegate lifecycle, and what you must implement to support multiple windows on iPadOS.

Accepted Answer

A strong answer explains that UIScene decouples the concept of a UI session from the process: multiple scenes can exist in one process, each with its own SceneDelegate and lifecycle (willConnectTo, sceneDidBecomeActive, sceneWillResignActive, etc.). For multi-window on iPad: configure UIApplicationSceneManifest in Info.plist with Enable Multiple Windows, implement application(_:configurationForConnecting:options:) in AppDelegate to supply a scene configuration, and restore scene state via NSUserActivity. AppDelegate now handles process-level events, SceneDelegate handles UI-level.

Question 20

A user starts a large file download, then backgrounds the app and eventually it is suspended. How does URLSession background session keep the download running, how does your app get notified when it completes, and what are the constraints?

Accepted Answer

A strong answer covers: URLSession with background configuration hands the download to the OS daemon (nsurlsessiond), the app is suspended or even terminated, completion wakes the app via application(_:handleEventsForBackgroundURLSession:), the app recreates the session with the same identifier to drain the event queue, and calls the completionHandler. Constraints: no streaming, only file downloads/uploads, limited on cellular without allowsCellularAccess, and background tasks are at OS discretion.

Question 21

You have a ViewModel that exposes a Combine publisher. How do you write a deterministic XCTest that verifies the sequence of output values and completion without relying on real time or real network calls?

Accepted Answer

A strong answer uses XCTestExpectation with a sink subscriber, collects emitted values into an array and fulfills the expectation on the expected count, and waits with a timeout. For determinism: inject a mock publisher via protocol or PassthroughSubject controlled by the test, use ImmediateScheduler or TestScheduler from CombineSchedulers to avoid real time. Candidate should mention cancelling subscriptions in tearDown to avoid interference.

Question 22

You are setting up Xcode Cloud for a team that has unit tests, UI tests, and needs beta distribution to TestFlight. What workflows would you create, what build settings pitfalls should you watch for, and how do you handle secrets like API keys?

Accepted Answer

A strong answer describes at minimum: a PR workflow that builds and runs unit tests on every pull request, a nightly workflow that runs full UI tests and distributes to TestFlight internal group. Pitfalls: mismatched provisioning profiles, hardcoded bundle IDs in test targets, UI tests that depend on device state. Secrets: use Xcode Cloud environment variables (never commit .env files), inject at build time with build scripts using xcconfig references.

Question 23

Explain the Sendable protocol in Swift's concurrency model. What does it guarantee, how does the compiler check conformance, and what are the escape hatches like @unchecked Sendable and when are they acceptable?

Accepted Answer

A strong answer defines Sendable as a marker protocol indicating a type is safe to share across concurrency domains, that the compiler performs semantic checks on struct members (all must be Sendable), and that classes need manual declaration because the compiler cannot verify their internals. @unchecked Sendable is appropriate for types that are thread-safe internally via locks (like dispatch queue-protected wrappers) but should be narrowly used and documented. @Sendable on closures prevents capturing non-Sendable state.

Question 24

Your iOS app has a cold launch time over five seconds on older devices. How would you diagnose and reduce it?

Accepted Answer

Measure first with Instruments and real devices, separating pre-main time from work after application launch. Common wins include reducing dynamic frameworks, delaying non-critical SDK initialisation, moving network and database work off the launch path, and making the first screen render from cached state. The answer should mention that AppDelegate and scene setup often become dumping grounds for analytics, feature flags and dependency graph construction. Optimisation should preserve correctness by defining what the user must see at first interactive frame. Candidates trip up by optimising isolated functions without proving they affect launch metrics.

Question 25

When Swift dispatches a method call through a protocol existential, how does it find the implementation? Compare this to class vtable dispatch and explain when each has a meaningful performance cost.

Accepted Answer

A strong answer describes protocol witness tables (PWT) stored alongside existential containers, explains the five-word existential container layout (a three-word inline value buffer, one value-witness table pointer, one protocol witness table pointer), contrasts this with vtable dispatch through a class isa pointer, and notes that existentials on large value types cause heap allocation because they do not fit in the three-word buffer. The performance nuance is that both are indirect calls but existentials add indirection through the container and can inhibit specialization, which matters in tight loops.

Question 26

Explain how the Combine framework's demand model works. When would you see a subscriber receive more values than it requested, and how would you debug a pipeline where the subscriber is being flooded?

Accepted Answer

A strong answer covers the Subscriber protocol's receive(subscription:) and receive(_:) methods, that subscribers signal demand via Subscribers.Demand, that some publishers (PassthroughSubject) ignore demand and buffer or drop, and that operators like buffer(size:prefetch:whenFull:) or debounce help tame flooding. Debugging involves print() operator insertion or breakpoints in receive.

Question 27

Describe what a property wrapper is in Swift, implement a @Clamped wrapper that constrains a numeric value to a closed range, and explain what projectedValue enables and when you would use it.

Accepted Answer

A strong answer shows the @propertyWrapper attribute, a wrappedValue computed property that clamps on set, and optionally a projectedValue that could expose the range itself or a publisher. Candidate should note that property wrappers on function parameters are not fully supported in Swift 5.9 and that SwiftUI's $ prefix access uses projectedValue.

Question 28

GeometryReader is often misused in SwiftUI. Describe what it does, what layout problems it introduces, and what you use instead when you just need to know a child's size.

Accepted Answer

A strong answer explains GeometryReader expands to fill all available space (unlike most views), reads the proposed size not the actual content size, and using it just to size a child creates a layout pass problem. Better alternatives: .overlay with GeometryReader to measure without affecting layout, the newer onGeometryChange modifier (iOS 17), or preference keys to pass child sizes up. Candidate should note that GeometryReader is valid for custom full-screen layouts.

Question 29

Explain what a result builder is in Swift, how the compiler transforms a SwiftUI body that mixes conditional views and for-each into valid Swift, and what the limitation is when you have more than ten child views.

Accepted Answer

A strong answer explains @resultBuilder transforms block syntax using static buildBlock, buildOptional, buildEither, etc., that the compiler generates calls to these methods at the call site, and that SwiftUI's ViewBuilder conforms to this. Historically the ten-view limit came from buildBlock overloads that capped out at around ten generic parameters, and Group was the workaround. Swift 5.9 removed this limit via parameter packs (SE-0393), so modern SwiftUI targets no longer hit it, but candidates working on pre-iOS 17 codebases still need to know Group. Candidate should note result builders are general-purpose, not SwiftUI-specific.

Question 30

Describe how Core Animation layers are composited on iOS. What is the render server, why does offscreen rendering cause frame drops, and how do you detect it?

Accepted Answer

A strong answer explains that Core Animation runs in a separate render server process (renderserverd), that layer trees are serialized and sent across XPC, and that the GPU composites final frames. Offscreen rendering (masks, shadows with custom paths, shouldRasterize when size changes) forces an extra GPU render pass to an offscreen buffer before compositing. Detection: Core Animation instrument with Color Offscreen-Rendered Yellow overlay. Fix: use shadowPath for pre-computed shadow shapes, rasterize static complex layers, avoid cornerRadius with masksToBounds on animated views.

Questions

Explain ARC and the three most common retain cycle patternsRole-specificmediumVery common

As asked

Sample answer outline

Expect these follow-ups

Compare async/await to GCD DispatchQueue for iOS concurrencyRole-specificmediumVery common

As asked

Sample answer outline

Expect these follow-ups

Walk through finding a memory leak with the Memory Graph DebuggerRole-specificmediumVery common

As asked

Sample answer outline

Expect these follow-ups

Why must UIKit calls happen on the main thread?Role-specificmediumVery common

As asked

Sample answer outline

Expect these follow-ups

Content compression resistance vs content hugging in Auto LayoutRole-specificmediumVery common

As asked

Sample answer outline

Expect these follow-ups

Custom Codable decoding for mismatched JSON shapesRole-specificmediumVery common

As asked

Sample answer outline

Expect these follow-ups

Value semantics vs reference semantics and copy-on-writeRole-specificmediumVery common

As asked

Sample answer outline

Expect these follow-ups

How does SwiftUI decide when to re-render a view?Role-specifichardCommon

As asked

Sample answer outline

Expect these follow-ups

How do Swift actors prevent data races?Role-specifichardCommon

As asked

Sample answer outline

Expect these follow-ups

What is Optional in Swift under the hood?Role-specificmediumCommon

As asked

Sample answer outline

Expect these follow-ups

Difference between generics, existentials, and opaque types in SwiftRole-specifichardCommon

As asked

Sample answer outline

Expect these follow-ups

How does Core Data handle concurrency across contexts?Role-specifichardCommon

As asked

Sample answer outline

Expect these follow-ups

@Observable macro vs ObservableObject: what changed in iOS 17?Role-specificmediumCommon

As asked

Sample answer outline

Expect these follow-ups

Diagnosing and reducing iOS app launch timeRole-specifichardCommon

As asked

Sample answer outline

Expect these follow-ups

Using TaskGroup for parallel async work in SwiftRole-specifichardCommon

As asked

Sample answer outline

Expect these follow-ups

When to use Keychain versus UserDefaults for sensitive dataRole-specificmediumCommon

As asked

Sample answer outline

Expect these follow-ups

How do you unit test async/await code in XCTest?Role-specificmediumCommon

As asked

Sample answer outline

Expect these follow-ups

Finding CPU hotspots with Time Profiler in InstrumentsRole-specificmediumCommon

As asked

Sample answer outline

Expect these follow-ups

SceneDelegate and multi-window support on iPadOSRole-specificmediumCommon

As asked

Sample answer outline

Expect these follow-ups

How does URLSession background download work on iOS?Role-specifichardCommon

As asked

Sample answer outline