Mastering the iOS Interview

Explain how memory management evolved from manual retain and release to automatic reference counting, detailing the reference counter, ARC compiler actions, and Swift's memory safety with optionals.

Closures are blocks of code passed around like functions, with inputs and outputs, and are commonly used as parameters for asynchronous tasks like updating the UI after a network fetch.

Identify how strong reference cycles cause memory leaks in Swift, with examples like view controllers and delegates, and prevent them by using weak references and weak self in closures.

Explain how the final keyword marks a class as non-inheritable and non-overridable, clarifying intent and enabling static dispatch, reducing dynamic dispatch overhead and improving runtime performance.

Explain how Swift value types, including structs and primitive types like integers, doubles, strings, dictionaries, and arrays, keep copies while reference types share data, with copy-on-write delaying copies until updates.

Use value types for data or state entities like user information to avoid side effects, and reference types for services that modify data, to ensure code base consistency.

Learn how the escaping keyword applies to closures passed as function parameters, escaping to asynchronous blocks, memory management, and how Xcode reminders enforce this in Swift.

Master performing all UI updates on the main thread to prevent glitches when using multi-threading, and learn why returning to the main thread ensures correct UI behavior.

Use the rule that the presenting controller dismisses a presented view controller. Implement a delegate protocol so the home controller dismisses with flexible, reusable animations in modal or navigation contexts.

Compare core foundation and foundation, two frameworks that provide basic types and collections used by most apps, noting foundation follows native patterns while core foundation targets legacy objective-c memory.

Learn the iOS app life cycle: not running, inactive, active foreground, background, and suspended; transitions include launch, become active, enter background, resume, and possible OS termination, with delegate methods.

Distinguish bounds from frame in iOS views: bounds define internal size, while frame defines position relative to the parent; consider origin and rotation, scaling, constraints.

Learn how to enlarge a button’s touch area beyond its visible bounds by overriding hit-testing logic and implementing a custom touch-detection approach, with emphasis on identifying the override method.

Learn how Grand Central Dispatch (GCD) from Apple provides a high level API to execute code on multiple threads, synchronously or asynchronously, with easy thread switching and coordination.

Learn how operations and operation queues provide a high-level api for managing code execution on the main and background threads, enabling dependencies, priorities, and coordination in the Apple ecosystem.

Explore what unit tests cover, testing base models and services, using given-when-then structure, and applying dependency injection; compare functional, integration, and snapshot testing, plus coverage cost.

Learn best practices for third party dependencies: avoid unnecessary use, weigh costs and security vulnerabilities, avoid inconsistency from dependencies, and aim to use as few as possible to demonstrate seniority.

Compare CocoaPods, Carthage, and SwiftPM as centralized, decentralized, and Apple-created package managers that share reusable modules across projects, with attention to setup, performance, and UI kit support.

Learn how dependency injection enables testable code by passing dependencies from outside, using initialization-based injection, protocols, and mocks to swap real services during unit tests.

Analyze MVC drawbacks where business logic creeps into controllers, and how VM adds a view model layer to separate concerns; weigh tradeoffs between MVC simplicity and VIPR complexity.

The singleton pattern, widely used, ensures only one instance of a class. Misuse occurs when developers skip dependency injection and access the shared instance anywhere, reducing testability and scalability.

Learn how private, internal, public, and open access levels control visibility in a module, exposing only selected classes, functions, and properties while hiding implementations.