Top 80+ iOS Interview Questions and Answers [2026 Edition]

Prepare for success with this definitive list of Top 80+ iOS Interview Questions updated for Swift 6 and iOS. From core memory management to advanced System Design architectures, we cover the exact questions asked by top tech giants like Apple, Uber, and Amazon. Whether you are a Fresher or a Senior Architect, this guide is your ultimate roadmap to mastering the modern iOS ecosystem.”

1. Explain the different types of iOS Application States.

You will experience a few app states while using the application. There are five states in the iOS application as follows.

• Not Running: The application is in the Not running state if the app is not launched yet, or if the application is terminated by the user or by the OS.
• Inactive: An inactive state occurs when the application is not receiving events. 
• Active: In this state, the app runs in the foreground, and the UI is accessible.
• Background: Before being suspended, most apps enter this state. If an app requests extra execution time, then that will remain in this state for some more time.
• Suspended: In a suspended state, the application does not execute any code. The system purges suspended apps without notice to make more space when a low-memory condition occurs.

2. How is memory management handled on iOS?

Memory management is crucial in any application, especially in iOS applications, due to memory and other limitations. ARC, MRC, reference forms, and value types are all included. Every iOS developer should be aware of this! Memory leaks and system crashes are all too common in iOS apps due to poor memory management.

3. What is Swift, and what is Objective-C?

Swift is a modern programming language created by Apple for iOS, OS X, watchOS, and tvOS. It combines the best of C and Objective-C without the C compatibility issues. Swift follows secure programming patterns and incorporates modern features to make programming simpler, versatile, and enjoyable.

Objective-C is the primary object-oriented programming language used for OS X and iOS. It is a superset of the C programming language that adds class and process definition syntax while retaining C’s primitive types and flow control statements.

Table of Contents:

• Module 1: iOS Fundamentals and Language Core
• Module 2: User Interface (UIKit and SwiftUI)
• Module 3: Architecture and Design Patterns
• Module 4: Concurrency, Networking, and Security
• Module 5: Data Persistence and System Optimization

Module 1: iOS Fundamentals and Language Core

4. What is the difference between struct and class in Swift?

The fundamental difference between them is the way data is passed:

• Structs are Value Types: When you are assigning or passing a struct, a copy of the data is created. They are stored on the Stack.
• Classes are Reference Types: When we assign or pass classes, we create references or pointers to the same instance. They are stored in the Heap (slower, handled by ARC).

5. What are Generics in Swift?

Generics enable you to create versatile and reusable functions and types that are applicable to all types, provided certain conditions are met by you. They avoid code duplication and provide Type Safety. Instead of writing separate functions for Int, String, and Double, you write one function using a placeholder such as <T>.

Code Example (Generic Swap Function):

// 'T' is a placeholder for any type

func swapValues<T>(_ a: inout T, _ b: inout T) {

    let temp = a

    a = b

    b = temp

}

var x = 10, y = 20

swapValues(&x, &y) // Works with Int

var str1 = "Hello", str2 = "World"

swapValues(&str1, &str2) // Works with String

6. What is an Optional in Swift, and how do you unwrap it safely?

An Optional is a type that handles the absence of a value. It can either hold a value or be nil. You define it by adding a ? after the type (e.g., String?).

To use the value inside an optional, you must “Unwrap” it.

• Unsafe Unwrapping (!): Forces access. Crashes the app if nil.
• Safe Unwrapping: Checks for nil before accessing.

Best Ways to Safely Unwrap:

if let (Optional Binding): Unwraps the value only if it exists.

var name: String? = "John"

if let safeName = name {

    print("User is \(safeName)")

} else {

    print("No name found")

}

guard let (Early Exit): Ensures the value exists before continuing the function. Preferred for cleaner code.

func greet(user: String?) {

    guard let safeUser = user else {

        print("User is nil!")

        return // Exits function immediately

    }

    print("Hello, \(safeUser)") // safeUser is available here

}

Nil Coalescing (??): Provides a default value if the optional is nil.

let username = name ?? "Guest"

7. What are the characteristics of iOS?

iOS is a proprietary mobile operating system developed by Apple, which is known for its security, smoothness, and integration with its ecosystem.

• Multitasking: It enables the user to switch applications quickly while efficient processing of background applications like audio or location continues.
• Social Media Integration: The integration is so deep that sharing content like photos and links is seamless.
• iCloud: Automatically synchronizes data, pictures, and contacts across all Apple devices.
• Security: It is based on a secure architecture with App Sandboxing, FaceID, and end-to-end encryption.
• Interface: Intuitive Multi-Touch gestures such as Tap, Swipe, and Pinch that define the modern smartphone experience.
• GPS & Maps: Precise location services for navigation and location-based apps.

8. What is Operator Overloading?

The process of adding new operators and changing existing ones to do various things is known as operator overloading.

+, *, and / symbols are known as operators.

9. What is iOS?

iOS stands for “iPhone Operating System,” which is used in the devices that Apple manufactures, whether they be iPhones or iPads. It is considered to be the second-most popular operating system in the world.

10. Mention a few key features of the iOS platform.

The key features of the iOS platform are the following: 

• Multitasking capabilities
• iCloud is used to store data on the cloud that can be accessed by any other Apple device where your ID is logged in.
• iOS is a closed system, which means the source code of Apple’s apps isn’t available to developers.
• Seamless integration with other Apple devices.

11. What are property observers?

As the name suggests, the Property Observer observes and responds to the change in property value. So wherever a value of the property is set, the property observer gets called.

12. What is an NSError in Swift?

The NSError class is a Cocoa class. The knowledge about an error condition is encapsulated in an extendable, object-oriented manner by an NSError object. It includes a predefined error domain, a domain-specific error code, and a user details dictionary with application-specific data.

13. What is the difference between retain and assign?

Assign creates a reference from one object to another without increasing the source’s retain count.

if (_variable != object)

{

[_variable release];

_variable = nil;

_variable = object;

}

Retain creates a reference from one object to another and increases the retain count of the source object.

if (_variable != object)

{

[_variable release];

_variable = nil;

_variable = [object retain];

}

14. What is Dynamic Dispatch?

At runtime, Dynamic Dispatch determines which implementation of a polymorphic procedure, such as a method or a function, to call. This means that when we want to call our methods, such as object methods, we must use this syntax. Swift, on the other hand, does not use dynamic dispatch by default.

15. Do private methods exist in Objective-C?

Yes, Objective-C does contain private methods. Private methods are methods that are only accessible within the class they are defined in, and are not visible to other classes or objects. They can be used to encapsulate implementation details and prevent them from being accessed or modified by external code.

16. Explain the term ARC.

ARC stands for Automatic Reference Counting. It is used to manage the app’s memory usage by initializing and de-initializing it.

17. Which programming languages are used for iOS development?

The following languages are used in iOS development : 

1. Swift
2. Objective-C.
3. C++
4. .NET
5. C
6. HTML5
7. Javascript

18. Explain the lazy property in Swift?

A lazy stored property is one that does not determine its initial value until it is used for the first time. The lazy modifier is written before the declaration of a lazy stored property.

19. What is the difference between strong, weak, read-only, and copy?

These attributes define how memory is managed for properties.

20. What is the use of deinit in Swift?

Deinitialization in Swift is the method of deallocating or cleaning up unused class instance objects in order to free up memory space used by machine resources for better memory management. Until a class instance is deallocated, the deinitialization process is usually named.

21. Does Objective-C contain private methods?

No, there is nothing called a private method in Objective-C programming. If a method is defined in .m only, then it becomes protected; if it is defined in .h, it is public.

If we really want a private method, then we need to add a local category/unnamed category/class extension in the class, add the method in the category, and define it in class.m.

22. What are Swift’s advantages?

The main advantages of Swift are mentioned below:

• Easy to read
• Easy to maintain
• Extremely fast
• Dynamic libraries
• Safe programming language
• Efficient memory management
• Concise code

23. What is the difference between an ‘App ID’ and a ‘Bundle ID’? What is each used for?

The confusion arises because they look similar, but their scope is different.

• App ID: A two-part string used to identify one or more apps from a single development team. It connects your app to Apple services (like iCloud, Push Notifications).
  • Format: [Team ID].[Bundle ID] (e.g., A1B2C3D4.com.example.myapp)
• Bundle ID: A unique identifier for a single app. It is defined in Xcode and must be unique across the entire App Store.

24. What is an abstract class in Cocoa?

Cocoa doesn’t provide anything called abstract. It can create a class abstract that gets checked only at runtime, while it is not checked at compile time.

@interface AbstractClass : NSObject

@end

@implementation AbstractClass

+ (id)alloc{

if (self == [AbstractClass class]) {

NSLog(@"Abstract Class can’t be used");

}

return [super alloc];

@end

25. What is the difference between Cocoa and Cocoa Touch?

Cocoa is the application framework for macOS, while Cocoa Touch is the framework for iOS (iPhone/iPad).

26. Explain Swift’s pattern-matching techniques

• Tuple patterns: Values of corresponding tuple forms are matched using tuple patterns.
• Type-casting patterns: You can cast or mix styles using type-casting patterns.
• Wildcard patterns: Every kind and kind of value is matched by wildcard patterns, which disregard them.
• Optional patterns: To align optional values, optional patterns are used.
• Enumeration case patterns: The cases of existing enumeration forms are matched by enumeration case patterns.
• Expression patterns: You may use expression patterns to compare a given value to a given expression.

27. What is the relation between iVar and @property?

iVar is an instance variable. It cannot be accessed unless we create accessors, which are generated by @property. iVar and its counterpart @property can be of different names.

@interface Box : NSObject{

NSString *boxName;

}

@property (strong) NSString *boxDescription;//this will become another ivar

-(void)aMethod;

@end

@implementation Box

@synthesize boxDescription=boxName;//now boxDescription is accessor for name

-(void)aMethod {

NSLog(@"name=%@", boxName);

NSLog(@"boxDescription=%@",self.boxDescription);

NSLog(@"boxDescription=%@",boxDescription); //throw an error

}

@end

28. What is a Guard statement?

If one or more requirements aren’t met, a guard statement is used to pass program control out of a domain. The advantages of guard statements are as follows:

• It is another way to safely unwrap optionals
• It provides an early exit
• It avoids pyramids of doom

The guard statement is written as:

guard condition else {

statements

}

29. What are raw strings?

Raw String in Swift 5 gives us the ability to specify a custom delimiter #.

For example, when we write \n, it should act as an escape sequence, but it will be treated as a backslash, then an ‘n.’

let regularString = "\\Hello \\World"

let rawString = #"\Hello \World"#

30. How would you optimize memory usage for large datasets in iOS?

To optimize memory usage for large datasets in iOS, you can:

• Use lazy loading to load only the necessary data at the time it is needed.
• Utilize pagination to load data in smaller chunks instead of all at once.
• Use memory-efficient collections like NSPointerArray or NSSet instead of arrays where appropriate.
• Implement image caching to avoid reloading large images multiple times.
• Use Core Data with NSFetchedResultsController for efficient data handling and memory management in table views.
• Enable automatic memory management with ARC to ensure unused objects are freed promptly.

31. What is ARC, and how does it manage memory in iOS?

ARC (Automatic Reference Counting) is a memory management system in iOS (and macOS) that automatically manages the memory for objects by keeping track of the number of references to each object. When an object’s reference count reaches zero, it is deallocated. ARC eliminates the need for manual memory management, but developers still need to handle retain cycles by breaking references properly (e.g., using weak references).

Module 2: User Interface (UIKit and SwiftUI)

32. What is the difference between @State, @Binding, and @ObservedObject in SwiftUI? 

These are Property Wrappers used in SwiftUI to manage data flow and state. The difference between these two lies in Ownership and Reference, i.e., Value vs. Reference type.

• @State: It’s used for local value types such as Int, String, and Bool that are owned by the view itself. It’s the source of truth for the specific view.
• @Binding: A reference to a value owned by a parent view. This allows a child to read and write data owned by its parent view. (Two-way connection)
• @ObservedObject: Used for complex external data (Classes) that conforms to ObservableObject. This is for monitoring changes in a reference type (like a ViewModel).

33. How does SwiftUI handle layout differently from Auto Layout? 

The main difference is between Declarative (SwiftUI) and Constraint-Based (Auto Layout).

1. Auto Layout (UIKit): Makes use of a very intensive mathematical solver (Cassowary algorithm) that solves linear equations based on constraints (for instance, “View A is 10px away from View B”). It is top-down and very complex.
2. SwiftUI: Stack-Based (HStack, VStack). The layout process is divided into 3 very simple steps:
   • Step 1: The parent proposes a size to the Child.
   • Step 2: Child selects own size based on content.
   • Step 3: The parent places the Child in its coordinate space.

Why it matters: SwiftUI layout performance is much better because it does not involve exponential constraint solving.

34. What is ViewBuilder in SwiftUI?

ViewBuilder is a specialized form of a result builder in Swift. It enables you to create a view based on a closure that contains multiple childviews.

It drives the syntax of HStack, VStack, and body, which allows you to list out multiple views sequentially without having to manually return an array or complex tuple. It automatically collects the child’s views and combines them into a single view.

35. Give the name of the framework that is employed to create the iOS application’s user interface.

The UIKit framework facilitates the development of the application’s user interface. It enables event handling, drawing models, windows, views, and controls specifically designed for touch-screen interfaces.

This framework offers the following key components:

• Window and view architecture for managing the app’s user interface.
• Infrastructure for handling events and responding to user input.
• An application paradigm to control the primary run loop and communicate with the system.

36. Which is the application thread from where UIKit classes should be used?

Unless it’s stated, use UIKit classes only from your application’s main thread or main dispatch queue. This restriction applies in particular to classes derived from UIResponder or that require modifying the user interface of your app in some way.

37. How can you respond to state transitions on your app?

State transitions can respond to state changes in an appropriate way by calling corresponding methods on the app’s delegate object.

For example:

• applicationDidBecomeActive( ) method: To prepare to run as the foreground app
• applicationDidEnterBackground( ) method: To execute some code when the app is running in the background that may be suspended at any time
• applicationWillEnterForeground( ) method: To execute some code when the app is moving out of the background
• applicationWillTerminate( ) method: Called when the app is being terminated

38. What is TVMLKit?

TVMLKit serves as a bridge between TVML, JavaScript, and your native tvOS software. You can test TVMLKit JS and TVML files from inside your tvOS app using the TVMLKit framework. The JavaScript environment can be used to build TVML objects, styles, views, and view controllers.

39. What are UI Elements in iOS?

The visual elements that we can see in our applications are known as UI elements. Some of these components, such as buttons and text fields, respond to user interactions, while others, such as images and labels, provide information.

40. What are the features added in the latest iOS (iOS 26)?

• Liquid Glass Design: A new fluid design system where app icons and controls reflect and refract their surroundings, with 3D Lock Screen effects.
• Apple Intelligence: Visual Intelligence to search on-screen content, Live Translation for calls/FaceTime, and Genmoji creation.
• Communication: Polls in Messages, custom chat backgrounds, and Call Screening that answers unknown callers for you.
• Navigation & Audio: Maps now learns your Preferred Routes, and Apple Music features AutoMix and Lyrics Translation.
• New Apps: A dedicated Games App for tracking friends’ activity and a redesigned Wallet with bag tracking and airport maps.

41. What options are there for the UIView element layout specification?

Here are some common ways to specify the layout of elements in a UIView:

• By employing InterfaceBuilder, we have the capability to integrate a XIB file into our project, organize its elements, and subsequently load the XIB within our application code, either automatically based on naming conventions or manually.
• With InterfaceBuilder, we can also design a storyboard for our application.
• We can write our own code to employ NSLayoutConstraints, which enables us to arrange elements in a view using Auto Layout.
• By creating CGRects that describe the precise coordinates for each element, we can pass them to the UIView’s (id)initWithFrame:(CGRect)frame method.

42. What is SpriteKit, and what is SceneKit?

SpriteKit is a platform for creating animated 2D objects quickly and easily.

SceneKit is a platform for 3D graphics rendering that was inherited from OS X.

SpriteKit, SceneKit, and Metal are expected to boost a new generation of mobile games that push the boundaries of what the powerful GPUs in iOS devices can do.

43. Differentiate between UIView’s frame and UIView’s bounds?

A UIView’s frame is a rectangle with a scale (width, height) and position (x,y) relative to the super view it is located within.

A UIView’s bounds are a rectangle with a size (width, height) and position (x,y) relative to its own coordinate system (0,0).

44. How to Prioritize Usability in Design?

To prioritize usability, the design process has broken down into 4 steps:

• Consider the user’s perspective when designing the user experience.
• Users, not demographics, are what you should focus on.
• Consider all of the scenarios in which an app might be useful when promoting it.
• Even after the app has been released, continue to improve its functionality.

45. What is the purpose of reuseIdentifier?

The reuseIdentifier is used to group together similar rows in a UITableView, i.e., the rows that differ only in their content, otherwise having similar layouts. A UITableView will normally allocate just enough UITableViewCell objects to display the content visible in the table.

If reuseIdentifier is set to a non-nil value, then the UITableView will first attempt to reuse an already allocated UITableViewCell with the same reuseIdentifier when the table view is scrolled. If reuseIdentifier has not been set, then the UITableView will be forced to allocate new UITableViewCell objects for each new item that scrolls into view, potentially leading to laggy animations.

46. What is the difference between viewDidLoad and viewWillAppear in iOS?

The main difference is frequency and purpose of use.

• viewDidLoad: This method is called Only Once when the view is first loaded into memory. This is where you do your “One-Time Setup.”
• viewWillAppear: Called Multiple Times, every time the view is about to appear on the screen (for example, when going back to the view). This is the place for “Refreshes.”

47. Explain the difference between the frame and bounds of a UIView.

The difference is the Reference Coordinate System:

• frame: The view’s position and size relative to its Super View (Parent).
• bounds: The view’s position and size relative to itself (Internal).

48. What is the use of the UIStackView in iOS?

UIStackView is a layout container that simplifies the process of arranging views in a linear fashion (horizontally or vertically). It automatically adjusts the size and position of the arranged views based on the stack’s distribution, alignment, and spacing properties. It’s a great tool for creating dynamic layouts without needing complex constraints.

49. What are the differences between UIControl and UIView?

UIView is the parent class responsible for displaying content on the screen. UIControl is a subclass of UIView that adds specific logic to handle user interactions (like taps and touches) using the Target-Action pattern.

Module 3: Architecture and Design Patterns

50. Explain the MVVM Pattern. How is it different from MVC? 

MVVM (Model-View-ViewModel) is an architectural pattern that aims to separate the User Interface (View) from Business Logic (Model).

• Model: The data and business rules (e.g., User struct, API response).
• View: The UI (UIView/UIViewController). It simply displays data and forwards user interactions to the ViewModel.
• ViewModel: The “Brain.” It contains state, processes data, and formats it. There is no reference to UI (UIKit) in the ViewModel.

The Core Difference (MVC vs. MVVM):

In the MVC pattern, the Controller is tightly coupled with the View. This is called the Massive View Controller. In the MVVM pattern, the ViewModel is independent and hence Unit Testable.

51. What is the Coordinator Pattern, and why is it used?

The Coordinator Pattern removes Navigation Logic from View Controllers.

The Problem: In a normal MVC/MVVM pattern, View Controller A calls View Controller B (navigationController?.pushViewController(vcB, animated: true)). This creates a Tight Coupling, meaning A must know about B. To reuse A in another part of your app, you cannot, as it is hard-coded to show B.

The Solution: There’s an object that handles all routing, and it’s called Coordinator. The View Controller just says, “I’m done,” and then it’s up to the Coordinator to decide what to do next.

Key Benefits:

1. Reusability: View Controllers turn into isolated “islands” that can be used anywhere.
2. Deep Linking: Push notifications with deep linking are easy to handle.
3. Testing: You can test the navigation flows without loading the UI.

52. Unnamed categories – what are they?

The category without a name is no longer favored since the extension of @protocol to support @optional methods. We use the @interface Foo() class extension to declare additional private API, known as the system programming interface (SPI), which is utilized for implementing the internal workings of the class. This declaration is typically placed at the beginning of the .m file. All methods and properties declared within the class extension must be implemented in the @implementation, similar to the methods and properties found in the public @interface. Class extensions also provide the ability to change a publicly read-only @property to read-write before using @synthesize on the accessors.

Example:

Foo.h

@interface Foo:NSObject

@property(readonly, copy) NSString *bar;

-(void) publicSaucing;

@end

Foo.m

@interface Foo()

@property(readwrite, copy) NSString *bar;

- (void) superSecretInternalSaucing;

@end

@implementation Foo

@synthesize bar;

.... must implement the two methods or compiler will warn ....

@end

53. What is the difference between KVC and KVO?

The difference lies in their purpose:

• KVC (Key-Value Coding): A mechanism to access an object’s properties indirectly using Strings (keys) instead of invoking the property accessor methods directly.
• KVO (Key-Value Observing): A mechanism to observe (listen for) changes to an object’s property. It allows one object to be notified when another object’s property changes.

54. Define SOLID Principles in iOS Development

The SOLID principles are five design guidelines to ensure code is maintainable and scalable:

• S – Single Responsibility Principle (SRP): Each class should have only one reason to change, meaning it handles a single specific job or duty.
• O – Open/Closed Principle (OCP): Classes should be open for extension (adding new features) but closed for modification (changing existing code).
• L – Liskov Substitution Principle (LSP): Subclasses must be substitutable for their base classes without breaking the application’s logic.
• I – Interface Segregation Principle (ISP): Clients should not be forced to depend on protocols/interfaces they don’t use. Use multiple specific protocols instead of one “fat” protocol.
• D – Dependency Inversion Principle (DIP): High-level modules should depend on abstractions (Protocols), not on concrete implementations (Classes).

55. Explain a singleton class.

When only one instance of a class is created in the application, that class is called a singleton class. See below:

@interface SomeManager : NSObject

+ (id)singleton;

@end

@implementation SomeManager

+ (id)singleton {

static id sharedMyManager = nil;

@synchronized([MyObject class]){

if (sharedMyManager == nil) {

sharedMyManager = [[self alloc] init];

}

}

return sharedMyManager;

}

@end

//using block

+ (id) singleton {

static SomeManager *sharedMyManager = nil;

static dispatch_once_t onceToken;

dispatch_once(&onceToken, ^{

sharedMyManager = [[self alloc] init];

});

return sharedMyManager;

}

56. What is method swizzling?

Method swizzling is a technique that allows you to change the implementation of a method at runtime. It involves swapping the implementation of one method with another, typically within a class or its subclasses.

How it works: The process involves exchanging the implementations (function pointers) of the original method and a new custom method using the Objective-C Runtime library. When the original method is called, the system executes your new method instead.

Common Use Case: It is often used to intercept system methods (like viewWillAppear) for Logging or Analytics without needing to subclass every View Controller.

57. Why is the design pattern very important?

Design patterns are important in software design because they are reusable solutions to many common problems. They’re models for writing code that’s simple to comprehend and reuse. The most popular design trends in Cocoa are as follows:

• Creational: Singleton.
• Structural: Decorator, Adapter, Facade.
• Behavioral: Observer and Memento

58. Explain MVC.

MVC is the acronym for “Model-View-Controller.” MVC is a design pattern for web applications that consists of three interconnected components.

• Model – A model is where the data is stored.
• View – The classes in view are reusable as they don’t have any domain-specific logic. 
• Controller –  with delegation patterns, the controller acts as a communication between the model and the view.

The MVC model, also known as the “pattern,” is widely used in the development of modern user interfaces.

59. What do you mean by TDD?

TDD stands for Test-Driven Development. With the help of this feature, a developer who is creating a feature can plan for the feature, build it, and then test it before it goes to production.

60. What is Dependency Injection, and how is it used in iOS?

Dependency Injection (DI) is a design pattern where an object’s dependencies are provided (injected) to it rather than the object creating them itself. This improves modularity and testing by allowing you to inject mock objects during testing. In iOS, DI can be implemented using constructor injection, property injection, or method injection.

61. Explain the concept of ‘Design Patterns’ in iOS development. Can you name a few?

Design patterns are general, reusable solutions to common problems faced in software development. They provide a template to solve problems in a standard way. Some of the most commonly used design patterns in iOS development include:

• MVC (Model-View-Controller): Separates data, UI, and business logic.
• MVVM (Model-View-ViewModel): A variation of MVC that promotes the separation of concerns by adding a ViewModel between the View and the Model.
• Singleton: Ensures that a class has only one instance, and provides a global point of access to it.
• Delegate: Used to allow one object to send messages to another object when an event occurs.

Module 4: Concurrency, Networking, and Security.

62. Explain async and await in Swift. 

async and await are two keywords that were introduced in Swift 5.5. These keywords help in handling asynchronous code (e.g., network calls) in a clean and linear way instead of “Callback Hell” (nested closures).

• async (Asynchronous): Indicates a method that might stop executing to wait for something to happen (e.g., while fetching the data).
• await: This keyword indicates where the execution stops until the async operation finishes. The thread can be released to perform other tasks.

63. What is an Actor in Swift? 

An Actor is a reference type (similar to a Class) that is inherently thread-safe. An Actor automatically prevents Data Races because only one task can access its state at a time.

• The Problem: If two threads attempt to modify a shared data item (e.g., balance += 10) simultaneously, the data becomes corrupted.
• The Actor Solution: Actors have a “Mailbox.” When another thread tries to access an actor that’s currently busy, it has to wait(using await) until the first actor has completed its task

64. What is SSL Pinning and why is it used?

SSL Pinning is a security technique to prevent Man-in-the-Middle (MITM) Attacks.

Normally, any server’s certificate that is signed by a trusted Root Authority (CA) can be trusted by an application. However, if a hacker gains access to a CA, he/she can create a false certificate and intercept your traffic.

How Pinning Works: You no longer trust the system’s list of CAs. You “pin” the particular Server Certificate (or Public Key) into your app bundle. Your app refuses to connect to any Server that doesn’t match this particular Server Certificate, even if it has a valid certificate issued by a trusted CA.

65. Which JSON framework is supported by iOS (iPhone OS)?

• The SBJson framework is supported by iOS. It is a JSON parser and generator for Objective-C (Objective-C is the primary programming language we use when writing software for OS X and iOS). It is a superset of the C programming language and provides object-oriented capabilities and a dynamic runtime.
• SBJson provides flexible APIs and additional control that make JSON handling easy.

66. What is the difference between Synchronous and Asynchronous tasks?

Synchronous can also be defined as in order. When you perform the synchronous operation, all that follows must wait for the operation to complete before proceeding.
In contrast, “asynchronous” can also be defined as “out of order.” When you do something asynchronously, you can run the following code right away, and the asynchronous process will happen someday. It could be run on a separate thread from the rest of the code. It could easily be rescheduled on the same thread at a later date, and you can notify me when it is done.

67. What is GCD?

The GCD stands for Grand Central Dispatch. It is a low-level API that allows you to manage multiple concurrent operations. It will assist you in increasing the responsiveness of your app by bringing computationally intensive tasks to the context. It’s a simpler concurrency model than locks and threads to deal with.

68. Explain iBeacons?

Apple’s introduction of Bluetooth low-energy (BLE) wireless technology, iBeacon, is a new way for iPhones and other iOS users to receive location-based information and services.

69. What options are available for networking and HTTP on iOS?

• URLSession: The native iOS networking library. It supports HTTP/HTTPS, background downloads, authentication, and session management without needing third-party dependencies.
• Alamofire: A popular Swift-based third-party library. It offers a cleaner syntax than URLSession, with built-in features for chaining requests, response serialization, and validation.
• AFNetworking: An older, widely used Objective-C networking library. While still powerful, it is less common in modern Swift projects compared to Alamofire.

70. How can you prevent the iOS 16 app’s streaming video media from being captured?

To mitigate the risk of QuickTime Player capturing streaming video, you can:

• Utilize a third-party screen recorder: Use alternative recorders that offer encryption for the video stream.
• Employ a VPN: Encrypt data transmission, which can render QuickTime incapable of capturing the protected stream.
• Disable screen recording: Navigate to Settings > General > Restrictions on the iOS device and disable the Screen Recording feature.

71. What is Concurrency?

Concurrency is a fancy term for “running several tasks at the same time.” On iOS devices, concurrency is commonly used to allow you to run tasks such as downloading or processing data in the background while keeping your user interface responsive.

72. Mention various ways to achieve concurrency in iOS?

Mainly, there are 3 ways to achieve concurrency in iOS. There are:

• Grand Central Dispatch
• OperationQueue
• Threads

73. What is meant by deadlock?

A deadlock is a situation that occurs when at least two threads are locked on different resources, and both are waiting for the other resource to finish its job. And no one is able to unlock the resource it is guarding.

74. Explain QOS?

QoS stands for the quality of service. It is a class that organizes the work that NSOperation, NSOperationQueue, NSThread artifacts, dispatch queues, and threads do (POSIX threads). By assigning a QoS, you’re telling the system how important it is, and the system prioritizes and schedules it accordingly.

75. Describe the NSURLConnection class.

There are two ways of using the NSURLConnection class: asynchronous and synchronous.

• Asynchronous: Creates a new thread and performs its download process on that thread, allowing the UI to remain responsive.
• Synchronous: Blocks the calling thread (whichever thread fired it) while downloading the content.

To create an asynchronous connection, you typically:

1. Convert an NSString URL to an NSURL.
2. Wrap it in an NSURLRequest.
3. Pass the request to an instance of NSURLConnection.

76. What is the significance of NSOperationQueue?

NSOperationQueue is a class that provides an easy way to manage the execution of concurrent or serial tasks in iOS. It provides more advanced features compared to GCD (Grand Central Dispatch), such as task prioritization, cancellation, and dependencies between operations.

77. What is the purpose of the dispatch_once function?

The dispatch_once function is used to execute a block of code only once during the lifetime of the application. It ensures that code is executed in a thread-safe manner, and it is commonly used for initialization tasks that should only be performed once, such as setting up a singleton instance.

Module 5: Data Persistence and System Optimization

78. The app is freezing on the main thread. How do you debug it?

The Cause:

A freeze, also known as a “Hang”, occurs when the Main Thread is blocked for more than 250ms. This means that you are probably doing some heavy work like Image Processing, JSON parsing, or Synchronous Network operations on the UI Thread instead of a Background Thread.

The Solution (Step-by-Step):

1. Reproduce: Identifying the user action that is causing the freeze.
2. Use Instruments (Time Profiler): This is the gold standard tool.
   • Open Xcode $\rightarrow$ Product $\rightarrow$ Profile (Cmd + I).
   • Select Time Profiler.
   • Record the app usage.
   • Look for “Heavy Stack Traces” on the Main Thread (labeled Main Thread or Thread 1).
3. Check Layout Loops: If your CPU usage is at 100 percent and your code has no heavy functions, it could be that your app has conflicting Auto Layout constraints that are stuck in an infinite loop.
4. Fix: Move the heavy task to a background queue.

Code Fix:

// BAD: Freezes UI

let image = processHeavyImage() // Blocks Main Thread

imageView.image = image

// GOOD: Background Thread

DispatchQueue.global(qos: .userInitiated).async {

    let image = self.processHeavyImage() // Heavy work here

    DispatchQueue.main.async {

        self.imageView.image = image // UI update must be on Main

    }

}

79. How do you secure API Keys in an iOS app?

The Golden Rule: Never hard-code your API keys directly into your code (e.g., let apiKey = “12345”). Strings directly embedded into your code can be easily discovered by hackers through “Reverse Engineering” tools (like the strings command or decompilers).

Best Practices (Ranked by Security):

1. Proxy Server (Best): Do not store the keys on the client at all. The app makes a call to your backend, and your backend makes the call to the 3rd party API (Google Maps, Stripe) using the key stored on the server.
2. Obfuscation (Good): If you have to store it locally, obfuscate it. Avoid storing it as “API_KEY.” Store it as an array of bytes or XOR logic that is constructed at runtime.
3. Environment Variables (.xcconfig): Store keys in a configuration file that is added to .gitignore so it is never uploaded to GitHub.

80. What are some iOS implementation options for persistence and storage?

Persistence involves storing data on the disk in a way that allows retrieval without modification when the app is reopened. There are various methods available for data storage, ranging from simple to complex:

• Storing data using data structures like arrays, dictionaries, sets, and other similar structures is an excellent option for intermediate storage.
• NSUserDefaults and Keychains serve as straightforward key-value stores. However, NSUserDefaults is considered insecure, while Keychains provide secure storage.
• NSFileManager enables the storage and retrieval of data (serialized or not) to and from a disk through file or disk storage.
• Relational databases, such as SQLite, offer a robust solution for implementing complex querying mechanisms.

81. What are the advantages of the Realm framework?

• To handle all of the work, only a small amount of code is needed.
• Available in both Objective-C and Swift.
• SQLite and Core Data have slower performance.
• Database files can be shared easily between iOS and Android devices.
• There is no fee, no charge.
• There is no limit to the data that can be stored.
• Regardless of huge data sets or massive storage, consistent speed and consistency

82. Describe the managed object context and its function.

A managed object context (represented by an instance of NSManagedObjectContext) is a temporary ‘scratchpad’ or ‘single object space’ in an application for a (presumably) related collection of objects. These objects collectively represent an internally consistent view of one or more persistent stores.

A single-managed object instance exists in one and only one context, but multiple copies of an object can exist in different contexts.

The key functions of the managed object context include the following:

• Life-cycle management: Here, the context provides validation, inverse relationship handling, and undo/redo.
• Notifications: These refer to context posts’ notifications at various points that can be optionally monitored elsewhere in our application.
• Concurrency: Here, the Core Data uses thread (or serialized queue) confinement to protect managed objects and managed object contexts.

83. What is a plist?

A Property List (plist) is a structured file format that organizes data into named values and lists using standard object types (like Dictionaries, Arrays, Strings, and Numbers).

• Function: It allows applications to store serialized data efficiently, often converting objects to and from XML format.
• Usage: It is the backbone of NSUserDefaults for storing user preferences.
• Archiving: Complex objects (like NSColor) that aren’t natively supported can still be stored in a plist if they conform to NSCoding and are archived as NSData.

84. What are the main differences between NSFetchRequest and NSPredicate in Core Data?

• NSFetchRequest: It is used to fetch objects from a Core Data store. It defines criteria such as sorting, fetching limits, and properties to be included in the results.
• NSPredicate: It is used to filter and define the conditions for fetching specific objects in a Core Data request. It is commonly used with NSFetchRequest to specify the filtering conditions (e.g., matching specific values in attributes).

85. How would you optimize memory usage for large datasets in iOS?

To optimize memory usage for large datasets in iOS, you can:

• Use lazy loading to load only the necessary data at the time it is needed.
• Utilize pagination to load data in smaller chunks instead of all at once.
• Use memory-efficient collections like NSPointerArray or NSSet instead of arrays where appropriate.
• Implement image caching to avoid reloading large images multiple times.
• Use Core Data with NSFetchedResultsController for efficient data handling and memory management in table views.
• Enable automatic memory management with ARC to ensure unused objects are freed promptly.

Salary Trends in iOS

In the past few years, the demand for iOS developers has been increasing, both in India and abroad. The average salary in India, as per payscale, has been noted to be ₹7.5 LPA, and in the USA, according to clouddev, the average for an iOS developer is $125K, ranging from $105K to $143K.

INDIA

USA

Job Trends in iOS

The iOS platform has seen a great uprise with the latest versions and changes in the mobile development market, with the increasing demand for iPhones.

• Popularity: According to Grand View Research, the market has observed an overwhelming rise of $240 billion in 2023, at a CAGR of 13.4%. With an increasing market, developers must stay ahead of the ever-rising job opportunities. The need for iOS developers has constantly increased in Silicon Valley and big cities such as New York.
• Regional Demand: The Indian market, as per LinkedIn, has seen a growing demand of more than 10,000 jobs in iOS Developer roles.
• Global Demand: According to LinkedIn, the market in the US has more than 8,000 jobs for iOS developers.
• Cross-Platform Development: The demand for iOS also saw a growth in React Native and Flutter, as the code written in both of these can be easily implemented in both Android and iOS, which eventually decreased the cost and increased time efficiency.

Roles and Responsibilities in iOS

Let’s understand the roles and responsibilities of iOS developers and mobile architects:

Conclusion

Don’t just memorize answers, understand the why behind every architectural decision. From Memory Management to Scalable Design, this guide prepares you for the toughest questions at companies like Apple and Uber.

Conclusion