Top 36 iOS Interview Questions And Answers

Question 1

What is CoreData?

Accepted Answer

**Core Data** is an object graph management framework. It manages a potentially very large graph of object instances, allowing an app to work with a graph that would not entirely fit into memory by faulting objects in and out of memory as necessary. Core Data also manages constraints on properties and relationships and maintains reference integrity (e.g. keeping forward and backward links consistent when objects are added/removed to/from a relationship). Core Data is thus an ideal framework for building the "model" component of an MVC architecture.

To implement its graph management, Core Data happens to use SQLite as a disk store. It could have been implemented using a different relational database or even a non-relational database such as CouchDB. Core Data isn't so much a database engine as it is an API that abstracts over the actual data store. You can tell Core Data to save as an sqlite database, a plist, a binary file, or even a custom data store type.

Question 2

What are different ways that you can specify the layout of elements in a `UIView`?

Accepted Answer

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

- Using InterfaceBuilder, you can add a `XIB` file to your project, layout elements within it, and then load the `XIB` in your application code (either automatically, based on naming conventions, or manually). Also, using InterfaceBuilder you can create a `storyboard` for your application.
    
- You can your own code to use `NSLayoutConstraints` to have elements in a view arranged by Auto Layout.
    
- You can create `CGRect`s describing the exact coordinates for each element and pass them to `UIView`’s `- (id)initWithFrame:(CGRect)frame` method.

Question 3

Explain what is `NSUserDefaults`?

Accepted Answer

`NSUserDefaults` is the easiest way to store data without a database using key-value pair. This approach is the ideal way to store small amounts of data. In most cases, NSUserDefaults is best used to save user’s settings and data that is not critical. The following types are supported by NSUserDefaults:

- `NSString`
- `NSNumber`
- `NSDate`
- `NSDictionary`
- `NSData`

**Pros**

- Relatively easy to store and retrieve data
- Perfect for storing small size data (example: User’s Settings)
- Easy to learn and implement

**Cons**

- Not ideal to store large amount of data
- Performance will decrease when storing large amount of data
- Not ideal to store sensitive data

Question 4

What's your preference when writing UI's? Xib files, Storyboards or programmatic `UIView`?

Accepted Answer

- Storyboard's and Xib's are great for quickly producing UI's that match a design spec. They are also really easy for product managers to visually see how far along a screen is.
- Storyboard's are also great at representing a flow through an application and allowing a high-level visualization of an entire application.
- Storyboard's drawbacks are that in a team environment they are difficult to work on collaboratively because they're a single file and merge's become difficult to manage.
- Storyboards and Xib files can also suffer from duplication and become difficult to update. For example if all button's need to look identical and suddenly need a color change, then it can be a long/difficult process to do this across storyboards and xibs.
- Programmatically constructing `UIView`'s can be verbose and tedious, but it can allow for greater control and also easier separation and sharing of code. They can also be more easily unit tested.

Most developers will propose a combination of all 3 where it makes sense to share code, then re-usable `UIView`s or `Xib` files.

Question 5

What is the difference between `viewDidLoad` and `viewDidAppear`?

Accepted Answer

`viewDidLoad` is called when the view is loaded, whether from a Xib file, storyboard or programmatically created in `loadView`. `viewDidAppear` is called every time the view is presented on the device. Which to use depends on the use case for your data. If the data is fairly static and not likely to change then it can be loaded in `viewDidLoad` and cached. However if the data changes regularly then using `viewDidAppear` to load it is better. In both situations, the data should be loaded asynchronously on a background thread to avoid blocking the UI.

Question 6

What is the `reuseIdentifier` used for?

Accepted Answer

The `reuseIdentifier` is used to indicate that a cell can be re-used in a `UITableView`. For example when the cell looks the same, but has different content. The `UITableView` will maintain an internal cache of `UITableViewCell`’s with the `reuseIdentifier` and allow them to be re-used when `dequeueReusableCellWithIdentifier:` is called. By re-using table cell’s the scroll performance of the tableview is better because new views do not need to be created.

Question 7

What's the difference between the `frame` and the `bounds`?

Accepted Answer

**frame** = a view's location and size using the **parent view's coordinate system**

- Important for: placing the view in the parent
- To help me remember **frame**, I think of **a picture frame on a wall**. The picture frame is like the border of a view.

**bounds** = a view's location and size using **its own coordinate system**

- Important for: placing the view's content or subviews within itself
 - To help me remember **bounds**, I think of **a basketball court** where sometimes **the basketball gets knocked out of bounds**.

![https://i.stack.imgur.com/SI1lH.png](https://i.stack.imgur.com/SI1lH.png)

Question 8

When would you use Core Data over `NSUserDefault`?

Accepted Answer

`NSUserDefaults` as the name suggests (vaguely) should be used for storing preferences and app settings only. You should not be storing critical data and or user data into them. Use `UserDefaults` in small projects or to store some flags. Don't use `UserDefaults` to store big data, such as image caching.

CoreData is a full fledged persistent framework which supports large data transactions. CoreData allows you to build relational entity–attribute model for storing user data. Use `CoreData` in big projects. `CoreData` entities are generally a better design than arbitrary values stored by keys, even if later serialized to objects.

Question 9

Explain when to use various storage mechanisms in iOS?

Accepted Answer

- `NSUserDefaults`: stores simple user preferences, nothing too complex or secure. If your app has a setting page with a few switches, you could save the data here.
    
- `Keychain` (see [SSKeychain](https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CC8QFjAA&url=https://github.com/soffes/sskeychain&ei=EDuIUbqAB-SO4ASE4IG4Aw&usg=AFQjCNHvcCLsXZf4Q1XeoXUIg6ioOg22Aw&bvm=bv.45960087,d.bGE) for a great wrapper): used to store sensitive data, like credentials.
    
- `PLists`: used to store larger structured data (but not huge): it is a really flexible format and can be used in a great number of scenarios. Some examples are:
    
    - User generated content storage: a simple list of Geopoint that will be shown by a map or list.
    - Provide simple initial data to your app: in this case the plist will be included in the NSBundle, instead of being generated by user and filled by user data.
    - Separate the data needed for a particular module of your application from other data. For example, the data needed to build a step-by-step startup tutorial, where each step is similar to the others but just needs different data. Hard-coding this data would easily fill your code, so you could be a better developer and use plists to store the data and read from them instead.
    - You are writing a library or framework that could be configured in some way by the developer that uses it.
- `Object archiving` could be useful to serialize more complex objects, maybe full of binary data, that can't (or that you don't want to) be mapped on simpler structures like plists.
    
- `Core Data` is powerful, can be backed by different persistent stores (SQLite is just one of them, but you can also choose XML files or you can even write your own format!), and gives relationships between elements. It is complex and provides many features useful for the development, like KVO and contexts. You should use it for large data sets of many correlated records, that could be user generated or provided by a server.
    
- `Raw SQLite` is useful when you need really, really fast access to a relational data source (Core Data introduces some overhead), or if you need to support the same SQLite format across multiple platforms (you should never mess with CoreData inner SQLite: it uses its own format, so you can't just "import" an existing SQLite in CoreData). For example, for a project I worked for, a webservice provided me some large SQLite instead of jsons or xmls: some of this SQLite were imported to CoreData (operation that could take a while, depending on the source size), because I needed all the features of it, while other SQLites were read directly for a really fast access.
    
- `Webserver storage` well it should be obvious: if you need to store data to a server it is because the device shouldn't be the only owner of that data. But if you just need to synchronize the same App across different iOS devices (or even with a Mac-ported version of the App) you could also look at iCloud storage, obviously.

Question 10

Explain iOS App States

Accepted Answer

Every iOS app is always in one of the five app states. The operating system manages the app state, but the app itself is responsible for managing important tasks to ensure smooth transitions between the states. The five states of an iOS app - as listed in the [iOS App Programming Guide](http://developer.apple.com/library/ios/#DOCUMENTATION/iPhone/Conceptual/iPhoneOSProgrammingGuide/ManagingYourApplicationsFlow/ManagingYourApplicationsFlow.html) - include the following:

1. **_Non-running_** - The app is not running.
2. **_Inactive_** - The app is running in the foreground, but not receiving events. An iOS app can be placed into an inactive state, for example, when a call or SMS message is received.
3. **_Active_** - The app is running in the foreground, and receiving events.
4. **_Background_** - The app is running in the background, and executing code.
5. **_Suspended_** - The app is in the background, but no code is being executed.

Top 36 iOS Interview Questions

What is CoreData?

What are different ways that you can specify the layout of elements in a `UIView`?

Explain what is `NSUserDefaults`?

What's your preference when writing UI's? Xib files, Storyboards or programmatic `UIView`?

What is the difference between `viewDidLoad` and `viewDidAppear`?

What is the `reuseIdentifier` used for?

When would you use Core Data over `NSUserDefault`?

Explain View Controller Lifecycle events and their order

What’s the difference between an app ID and a bundle ID and what is each used for?

What is AutoLayout? What does it mean when a constraint is broken by iOS?

What is the Responder Chain?

What mechanisms does iOS provide to support multi-threading?

What considerations do you need when writing a `UITableViewController` which shows images downloaded from a remote server?

A grandparent, parent and child problem

Explain code signing for iOS apps

What are some pros and cons of Core Data?

Explain when to use various storage mechanisms in iOS?

Explain iOS App States

Explain the difference between Background vs Suspended app state

What's the difference between the `frame` and the `bounds`?

What options do you have for implementing storage and persistence on iOS?

What are the options for laying out UI on iOS?

Explain how an autorelease pool works at the runtime level

What is the difference between ARC (automatic reference counting) and GC (garbage collection)?

**What's the difference between using a delegate and notification?**

What is QoS (Quality of Service) in GCD?

What are the reasons for using `NSOperationQueue` over GCD and vice versa?

Describe managed object context and the functionality that it provides

What are the most important application delegate methods?

What is `@autoreleasepool`?

Explain usage of Concurrent vs Serial Queues with `async` and `sync` blocks

What are the benefits of using `DispatchWorkItem` in Swift?

What iOS architectures do you know that scale?

Explain the use case when ARC won't help you to release memory (but GC will)?

Which is the best of GCD, `NSThread` or `NSOperationQueue`?

Why and in which conditions should we use `@autoreleasepool`?

Top 36 iOS Interview Questions

What is CoreData?

What are different ways that you can specify the layout of elements in a UIView?

Explain what is NSUserDefaults?

What's your preference when writing UI's? Xib files, Storyboards or programmatic UIView?

What is the difference between viewDidLoad and viewDidAppear?

What is the reuseIdentifier used for?

When would you use Core Data over NSUserDefault?

Explain View Controller Lifecycle events and their order

What’s the difference between an app ID and a bundle ID and what is each used for?

What is AutoLayout? What does it mean when a constraint is broken by iOS?

What is the Responder Chain?

What mechanisms does iOS provide to support multi-threading?

What considerations do you need when writing a UITableViewController which shows images downloaded from a remote server?

A grandparent, parent and child problem

Explain code signing for iOS apps

What are some pros and cons of Core Data?

Explain when to use various storage mechanisms in iOS?

Explain iOS App States

Explain the difference between Background vs Suspended app state

What's the difference between the frame and the bounds?

What options do you have for implementing storage and persistence on iOS?

What are the options for laying out UI on iOS?

Explain how an autorelease pool works at the runtime level

What is the difference between ARC (automatic reference counting) and GC (garbage collection)?

What's the difference between using a delegate and notification?

What is QoS (Quality of Service) in GCD?

What are the reasons for using NSOperationQueue over GCD and vice versa?

Describe managed object context and the functionality that it provides

What are the most important application delegate methods?

What is @autoreleasepool?

Explain usage of Concurrent vs Serial Queues with async and sync blocks

What are the benefits of using DispatchWorkItem in Swift?

What iOS architectures do you know that scale?

Explain the use case when ARC won't help you to release memory (but GC will)?

Which is the best of GCD, NSThread or NSOperationQueue?

Why and in which conditions should we use @autoreleasepool?

What are different ways that you can specify the layout of elements in a `UIView`?

Explain what is `NSUserDefaults`?

What's your preference when writing UI's? Xib files, Storyboards or programmatic `UIView`?

What is the difference between `viewDidLoad` and `viewDidAppear`?

What is the `reuseIdentifier` used for?

When would you use Core Data over `NSUserDefault`?

What considerations do you need when writing a `UITableViewController` which shows images downloaded from a remote server?

What's the difference between the `frame` and the `bounds`?

**What's the difference between using a delegate and notification?**

What are the reasons for using `NSOperationQueue` over GCD and vice versa?

What is `@autoreleasepool`?

Explain usage of Concurrent vs Serial Queues with `async` and `sync` blocks

What are the benefits of using `DispatchWorkItem` in Swift?

Which is the best of GCD, `NSThread` or `NSOperationQueue`?

Why and in which conditions should we use `@autoreleasepool`?