iOS developer interview questions

The following questions and answers have been reviewed and verified by Andrei Trukhan, Senior Software Engineer at EPAM Anywhere. Thanks a lot, Andrei!

Are you preparing for an iOS developer interview? Then you've come to the right place. Our comprehensive list of iOS developer interview questions will help you confidently evaluate your technical proficiency and problem-solving abilities.

These questions cover a broad spectrum of iOS development, from basic concepts to advanced topics, providing a well-rounded view of an applicant's expertise. So, let's dive in and explore these questions to help you ace your iOS interview preparation.

In iOS, memory management is done using Automatic Reference Counting (ARC). Strong, weak, and unowned references manage memory and avoid memory leaks or retain cycles.

• Strong reference: A strong reference is the default reference type in iOS. It creates a strong ownership relationship between the object and the reference, preventing the object from being deallocated as long as it exists.
• Weak reference: A weak reference does not create a strong ownership relationship. It allows the object to be deallocated even if the reference still exists. Weak references are used to avoid retain cycles and are automatically set to nil when the object is deallocated.
• Unowned reference: An unowned reference is very similar to a weak reference but with one difference. An unowned reference will give you a guarantee that the variable will not be nil when it is accessed. Similar to a weak reference, an unowned reference does not increment or decrease an object's reference count. We can say it is another solution to fix the retain cycle. Accessing an unowned reference when the instance the reference points to is nil will cause a fatal program error.

`frame` and `bounds` are properties of UIView in iOS that define the position and size of a view.

• Frame: The frame property represents the position and size of a view in its superview's coordinate system. It is a CGRect that contains the origin (x, y) and size (width, height) of the view relative to its superview.
• Bounds: The bounds property represents the position and size of a view in its coordinate system. It is also a CGRect, but its origin is always (0, 0), and its size is the same as the view's size.

The following figure shows the state transitions for scenes. When the user or system requests a new scene for your app, UIKit creates it and puts it unattached. User-requested scenes move quickly to the foreground, where they appear on screen. A system-requested scene typically moves to the background to process an event.

For example, the system might launch the scene in the background to process a location event. When the user dismisses your app's UI, UIKit moves the associated scene to the background and suspended state. UIKit can disconnect a background or suspended scene at any time to reclaim its resources, returning that scene to the unattached state.

`viewDidLoad` and `viewWillAppear` are lifecycle methods of UIViewController in iOS that are called at different stages of the view controller's lifecycle.

• viewDidLoad: This method is called when the view controller's view is loaded into memory. It is only called once during the lifecycle of a view controller, making it an ideal place to perform initial setup and configuration tasks.
• viewWillAppear: This method is called every time the view controller's view is about to be added to the view hierarchy and become visible on the screen. It is a good place to perform tasks that need to be done each time the view appears, such as updating the UI or refreshing data.

When do we know that our view is created?

In the loadView(), the controller loads or creates a view and assigns it to the view property. If you want to perform any additional initialization of your views, do so in the viewDidLoad() method.

DispatchQueue is a part of the Grand Central Dispatch (GCD) framework in iOS, which manages the execution of tasks concurrently on different threads. DispatchQueue provides an efficient way to execute tasks asynchronously on the main thread or background threads.

There are two types of dispatch queues:

• Serial queues: Tasks are executed one at a time in the order they are added to the queue.
• Concurrent queues: Tasks are executed concurrently, allowing multiple tasks to run simultaneously.

Using DispatchQueue, you can easily perform tasks on the main thread or in the background, ensuring your app remains responsive and efficient.

GCD is a lower-level API for managing concurrency. At the same time, operations provide a higher-level abstraction with additional features such as dependencies, prioritization, and built-in support for cancellation and error handling. The choice between GCD and operations depends on the complexity of your concurrent tasks and the level of control and abstraction you need. GCD might be sufficient for simpler tasks, while operations provide more features for managing complex workflows.

How would you handle concurrent tasks with dependencies using GCD and Operation?

Using GCD via dispatch groups:

• Create a dispatch group with dispatch_group_create().
• Use dispatch_group_enter() and dispatch_group_leave() to manage task counts.
• Employ dispatch_group_notify() to execute a completion block when all tasks are complete.

Using Operation via operation dependencies:

• Use Operation and OperationQueue.
• Create custom subclasses of Operation.
• Set dependencies between operations using addDependency(_:).
• Add operations to a queue, and they will execute in the correct order.

Storyboard and xib files are interface builder files used to create and manage user interfaces in iOS applications.

• Storyboard: A storyboard is a visual representation of the app's user interface, showing the flow and relationships between multiple view controllers. It allows you to design and prototype the entire app's navigation and layout in a single file.
• Xib file: A xib file (short for XML Interface Builder) creates a single view or a view controller's interface. It is a more modular approach to designing user interfaces, allowing you to create reusable views and view controllers that can be instantiated programmatically.

The reuseIdentifier is a string identifier UITableView and UICollectionView used to reuse cells during scrolling efficiently. When a cell goes off-screen, it can be dequeued and reused for a new cell about to appear on the screen. This process is called cell recycling and helps improve the performance and memory usage of table views and collection views.

Using a reuseIdentifier, you can register a specific cell class or nib file with the table view or collection view, allowing it to create and reuse cells as needed.

• UserDefaults: A simple key-value store that allows you to persistently store small amounts of data, such as user preferences and settings. It is not encrypted and should not be used to store sensitive information.
• File System: Swift provides file-handling capabilities that allow you to save data to the device's file system. This can be done using FileManager to write and read files.
• Core Data: A framework provided by Apple that allows you to manage the model layer objects in your application. It provides a way to persistently store and retrieve data in an object-oriented manner.
• Keychain: Keychain is a secure storage system that stores sensitive data, such as passwords, tokens, or encryption keys. It provides encryption and access control, ensuring that the stored data is protected and can only be accessed by the app that created it.
• Realm: A mobile database that is an alternative to Core Data. Realm is designed to be fast, efficient, and easy to use, offering real-time data synchronization capabilities.

The Info.plist file (short for Information Property List) is an XML file that contains key-value pairs of metadata about your iOS application. The system uses it to configure various aspects of your app, such as its display name, bundle identifier, supported orientations, and required permissions.

Some common keys in the Info.plist file include:

• CFBundleIdentifier: The unique identifier for your app
• CFBundleDisplayName: The display name of your app, shown on the home screen
• UISupportedInterfaceOrientations: The supported interface orientations for your app
• NSAppTransportSecurity: Configuration for App Transport Security (ATS) settings
• NSCameraUsageDescription: A description of why your app needs access to the camera

Delegates and notifications are both communication patterns used in iOS to pass information between objects.

• Delegate: A delegate is a one-to-one communication pattern that uses a protocol to define the methods that an object can call on its delegate. The delegate object implements the protocol methods and handles the events or actions triggered by the delegating object. Delegates are commonly used for handling user interface events, such as button taps or table view selections.
• Notification (Observer pattern): A notification is a one-to-many communication pattern that simultaneously uses the NotificationCenter to broadcast messages to multiple objects. An object can post a notification, and any other objects registered as observers for that notification will receive the message and respond accordingly. Notifications are useful for decoupling components and handling app-wide events, such as changes in network connectivity or user login status.

`didSet` and `willSet` are property observers in Swift that allow you to execute custom code before or after a property's value is changed.

didSet: The didSet observer is called after the property's value has been changed. It provides the old value of the property, allowing you to perform tasks such as updating the user interface or validating the new value.

willSet: The willSet observer is called before the property's value is changed. It provides the property's new value, allowing you to perform tasks such as preparing for the change or updating related properties.

Classes and structs are both used to define custom data types in Swift, but they have some key differences:

• Class: A class is a reference type, meaning that when you create an instance of a class, you are creating a reference to the object in memory(stored in a heap). When you assign a class instance to a variable or constant, you create a new reference to the same object. Classes support inheritance, allowing you to create subclasses that inherit properties and methods from a parent class.
• Struct: A struct is a value type, meaning that when you create an instance of a struct, you create a unique copy of the data(stored in a stack). When you assign a struct instance to a variable or constant, you create a new copy of the data. Structs do not support inheritance, but they can adopt protocols to provide shared functionality.
• Other differences: Struct provides default initializers. Class provides class-type casting, Deinitializers for class.

Generics are a powerful feature in Swift that allows you to write flexible and reusable code by defining functions, classes, structs, and enums that work with any type, while still maintaining type safety. Generics enable you to write code that can be used with different types without having to duplicate the implementation for each type.

Here's an example of a generic function that swaps the values of two variables:

Default sessions behave much like the shared session (unless you customize them further), but let you obtain data incrementally using a delegate. You can create a default session configuration by calling the default method on the URLSessionConfiguration class.

Ephemeral sessions are similar to default sessions, but they don’t write caches, cookies, or credentials to disk. You can create an ephemeral session configuration by calling the ephemeral method on the URLSessionConfiguration class.

Background sessions let you perform uploads and downloads of content in the background while your app isn’t running. You can create a background session configuration by calling the backgroundSessionConfiguration(_:) method on the URLSessionConfiguration class.

Access control is a feature in Swift that allows you to restrict the scope of variables, constants, functions, classes, structs, and enums, ensuring that they can only be accessed and modified from specific parts of your code. Swift provides five access levels:

• Open and public: These access levels allow entities to be accessed from any source file in any module. The main difference between them is that open access allows a class to be subclassed and a method to be overridden outside the defining module, while public access does not.
• Internal: This is the default access level. Internal access allows entities to be accessed from any source file within the same module but not from other modules.
• File-private: File-private access restricts the use of an entity to its defining source file. This is useful when encapsulating implementation details within a single file.
• Private: Private access is the most restrictive level. It limits the use of an entity to the enclosing declaration, such as a class, struct, or function, and any nested declarations within it.

Type casting is a process in Swift that allows you to check the type of an instance or treat it as a different superclass or subclass from somewhere else in its hierarchy. Type casting is done using the ‘as?’ and ‘as!’ operators.

Here's an example of type casting in Swift:

In this example, we have a base class, ‘Animal’ and two subclasses, ‘Dog’ and ‘Cat’. We create an array of ‘Animal’ instances and then iterate through the array using a for loop. Inside the loop, we use the ‘as?’ operator to attempt to cast the ‘animal’ instance to a ‘Dog’ or a ‘Cat’. If the type casting is successful, we can access the properties and methods specific to that subclass, such as ‘bark()’ for ‘Dog’ and ‘meow()’ for ‘Cat’.

Closures are a reference type. They are self-contained blocks of code that can be passed around and used in your code. They are similar to functions, but closures can capture and store references to variables and constants from the surrounding context in which they are defined. Closures are used extensively in Swift, particularly for callback functions and higher-order functions like ‘map’, ‘filter’, and ‘reduce’.

Optional is a type on its own, actually one of Swift's super-powered enums. It has two possible values, None and Some(T), where T is an associated value of the correct data type available in Swift.

Auto Layout is a powerful constraint-based layout system in iOS that allows you to create flexible and adaptive user interfaces that adjust to different screen sizes and orientations. Auto Layout uses a set of constraints to define the relationships between UI elements, such as their position, size, and alignment relative to each other or their parent view.

Auto Layout can create user interfaces that automatically adapt to different devices, screen sizes, and orientations, ensuring your app looks and works well on a wide range of iOS devices, including iPhones and iPads.

In conclusion, these iOS developer interview questions cover a broad spectrum of iOS development, from basic concepts to advanced topics. These will help you update your knowledge of iOS technologies and present yourself the best during your technical interview.

If you're an iOS developer looking for a new challenge, consider exploring remote iOS developer jobs at EPAM Anywhere. We offer many opportunities to work with international teams on diverse and exciting projects. Plus, you'll enjoy the flexibility of working remotely while still being part of a vibrant and supportive community. So why wait? Start your journey with EPAM Anywhere today and take your iOS development skills to the next level.