Top iOS developer interview questions and answers in 2025

CoreData is used as a framework for managing object graphs. It helps manage a graph of object instances that is potentially very large. This allows the app to use a graph that would not completely fit in the memory, by bringing objects in and out of the memory when needed. CoreData also helps in managing the limitations on properties and relationships and in maintaining the integrity of references. This means that when objects are added to or removed from a relationship, the forward and backward links remain consistent. Therefore, CoreData is considered to be the perfect framework for creating the “model” of an MVC architecture.

CoreData uses SQLite for disk storage to implement graph management. It is possible to implement graph management using some other relational database or even a non-relational database like CouchDB. CoreData is more of an API that abstracts from the actual datastore than a database engine. Therefore you can tell how CoreData must store itself - as a plist, an SQLite database, a binary file, or a custom data store type.

Giving a detailed answer to an iOS interview question like this is good, but your answer can become great if you can add your perspective as well to the answer.

Generally, retaining an object increases its retain count by one. This helps retain the object in memory instead of being blown away. Therefore, if you only have the retained version of an object, you will share that copy of the same with whoever sent it to you.

Copying an object, on the other hand, creates an extra copy or a duplicate version of the object. While you share the original with the person who sent the object to you, you do not share the copied or duplicate version with the sender.

A signed application helps the system to know who signed the application and also to determine that no changes were made to the application after it was signed. This is a necessary step to submit the application to the App Store for iOS and Mac. There is a signature verification process in OS X and iOS to confirm that the applications do not run with invalid signatures. This builds trust for the users who know that the application is signed by a verified Apple Source and no changes were made to it since signing.

During the build process, your digital identity is used by Xcode to sign your application. The digital identity comprises a public-private key pair and a certificate. The cryptographic functions use the private key to create the signature. Apple issues the certificate that contains the public key and helps identify you as the key pair owner.

The signature protects the executable code of the application because as soon as the executable code in the application changes even slightly, the signature becomes invalid. However, changes to images or nib files do not invalidate the signatures as these resources are not signed.

The signature of an application can be removed and a different digital identity can be used to re-sign the application. For example, all applications on App Store are re-signed by Apple when they are sold.

For an iOS interview question of this type, it may be good to add if you have any prior experience of a project with similar requirements, code-signing for iOS apps in this case.

There are five app states in iOS. While the app state is managed by the OS, the important tasks are managed by the app itself so that transitions between states happen smoothly. The iOS programming guide lists the five iOS app states as follows:

• Non-running - When the app is not in the running state.
• Inactive - When the app runs in the foreground but does not receive any events. This can happen with an iOS app when a call or SMS is received or some other function takes precedence.
• Active - This is the state when the app runs in the foreground and receives events.
• Background - When the app runs in the background and executes code at the same time.
• Suspended - When the app runs in the background but does not execute any code at that time.

iOS interview questions like the above where you need to talk about multiple states or steps are popular in iOS interviews

The main features of Swift are as follows:

• Generics
• Optionals
• Reference types
• Value types
• Static typing
• Protocols

The biggest feature of Swift is that it is a strongly-typed language. Being a strongly-typed language is an advantage as well as a disadvantage. Development in Swift is easy because of protocols, generics, and optionals which exist because of static typing. While static timing throws several compilation errors and compile-time warnings, it also offers more security at runtime and helps in determinism for optionals, generics, etc. This is, therefore, a big advantage of Swift. The security offered by strict type is most useful under the following circumstances:

• When creating a client application requires more strict clarity than flexibility and dynamism
• When you don’t want inexperienced developers to have excessive power and cause damage to themselves or their work and thus, need to add restrictions
• When your code needs refactoring and using the compiler can help in writing proper and correct code

All the above are scenariOS where developers build customer-facing iOS applications.
The disadvantage of Swift is that it can be too restrictive, especially when the app you are building needs flexibility. For example, when you build a library or a framework, it needs to be flexible and dynamic. In such a case, Objective-C which offers meta-programming capabilities can be a better choice than Swift, though presently, Objective-C seems to be going obsolete.

MVC stands for Model View Controller. It is Apple’s main software design pattern for developing iOS apps. Models represent the data for the application. Views bring things to the screen. Controllers are used to manage the flow of data between model and view. There is no direct communication between model and view, all communication is taken care of by the controller.

As a senior developer, one must know that while MVC is good for general-purpose design, it can be used only for the view layer. Therefore, using only MVC will restrict the architecture of the application and could also lead to the “Massive View Controller” problem.

Massive View Controller refers to that state of the codebase when excessive logic and responsibility are given to View Controllers that are not supposed to shoulder that responsibility. As a result, the code may become rigid, bloated, and difficult to alter. As a remedy, one can use design patterns such as Coordinator, MVP, and MVVM. For scaling the iOS code and avoiding this type of problem, architectures like VIPER and RIBs can be used.

Both, delegate and KVO, create relationships between objects. Delegation creates a one-to-one relationship in which the delegate protocol is implemented by one object, and the other object uses protocol-defined methods to send messages to the first object. KVO, on the other hand, creates a many-to-many relationship in which the message is broadcast by one object, and one or more objects receive the message and react to it. KVO is not protocol-dependent.

When preparing for your iOS interview, ensure that you go through all such concepts where you could be asked to differentiate between two things.

Apart from MVC, Singleton, Observer, and Delegate patterns that are commonly used, there are other patterns too that could be used for developing iOS applications:

• Factory Method: With the Factory Method, one can replace class constructors for abstracting and hiding initialization of objects so that the type is determined when the application is run. This method also helps to hide and contain the switch/if statements that help identify which objects to create instances for.
• Adapter: With the help of the Adapter design pattern one can adapt one object’s interface to that of the other. It is useful when a third-party code cannot be changed to one’s own code or when something with an inconvenient or incompatible API needs to be used.
• Decorator: The Decorator is a wrapper that can be wrapped around different classes to enhance their capabilities. One can wrap it around things one wants to decorate. Once wrapped, it implements the interface and delegates the messages that were sent to it to the underlying objects, or it changes and improves objects or gives its own implementation to them.
• Command: The Command design pattern allows you to implement an object representing an operation that you want to perform. The operation you want to execute may have its own state and logic for performing the task. As an advantage, you can hide the operation’s internal implementation from the users, add undo/redo capabilities to it, and even execute operations later instead of at the time of operation creation.
• Template: The Template design pattern has a base class outlining the algorithm for what is required to be done. There are several abstract methods of the base class. These abstract methods must be implemented by the concrete subclasses of the base class. These abstract methods are also referred to as hook methods. The interaction of the Template Method class users happens through the base class that implements the algorithm steps. The subclasses supply the concrete implementations for those steps.

Outlined below are the ways to store data in simple to complex order:

• For intermediate data storage or for storage that doesn’t need to last long, we can use in-memory arrays, dictionaries, sets, and other data structures.
• For simple key-value storage, we can use NSUserDefaults/Keychain. Here, one thing is insecure, and the other is secure, respectively.
• For writing data to or from a disk, we can take the help of NSFileManager, whether the data is serialized or not, we can use File or Disk storage.
• When trying to simplify working with databases, frameworks like Core Data and Realm are useful.
• When your requirements include implementing complex querying mechanics, the SQLite relational database is what you should use.

The above iOS interview question is an example of questions where you can use the traditional answer outline above and be safe, but if you add examples of having implemented each or any of the options above, you may earn the interviewer’s attention.

When you work with Structs or Enums, ARC doesn’t manage these memory types. Thus, there isn’t any need to worry about specifying whether you are using weak or unowned references for the constants or variables there.
In hierarchical relationships, where the parent references the child but the reverse does not occur, you can use strong references. In most cases, anyway, strong references are apt. However, where the relationship of two instances is optional, you must ensure that one instance is weakly referenced to the other.
When one instance is linked to another in a way that it cannot exist in the other’s absence, there is a mandatory dependency of one variable on the other. In such a case, the instance that has mandatory dependence on the other must hold an unowned reference to the other.

The primary programming language used for iOS development is Swift. Objective-C is also used, but its usage has been declining in favor of Swift.

Overlays are a technique used in operating systems to allow programs to use more memory than they would otherwise be able to.

When a program is loaded into memory, it takes up a certain amount of space. If the program is large and requires more memory than is available, overlays can be used to load only the portions of the program that are currently needed into memory. As the program executes, different portions can be swapped in and out of memory as needed.

Some of the important features of Swift include:

• Safety
• Simplicity in syntax
• Readability
• Support for multiplatform

In Swift, conditional conformances allow you to declare that a generic type conforms to a protocol only under certain conditions. This means that a type will only conform to a protocol if some condition is met, such as the type's generic parameter satisfying certain constraints.

ButtonStyle protocol allow to customize new button styles that can be reused without the need for new views. Using this protocol, you can create a button that will appear the way you want. You will make your own style that sets a decent background for a button. You can use the buttonStyle(_:) modifier.

Where arrays are an ordered collection of values, sets are an unordered collection. Also, an array can duplicate elements, while a set cannot.

A tuple is a set of multiple values inside Swift. They occupy space between dictionaries and structures and return values from a function call.

GeometryReader reads all the size and position information and passes that information to its child views via GeometryProxy. It is a flexible view and takes over all the available space provided by the parent view

A bounding box is a rectangular frame that represents the smallest rectangle that completely encloses a particular object or shape. This object can be an image, a text character, or any other graphical element on the screen. The bounding box is defined by its position and size. The position is specified by the coordinates of the top-left corner of the rectangle, while the size is specified by the width and height of the rectangle

When a custom view is set to IBDesignable, it allows Xcode to preview it while storyboards are edited. Interface Builder helps directly with making custom layouts. You can easily provide any effects like border width shadow color, shadow width, border color, corner radius, and shadow Opacity.

It stores those settings that must be available even when the app is not running. It is a file in the Mac and GNUstep environments that stores user settings. There are three formats plist, Text, Binary, and XML. A plist can store string, number, data(binary data), boolean, dictionary(associative array), and array.

They create strings that print what you see, unlike some escape orders that make your string print in a different form. Raw strings are denoted by the # hash symbol, also known as pound symbol. It is used before and after quotation marks by using # at the starting and ending point.

Using two primary ways @Published property wrapper or calling objectwillchange. send()

@Published property wrapper: It is very useful in SwiftUI. It allows us to create observable objects that automatically announce when changes occur.

Objectwillchange: It is a property defined on the ObservableObject protocol. Whenever any @Published properties of the objects change, the compiler synthesizes a default implementation for the property, which emits a value.

When two objects strongly refer each other, they can never be deallocated. And this strong reference also enables them to keep each other alive. When objects hold strong references to each other, it means that each object has a strong ownership of the other, which creates a cycle, and this cycle is referred to as a circular reference.

No, we cannot add a stored property to a type through an extension in Swift.

Extensions in Swift can add computed properties, instance methods, class methods, and initializers to a type, but they cannot add stored properties. This is because stored properties must be initialized when an instance of the type is created, and extensions cannot provide their own initializers.

It specifies a range between values x and y (x..<y) where y is not included. The operator specifies a range that includes the first value but not the final value.It is specifically useful when you work with zero-based lists such as arrays, where it's useful to count up to the length of the list.

One benefit of using child view controllers is that it allows for better modularization and organization of code in an iOS app. By breaking down a large, complex view controller into smaller, more manageable child view controllers, it becomes easier to understand and maintain the codebase.

A reference type contains the location in the memory where data lives. A reference type is passed to a function; instead of creating a new copy of the object, it just creates another reference to that object which is shared among all the different references.

In Swift, a nested function is a function defined within the body of another function. Nested functions are useful for organizing code and encapsulating functionality within a larger function scope. Nested functions can be useful for abstracting complex logic or for breaking down large functions into smaller, more manageable parts.

They are special string patterns that tell how to search for a string. It is a sequence of characters that specifies a search pattern in the text; it finds or finds and replaces operations on strings.

It is an order of objects that receive the chance to respond to events. It is the series of events that happen once we start interacting with the application on iOS. Applications receive and handle events using responder objects.

• Octal Literals
• Hexadecimal Literals
• Binary Literals
• Decimal Literals

It provides tools and resources to steer business processes toward better performance. It is an execution unit in which a program operates. It ensures that each process and application receives enough of the processor’s time to function properly and deallocates after the process is completed.

• Continue
• Fallthrough
• Return
• Break
• Throw

Subclass: It is the act of constructing a new class on an existing class. They inherit characteristics from the existing class, and you can further modify them with new characteristics.

Super Class: When a class inherits properties from another class, the inheriting class is known as a subclass, and the class it inherits from is called a superclass.

Each thread in iOS serves as a single path of execution. Every application in IOS starts with a single thread that runs the application's main functions.

For a single-line comment you can use double slashes (//)
And for multi-line comments you can use a forward slash followed by an asterisk (/*)

It is a process of querying and calling properties. Different queries can be chained here, but the chain fails if any link is nil.

It is a process by which a class inherits properties, methods, or any other features from some other class. It is a fundamental behavior that differentiates classes from other types in Swift. We can write different implementations while maintaining the same behaviors by reusing code we have already written.

It is used as an alternative to long if-else-if statements. It lets you inspect a value and match it with a number of cases. It's especially effective in making concise decisions based on one variable that can contain a number of possible values. Using the switch statement often results in more concise code that's easier to read.

It is used in a loop when you want to end a statement immediately in a loop. Also, it is used to end the case in the switch statement. In simple words, when a program is running at a specified condition, we use a break statement that automatically breaks the current flow and terminates the program.

"didSet" is a property observer that is called after the property's value has been set, while "willSet" is a property observer that is called before the property's value is set. "didSet" and "willSet" are useful for performing additional logic when a property's value changes, such as updating the UI or triggering other methods.

It is the simplest way to store data without a database using key-value pairs. Basically, it provides a programmatic interface for interacting with the default systems. By this default setting, an application is able to change or modify its behavior to match a user's preference. For example, users can specify their preferred media playback speed.

Types supported by NSUserDefaults are as follows.

• NSString
• NSDate
• NSDictionary
• NSData
• NSNumber

It is used to accumulate together parallel rows in an UITableView, for example, rows that are different only in their content but otherwise have similar layouts. A UITableView object maintains a line of the currently reusable cells, each with its own reuse identifier, and makes them accessible to the delegate in the dequeueReusableCell method.

Where viewDidLoad pop-ups on the screen only when the view is loaded. At this position, you can instantiate any instance variable and build any views that remain on the device of this view controller.

viewDidAppear appears each time on the device. In this position, you can perform any layout actions, or you can do any drawing in the User Interface.

InterfaceBuilder: It gives collections of user interface objects to a Swift developer.

NSLayoutConstraints: NSLayoutConstraints is the relationship between two user interface objects that must be satisfied by the constraint-based layout system.

CGRect: CGRect is a structure that contains the location and dimensions of a rectangle.

When declared, “?” makes a property optional. However, if the property is not valuable, it helps avoid runtime errors.

Synchronous tasks are those for which you have to wait to complete before moving ahead. On the contrary, for asynchronous tasks, you don't have to wait for the task to complete. Synchronous code execution blocks the current thread until the task is completed, while asynchronous code execution allows the thread to continue running and completes the task in the background.

A de-initializer is called before a class instance is deallocated.

To write it, we use the deinit keyword as follows:

Deinit {

// deinitialization is performed

}

These are those properties whose first values are not computed until the first time they are used. To use it, you can report the lazy modifier before its declaration.

Size Classes is a feature in iOS that allows developers to design adaptive interfaces that can adjust to different screen sizes and device orientations. It is used to create user interfaces that look great and function well across different iOS devices. With Size Classes, developers can specify how the layout and behavior of their app's UI should change when it's displayed on a different device.

SBJson framework is a data interchange format that is easy to read and write. Here JSOn stands for JavaScript Object Notation. It is a JSON syntax analyzer and generator for Objective-C, which provides additional controls and flexible APIs, which makes JSON handling easier. Using the SBJson framework, you can reduce the apparent latency for each download/parse cycle of documents over a slow connection, can start parsing and return chunks of the parsed document, and can parse large documents bit by bit, so you don't have to keep them in memory.

While atomic properties are slow but thread-safe, only one thread is accessed by the variable(static type). It is not a keyword but a default behavior.
Whereas nonatomic is fast but thread-unsafe and multiple thread access by the variable (dynamic type). It is not a default behavior; that's why we need to add the keyword in the property attribute. If two different threads access a similar variable at the same time, then maybe the result is unexpected behavior.

• Not running state
• Active state
• Background state
• Suspended state
• Inactive state

• Threads
• Dispatch Queues
• Operation Queues

SpriteKit is a framework to develop animated 2D objects easily.
SceneKit is a framework from OS X that helps with 3D graphics design.

"try" is used for throwing functions that can potentially fail, "try?" is used to handle errors gracefully by returning nil if an error occurs, and "try!" is used to force unwrap the result of a throwing function and crash the app if an error occurs. "try?" is typically used for non-critical operations where it's okay to gracefully handle errors, while "try!" should be used sparingly and only when you are certain that an error won't occur.

The primary purpose of an autorelease pool is to help manage memory usage and reduce memory footprint in programs that create a lot of short-lived objects.

An autorelease pool is a stack-like structure that manages the release of objects. When an object is added to an autorelease pool, it is not released immediately, but rather added to a list of objects that will be released when the pool is drained.

UI Automation API as it initiates user interaction with the application and returns the log information.

UIKit classes should only be used from the main application thread, also known as the main thread or UI thread. In iOS development, the main thread is responsible for handling user interface updates, including processing user interactions, layout changes, and animation.

App ID is a unique identifier used by Apple to identify a specific app developed by a specific development team. It is used for various purposes, such as enabling push notifications, setting up app groups, and configuring the App Store.

Bundle ID, on the other hand, is an identifier specified by the developer in Xcode that uniquely identifies each app. It is used to identify the app's executable, as well as its resources and metadata

Cocoa is an application framework for building applications for Mac OS, whereas Cocoa touch is used for building applications that run on iPad and iPhones (iOS).

ARC (Automatic Reference Counting) is a memory management technique used in iOS development to automatically manage the memory of objects. It initializes and reinitializes the system resources. It is a memory management option for Objective-C provided by the Clang compiler. It automatically frees up memory when class instances don’t have strong references.

Grand Central Dispatch (GCD) is a low-level API that allows running tasks in parallel. Also, it manages threads in the background. It contains language features, system enhancements, and runtime libraries that provide comprehensive, systemic improvements on multicore hardware in iOS.

It directs the user to an app instead of a website through URLs or universal links. Deep linking links to a specific piece of content within an app. The content could be a particular section of a page, a view, or a certain tab.

Apple uses Objective-C as an object-oriented programming language. This language entails the benefits of C and Smalltalk. Objective-C inherits C syntax, flow control statements, and primitive types and adds syntax for defining methods and classes.

• BOOL
• NSInteger
• NSUInteger
• NSString

NotificationCenter is a feature in iOS and macOS which is mostly used to receive system messages outside and inside of your application. It shows your notifications history, allowing you to scroll back and see what you have missed. Users may choose what applications appear in Notification centers and how they are handled.

Dictionary in Swift is an unordered collection of items that stores items in key-value pairs. It uses a key as an identifier to store values that can be recovered through the same key. It is an unordered collection of key-value pairs; a key refers to unique identifiers, and a key stores a value.

Syntax:

var Dict_name = [KeyType: ValueType] ()

Example:

var examresult= [“Neha”: “44”, “Adil”: “56”, “Era” : “84”]

print(examresult)

Output:

[“Neha” : “44”, “Adil” : “56”, “Era” : “84”]

Keys are “Neha,” “Adil,” “Era”

Values are “44”, “56”, “84”

It solves specific problems that might occur while designing an app's architecture. They are templates designed to make your coding easier. The most common design patterns are:

• Facade
• Decorator
• Memento
• Adapter

They are functions passed as parameters to other functions. Also, they are used with asynchronous tasks. They tell when an operation has finished. It is a technique for implementing callback functionality using blocks/closures.

It is new low-energy Bluetooth wireless technology that allows iPhone and other iOS users to get location-based info on smartphones. It is a small-scale network device that acts as a transmitter to detect and track smartphones.

Not Running: The app is not launched or was running but was terminated by the system.

Inactive: The app is in the foreground but not receiving events. This state is typically brief as apps transition to other states.

Active: The app is in the foreground and receiving events.

Background: The app is in the background and executing code. Most apps enter this state briefly on their way to being suspended.

Suspended: The app is in the background but is not executing code. The system may purge suspended apps from memory at any time without warning to make more space for other apps.

To create a custom UIView, you need to create a subclass of UIView and implement the draw(_:) method.

Example:

It is used during software development to decide the software characteristics and write test cases for each such characteristic. It provides insights into both quality and design. You have to create and test each functionality of the test case; if it fails, write the new code to pass the test and make the code simple and bug-free.

A closure is a self-contained block of code that can be passed around and executed at a later time, while a function is a named block of code that performs a specific task.

To implement a singleton in Swift, you need to create a static instance property and a private initializer.

Simple Smart Group - This basic smart group lets you filter your project by file type, name, or path.

Simple Expression Smart Group - This smart group lets you filter your project using a more complex expression, such as "name contains 'ViewController' and the path contains 'Controllers'."

Custom Smart Group - This smart group lets you create a custom filter using predicates, which are similar to expressions but offer more options and flexibility.

A strong reference keeps an object in memory until it is released, while a weak reference allows the object to be deallocated when there are no more strong references to it. For example, in the following code, the parent object has a strong reference to the child object, while the child object has a weak reference to its parent:

It measures the statements in the body of code that have been executed and non-executed when tests are performed. A program with high test coverage executes more of its source code during testing, suggesting it has a lower chance of containing undetected software bugs than a program with low test coverage.

A guard statement is used to exit a function or method early if a certain condition is not met. It is typically used to validate input parameters at the beginning of a function.

Here's an example:

They are used to solve common problems in software design and assist in writing simplified code using different templates. Using design patterns, you can represent an idea, not a particular implementation, and make code more flexible, reusable, and maintainable.

Some of the most commonly used Cocoa design patterns are:

Creational: Singleton - This pattern is used to ensure that only one instance of a class is created and that it is globally accessible. This is useful when you need to share a resource or configuration settings throughout your application.

Behavioral: Memento - The Memento pattern is a behavioral design pattern that allows an object's state to be saved externally and restored later. The Memento pattern is often used in conjunction with the Command pattern and the Undo/Redo functionality.

Structural: Decorator - The Decorator pattern allows behavior to be added to an object without changing its structure. This is useful when you want to add functionality to an object at runtime or when you want to create a chain of decorators that modify an object's behavior in a specific order.

The Adapter Pattern is a design pattern that allows objects with incompatible interfaces to work together. It acts as a bridge or a wrapper between two existing interfaces, converting the interface of one object into another interface that clients expect.

This conversion allows objects with different interfaces to collaborate seamlessly. We need this when we have an Ethernet interface on one end and USB on the other.

To create a custom table view cell in iOS, you need to create a new subclass of UITableViewCell and define the user interface elements in the cell's contentView. Here is an example of a custom table view cell:

Significant location changes: Users can track locations up to 1km.
Region monitoring: Users can track enter/exit events within a radius equal to 100m or more.
Visit events: It monitors enters/exits visit events from a place(Home/office)

While there are many ways, NSCache is preferable over a simple dictionary as it automatically clears the cache on low memory. NSCache will automatically remove items without you knowing about it and remove items intelligently, trying to keep as much cached as possible.

Additionally, NSCache provides other features such as thread-safe access to cached data, support for arbitrary keys and values, and customizable behavior through the use of delegate methods. These features make NSCache a flexible and robust caching solution that is well-suited for a wide range of use cases.

A delegate is a design pattern that allows one object to communicate with another object by sending messages directly to a delegate protocol. A notification, on the other hand, is a message that is broadcasted to all registered observers without any specific target. In short, delegates are used for one-to-one communication, while notifications are used for one-to-many communication.

The "frame" property of a UIView specifies the view's location and size relative to its superview, while the "bounds" property specifies the view's location and size relative to its own coordinate system. In other words, the frame takes into account the view's position within its superview, while the bounds only considers the view's own coordinate space.

Computed properties are a feature that allow you to define a property whose value is computed rather than stored. Instead of directly storing a value in memory, a computed property calculates its value on the fly based on some underlying logic or other properties.

It is a mechanism that enables the program to decide during runtime what implementation of a method or function to call. Dynamic dispatch can provide flexibility and extensibility to a program by allowing new subclasses to override methods inherited from their parent classes and provide their own implementations.

Two atomic operations are possible:

Wait(): This operation decreases the value of the semaphore by 1. If the value of the semaphore is already 0, then the process that performs the wait operation is blocked until the semaphore value becomes greater than 0.

Signal(): This operation increases the value of the semaphore by 1. If any processes were blocked on this semaphore due to a wait operation, then one of those processes is unblocked.

RTOS stands for Real-Time Operating System and it is used for real-time applications. It is suitable for those applications where a large number of events, mostly external to the computer system, must be accepted, and data processing must be done in a short time or within certain deadlines. With the help of RTOS, you can measure the processing time in tenths of seconds.

The "prepareForReuse" method is called on a UITableViewCell just before it is about to be reused for a new row in the table view. It allows the cell to reset its state and prepare for new content. For example, you might reset the cell's text and image properties and cancel any pending network requests.

The two types of process synchronization are:

Interprocess Communication (IPC): This mechanism allows processes to communicate and synchronize their actions with each other. Examples of IPC mechanisms include shared memory, message passing, and semaphores.

Mutual Exclusion (Mutex): This is a technique used to ensure that only one process at a time accesses a shared resource or a critical section of code. Mutex can be implemented using binary semaphores, locks, or synchronization primitives.

Either when it is not launched or when it gets terminated by the system when running. The OS may have terminated the app. Therefore, if an application is not visible on the screen or background, that means the application is in the Not Running state.

The app is running in the background, receiving the events and executing code, but for a limited time ( In iOS 12, the app remains working for 180 seconds ); the Operating System automatically moves the application to the suspended state and stops the execution of code.

After moving from an inactive state, it first goes to an active or background state. It is not said to be running before launch. The app runs in the foreground but does not receive events in an inactive state. The next stage is an active state where an application runs in the foreground and receives events. Next is the background state, where the application runs in the background and executes code. Last is the suspended state, where the application is present in the background, but no code is being executed.

A background state is where most apps enter briefly on their way to being suspended. Although, an application that requests extra execution time may remain in this state for a certain period. Apart from an application being launched directly into the background, it enters the background state instead of the inactive state.

Where the equal-to == operator checks whether the values are the same,the strict equality === operator checks if the references point to the same instance. The equal-to == operator does the type conversion of the operands before comparison, whereas the strict equality === operator compares the values and the data types of the operands.

You can use it if you want to clean up before deallocating the class instances. With it, you can free up the memory space occupied by the system. If we manually want to deallocate instances, we only use deinit in Swift. Otherwise, Swift automatically does the deallocation. Each class contains only a single deinit.

Bitcode: This is an intermediate representation of your app's compiled code that Apple can recompile for different devices and architectures. This can help reduce the overall size of your app.

App slicing: With app slicing, only the necessary assets are downloaded to a user's device, which can help reduce the size of your app by excluding assets that aren't needed for specific devices.

On-demand resources: This method involves delivering content only when it's needed. This can help reduce the initial download size of your app by not requiring users to download all assets at once.

App thinning: This is a set of techniques used to optimize the installation process and reduce the amount of storage required by your app. App thinning includes techniques such as app slicing, on-demand resources, and bitcode.

Identify and remove unused assets: Reviewing your app for unused assets and removing them can help reduce the overall size of your app.

It solely depends on the data use case. If data is static, unchangeable, and it is called exactly once, we can load it in viewDidLoad and cached. However, if data changes, we can load it in viewDidAppear, and it is called multiple times during the life cycle of a view controller. The viewDidLoad is called when the view controller is first loaded into memory, whereas viewDidAppear is called when the view is actually visible.

A synchronous NSURLSession blocks the current thread until the network request is complete, while an asynchronous NSURLSession allows the request to be executed in the background without blocking the main thread. Asynchronous NSURLSessions are typically used for long-running network requests, while synchronous NSURLSessions are used for quick network requests that need to block the main thread.