Swift

How to answer in an interview

Swift is Apple's modern, type-safe language designed for iOS, macOS, watchOS, and tvOS development. Key features include optionals for null safety, closures with simplified syntax, protocol-oriented programming, and memory management via ARC. Compared to Objective-C, Swift offers cleaner syntax, stronger type inference, no pointer arithmetic by default, and better performance through LLVM optimization. Swift also provides playgrounds for rapid prototyping and is fully interoperable with existing Objective-C codebases.

Explain like I am 5

Swift is like a newer, cleaner way to give instructions to Apple devices. It's safer because it won't let you use something that doesn't exist, and it's easier to read than the older way (Objective-C).

How to answer in an interview

`let` declares a constant — once assigned, its value cannot be changed. `var` declares a variable — its value can be reassigned. Swift encourages using `let` by default for immutability, which improves safety, clarity, and enables compiler optimizations. Constants also make intent explicit: code reading a `let` knows the value won't change. Note that for reference types assigned with `let`, the reference is constant but the object's properties may still be mutable.

Explain like I am 5

`let` is like writing something in pen — once it's there, you can't change it. `var` is like writing in pencil — you can erase and rewrite.

How to answer in an interview

Optionals are Swift's mechanism for handling the absence of a value. An optional type (e.g., `String?`) can hold either a value or `nil`. This eliminates null pointer exceptions at compile time. You safely unwrap optionals using optional binding (`if let`, `guard let`), optional chaining, or the nil-coalescing operator (`??`). Force unwrapping (`!`) is discouraged because it crashes if the value is nil. Optionals enforce explicit handling of missing values, making code more robust and self-documenting.

Explain like I am 5

Optionals are like a box that might be empty. Swift makes you check if the box has something in it before you try to use what's inside, so your app won't crash if it's empty.

How to answer in an interview

Structs are value types — when assigned or passed, they are copied, so changes to one copy don't affect the original. Classes are reference types — multiple variables can refer to the same instance, and changes through one reference are visible to all. Swift encourages using structs by default for simplicity and thread safety. Use classes when you need inheritance, identity (reference semantics), or deinitializers. Both support properties, methods, initializers, and extensions. Structs automatically get a memberwise initializer, while classes require explicit initializer definitions.

Explain like I am 5

A struct is like photocopying a document — each copy is independent. A class is like sharing a link to a Google Doc — everyone sees the same changes.

How to answer in an interview

Closures are self-contained blocks of code that can be passed around. Unlike functions, closures can capture and store references to variables from their enclosing scope (capturing values). Swift provides shorthand syntax for closures: implicit returns, shortened parameter names, and trailing closure syntax. Closures are classified as non-escaping (called within the function's scope, default) or escaping (stored or called after the function returns, requiring `@escaping`). Closures are fundamental to APIs like `map`, `filter`, `sort`, and asynchronous handlers.

Explain like I am 5

A closure is a chunk of code you can pass around like a variable. It remembers the values from where it was created, even after that code has finished running.

How to answer in an interview

Extensions add new functionality to existing types — including types you don't own — without subclassing. You can add computed properties, methods, initializers, subscripts, and even make existing types conform to new protocols. Extensions cannot add stored properties or designated initializers. They are widely used in Swift to organize code (e.g., separating protocol conformance into dedicated extensions) and to extend standard library or framework types with project-specific utilities.

Explain like I am 5

Extensions let you add new abilities to something that already exists — like adding a new chapter to a book that's already been printed.

How to answer in an interview

Swift models errors as values conforming to the `Error` protocol (typically enums). Functions that can throw errors are marked with `throws`, and callers use `do-try-catch` to handle them. The `try` keyword attempts the call, and `catch` blocks handle specific error cases. For asynchronous contexts, the `Result<Success, Failure>` type or `async throws` (Swift 5.5+) provide structured error handling. Swift's approach is explicit — unhandled errors won't compile — encouraging robust error management without exceptions.

Explain like I am 5

Swift makes you plan for things that might go wrong. You wrap risky code in a 'do-try-catch' block: you try the risky thing, and if it fails, you have a plan (catch) for what to do next.

How to answer in an interview

`map` transforms each element in a sequence using a closure and returns an array of the same size. `compactMap` is like `map` but automatically unwraps and removes `nil` results, producing a smaller array. `flatMap` has two uses: flattening nested sequences (e.g., `Int` into `[Int]`) and, in older Swift, performing optional chaining across multiple levels (now largely replaced by `compactMap`). Choose `map` when every input produces a valid output, `compactMap` when some outputs might be nil, and `flatMap` when working with nested collections.

Explain like I am 5

`map` changes every item in a list. `compactMap` changes items and throws away any that end up empty. `flatMap` takes lists inside a list and squishes them into one flat list.

How to answer in an interview

Both `weak` and `unowned` prevent strong reference cycles, but they differ in semantics. `weak` references are optional — they become `nil` when the referenced instance is deallocated, so you must safely unwrap. `unowned` references are non-optional — they must not outlive the referenced instance, and accessing them after deallocation causes a crash. Use `weak` when the referenced object may be deallocated first (e.g., delegate patterns). Use `unowned` when you are certain the reference will not outlive the object (e.g., a closure that definitely completes before the object is freed).

Explain like I am 5

`weak` is like a sticky note that says 'might be gone' — you have to check. `unowned` is like a guarantee that the thing is still there — if it's not, you're in trouble.

How to answer in an interview

Protocol-oriented programming (POP) is Swift's paradigm that favors composing behavior through protocols and their extensions over class inheritance. Protocols define contracts, and protocol extensions can provide default implementations. This enables code reuse without the fragility of class hierarchies. POP works with both structs and classes, supports protocol composition (`ProtocolA & ProtocolB`), and reduces coupling. Swift's standard library is heavily protocol-oriented (e.g., `Equatable`, `Codable`, `Hashable`). POP leads to more modular, testable, and flexible codebases compared to traditional OOP approaches.

Explain like I am 5

Instead of building everything from one big parent class, you mix and match abilities using protocols — like adding stickers to a notebook. Each protocol gives your type a new skill.

How to answer in an interview

Swift uses Automatic Reference Counting (ARC) to manage memory. Each instance has a reference count; when the count drops to zero, the instance is deallocated. Strong references increase the count. To prevent retain cycles (where two objects hold strong references to each other, preventing deallocation), use `weak` or `unowned` references. `weak` references are optional and become nil when the instance is deallocated; `unowned` references are non-optional and must not outlive the instance. Instruments and the Memory Graph Debugger help identify memory leaks.

Explain like I am 5

Swift keeps track of how many things are using each object. When nothing needs it anymore, Swift cleans it up. If two objects keep holding onto each other, they'll never be cleaned up — that's a leak, and you fix it by using weak references.

How to answer in an interview

Generics allow you to write flexible, reusable code that works with any type while preserving type safety. You define a generic function, struct, class, or protocol with a type parameter (e.g., `<T>`). Constraints (e.g., `T: Equatable`) restrict which types can be used. Associated types in protocols provide generic-like behavior within protocols. Generics eliminate code duplication for algorithms and data structures, and are used extensively in Swift's standard library (e.g., `Array<T>`, `Dictionary<Key, Value>`).

Explain like I am 5

Generics are like a recipe that works with any fruit — you write it once and it works whether you use apples, oranges, or bananas.

How to answer in an interview

Property wrappers encapsulate reusable storage logic for properties. A property wrapper is a struct or class annotated with `@propertyWrapper` that implements `wrappedValue` (the value accessed) and optionally `projectedValue` (the `$` prefix value, often used for bindings in SwiftUI). Common built-in examples include `@State`, `@Binding`, `@ObservedObject`, and `@Environment`. Custom property wrappers can enforce validation, logging, lazy initialization, or persistence. They reduce boilerplate and centralize access control logic.

Explain like I am 5

A property wrapper is like a security guard for a variable — it controls how the value is read and written, and can add extra behavior (like logging or validation) every time it's accessed.

How to answer in an interview

Swift 5.5 introduced native concurrency with `async/await` — functions marked `async` can suspend without blocking threads, and `await` marks suspension points. Structured concurrency groups async work into `Task` hierarchies, ensuring proper cancellation and error propagation. Actors provide thread-safe isolation for shared mutable state, eliminating data races without locks. `AsyncSequence` and `AsyncStream` handle asynchronous streams of values. This model replaces callback-based patterns and Combine for many use cases, producing more readable and maintainable asynchronous code.

Explain like I am 5

async/await lets Swift do long tasks (like downloading data) without freezing the app. The 'await' part tells Swift 'wait here, but don't block everything else while you wait.'

How to answer in an interview

Result builders (formerly function builders) enable declarative, DSL-like syntax by transforming a sequence of expressions into a single return value. The `@resultBuilder` attribute marks a type that provides `buildBlock`, `buildOptional`, `buildEither`, and other methods. SwiftUI uses `@ViewBuilder` extensively — allowing multiple child views to be written as a flat list that the builder assembles into a `TupleView`. Result builders power not only UI code but also SQL query builders, HTML generators, and configuration DSLs.

Explain like I am 5

Result builders let you write code that looks like a list of instructions, and Swift automatically combines them into one big block — like stacking LEGO bricks that snap together.

How to answer in an interview

Type erasure wraps a concrete type behind a protocol-conforming wrapper so it can be stored in collections or passed where only the protocol type is known. Swift provides built-in type erasers: `AnySequence`, `AnyPublisher`, and `AnyView`. Without type erasure, you cannot store protocol existentials in arrays when the protocol has associated types. Custom type erasure involves creating a private struct that holds the concrete instance and forwards protocol method calls. It trades compile-time type information for runtime flexibility.

Explain like I am 5

Type erasure is like putting different toys in identical boxes — you can carry them all together, but you have to open the box to see which toy is inside.

How to answer in an interview

Swift's standard library collections (Array, Dictionary, Set, String) use copy-on-write (COW) internally. When a collection is copied, no actual duplication occurs — both references share the same storage. A deep copy only happens when one of the copies is mutated. This gives value-type semantics (independent copies) with reference-type performance (shared storage until mutation). You can implement COW in custom types by checking `isKnownUniquelyReferenced` before mutating shared buffer storage.

Explain like I am 5

Copy-on-write is like sharing a Google Doc — everyone reads the same copy until someone edits it, at which point they get their own personal copy to change.

How to answer in an interview

Swift 5.9 introduced macros — compile-time code generation that transforms syntax using explicit macro definitions. Macros are declared with `macro` keyword and expanded by macro implementations (written in Swift using the SwiftSyntax library). They come in three roles: `expression` (replace with an expression), `declaration` (add declarations), and `accessor` (add property accessors). Examples include `#stringify` (returns an expression and its string representation) and `@Observable` (auto-generates observation plumbing). Macros replace some use cases of code generation tools and reduce boilerplate while remaining type-safe.

Explain like I am 5

Macros are like templates that fill themselves in when you compile — you write a short instruction, and Swift expands it into the full code for you.

How to answer in an interview

Swift offers multiple concurrency mechanisms: Grand Central Dispatch (GCD) with `DispatchQueue` for queue-based threading, `Operation` and `OperationQueue` for complex task dependencies, and the modern actor model (Swift 5.5+) for thread-safe isolation. `@MainActor` guarantees execution on the main thread for UI updates. Actors use mutual exclusion — only one task can access an actor's state at a time — eliminating data races without manual locking. Combine `async/await` with actors for clean, race-free concurrent code. Traditional locks (`NSLock`) are still available but discouraged in favor of actors.

Explain like I am 5

Threading is like having multiple workers doing jobs at the same time. Swift's actors are like a single-person elevator — only one person can use it at a time, preventing crashes.

How to answer in an interview

Opaque types (`some Protocol`) hide the concrete type from the caller while preserving it at compile time — the compiler knows the exact type and can optimize accordingly. Existentials (`any Protocol`) erase the type entirely, storing a box with dynamic dispatch — more flexible but with performance overhead and restrictions (e.g., cannot use associated types without `any`). Opaque types are preferred when the return type is fixed but you want to hide implementation details (common in SwiftUI). Existentials are used when you genuinely need to store different conforming types in the same variable.

Explain like I am 5

Opaque types are like a gift with no label — you know exactly what's inside, but the wrapping hides it. Existentials are like a grab bag — it could be anything inside, and Swift has to figure it out at runtime.