Professional Documents
Culture Documents
Managed Object Model – It describes the schema that you use in the app. If you have a database
background, think of this as the database schema. However, the schema is represented by a collection of
objects (also known as entities). In Xcode, the Managed Object Model is defined in a file with the
extension .xcdatamodeld. You can use the visual editor to define the entities and their attributes, as well
as, relationships.
Persistent Store Coordinator – SQLite is the default persistent store in iOS. However, Core Data allows
developers to setup multiple stores containing different entities. The Persistent Store Coordinator is the
party responsible to manage different persistent object stores and save the objects to the stores. Forget
about it you don’t understand what it is. You’ll not interact with Persistent Store Coordinator directly when
using Core Data.
Managed Object Context – Think of it as a “scratch pad” containing objects that interacts with data in
persistent store. Its job is to manage objects created and returned using Core Data. Among the
components in the Core Data Stack, the Managed Object Context is the one you’ll work with for most of
the time. In general, whenever you need to fetch and save objects in persistent store, the context is the
first component you’ll talk to.
The below illustration can probably give you a better idea about the Core Data Stack:
Part - 1
1- How could you setup Live Rendering ?
The attribute @IBDesignable lets Interface Builder perform live updates on a particular view.
5- What is Enum ?
Enum is a type that basically contains a group of related values in same umbrella.
16- What’s the difference between the frame and the bounds?
The bounds of an UIView is the rectangle, expressed as a location (x,y) and size (width,height) relative to
its own coordinate system (0,0).
The frame of an UIView is the rectangle, expressed as a location (x,y) and size (width,height) relative to
the superview it is contained within.
37- How many are there APIs for battery-efficient location tracking ?
There are 3 apis.
● Significant location changes — the location is delivered approximately every 500 metres (usually
up to 1 km)
● Region monitoring — track enter/exit events from circular regions with a radius equal to 100m or
more. Region monitoring is the most precise API after GPS.
● Visit events — monitor place Visit events which are enters/exits from a place (home/office).
in an NSOperationQueue, the terms concurrent and non-concurrent do not necessarily refer to the
side-by-side execution of threads. Instead, a non-concurrent operation is one that executes using the
environment that is provided for it while a concurrent operation is responsible for setting up its own
execution environment.
The iOS architecture can be broken down into four distinct layers:
● Cocoa Touch
● Media
● Core Services
● Core OS
Core OS - This important layer is in charge of managing memory—allocating and releasing memory once
the application has finished with it, taking care of file system tasks, handling networking, and other
operating system tasks. It also interacts directly with the hardware.
Core Services - Some of the Important Frameworks available in the core services layers.
Graphics, audio, and video are handled by the Media layer.
Cocoa Touch - Multitasking support. – Basic app management and infrastructure. – User interface
management – Support for Touch and Motion event. – Cut, copy and paste support and many more.
46- Readers-Writers
Multiple threads reading at the same time while there should be only one thread writing. The solution to
the problem is a readers-writers lock which allows concurrent read-only access and an exclusive write
access. Terminology;
● Race Condition A race condition occurs when two or more threads can access shared data and
they try to change it at the same time.
● Deadlock A deadlock occurs when two or sometimes more tasks wait for the other to finish, and
neither ever does.
● Readers-Writers problem Multiple threads reading at the same time while there should be only
one thread writing.
● Readers-writer lock Such a lock allows concurrent read-only access to the shared resource while
write operations require exclusive access.
● Dispatch Barrier Block Dispatch barrier blocks create a serial-style bottleneck when working with
concurrent queues.
47- NSOperation — NSOperationQueue — NSBlockOperation
NSOperation adds a little extra overhead compared to GCD, but we can add dependency among various
operations and re-use, cancel or suspend them.
NSOperationQueue, It allows a pool of threads to be created and used to execute NSOperations in
parallel. Operation queues aren’t part of GCD.
NSBlockOperation allows you to create an NSOperation from one or more closures. NSBlockOperations
can have multiple blocks, that run concurrently.
48- KVC — KVO
KVC adds stands for Key-Value Coding. It’s a mechanism by which an object’s properties can be
accessed using string’s at runtime rather than having to statically know the property names at
development time.
KVO stands for Key-Value Observing and allows a controller or class to observe changes to a property
value. In KVO, an object can ask to be notified of any changes to a specific property, whenever that
property changes value, the observer is automatically notified.
Part - 2
4- What is ARC ?
ARC is a compile time feature that is Apple’s version of automated memory management. It stands for
Automatic Reference Counting. This means that it only frees up memory for objects when there are zero
strong references/ to them.
5- Explain #keyPath() ?
Using #keyPath(), a static type check will be performed by virtue of the key-path literal string being used
as a StaticString or StringLiteralConvertible. At this point, it’s then checked to ensure that it
A) is actually a thing that exists and
B) is properly exposed to Objective-C.
8- What is NSFetchRequest ?
NSFetchRequest is the class responsible for fetching from Core Data. Fetch requests are both powerful
and flexible. You can use fetch requests to fetch a set of objects meeting the provided criteria, individual
values and more.
9- Explain NSPersistentContainer ?
The persistent container creates and returns a container, having loaded the store for the application to it.
This property is optional since there are legitimate error conditions that could cause the creation of the
store to fail.
16- What is the difference fileprivate, private and public private(set) access level ?
fileprivate is accessible within the current file, private is accessible within the current declaration.
public private(set) means getter is public, but the setter is private.
21- What is five essential practical guidelines to improve your typographic quality of mobile product
designs ?
1. Start by choosing your body text typeface.
2. Try to avoid mixing typefaces.
3. Watch your line length.
4. Balance line height and point size.
5. Use proper Apostrophes and Dashes.
35- Why do we use a delegate pattern to be notified of the text field’s events?
Because at most only a single object needs to know about the event.
Most state transitions are accompanied by a corresponding call to the methods of your app delegate
object. These methods are your chance to respond to state changes in an appropriate way. These
methods are listed below, along with a summary of how you might use them.
● application:willFinishLaunchingWithOptions:—This method is your app’s first chance to execute
code at launch time.
● application:didFinishLaunchingWithOptions:—This method allows you to perform any final
initialization before your app is displayed to the user.
● applicationDidBecomeActive:—Lets your app know that it is about to become the foreground app.
Use this method for any last minute preparation.
● applicationWillResignActive:—Lets you know that your app is transitioning away from being the
foreground app. Use this method to put your app into a quiescent state.
● applicationDidEnterBackground:—Lets you know that your app is now running in the background
and may be suspended at any time.
● applicationWillEnterForeground:—Lets you know that your app is moving out of the background
and back into the foreground, but that it is not yet active.
● applicationWillTerminate:—Lets you know that your app is being terminated. This method is not
called if your app is suspended.
45- What are the most important application delegate methods a developer should handle ?
The operating system calls specific methods within the application delegate to facilitate transitioning to
and from various states. The seven most important application delegate methods a developer should
handle are:
application:willFinishLaunchingWithOptions -- Method called when the launch process is initiated. This is
the first opportunity to execute any code within the app.
application:didFinishLaunchingWithOptions -- Method called when the launch process is nearly complete.
Since this method is called is before any of the app’s windows are displayed, it is the last opportunity to
prepare the interface and make any final adjustments.
applicationDidBecomeActive -- Once the application has become active, the application delegate will
receive a callback notification message via the method applicationDidBecomeActive. This method is also
called each time the app returns to an active state from a previous switch to inactive from a resulting
phone call or SMS.
applicationWillResignActive -- There are several conditions that will spawn the
applicationWillResignActive method. Each time a temporary event, such as a phone call, happens this
method gets called. It is also important to note that “quitting” an iOS app does not terminate the
processes, but rather moves the app to the background.
applicationDidEnterBackground -- This method is called when an iOS app is running, but no longer in the
foreground. In other words, the user interface is not currently being displayed. According to Apple’s
UIApplicationDelegate Protocol Reference, the app has approximately five seconds to perform tasks and
return. If the method does not return within five seconds, the application is terminated.
applicationWillEnterForeground -- This method is called as an app is preparing to move from the
background to the foreground. The app, however, is not moved into an active state without the
applicationDidBecomeActive method being called. This method gives a developer the opportunity to
re-establish the settings of the previous running state before the app becomes active.
applicationWillTerminate -- This method notifies your application delegate when a termination event has
been triggered. Hitting the home button no longer quits the application. Force quitting the iOS app, or
shutting down the device triggers the applicationWillTerminate method. This is the opportunity to save the
application configuration, settings, and user preferences.
Part - 3
1- What is Nil Coalescing & Ternary Operator ?
It is an easily return an unwrapped optional, or a default value. If we do not have value, we can set zero
or default value.
4- What is DispatchGroup ?
DispatchGroup allows for aggregate synchronization of work. We can use them to submit multiple
different work items and track when they all complete, even though they might run on different queues.
This behavior can be helpful when progress can’t be made until all of the specified tasks are
complete. — Apple’s Documentation
The most basic answer: If we need to wait on a couple of asynchronous or synchronous operations
before proceeding, we can use DispatchGroup.
17- Which git command saves your code without making a commit ?
git stash
39- Explain the difference between atomic and nonatomic synthesized properties
atomic : It is the default behaviour. If an object is declared as atomic then it becomes thread-safe.
Thread-safe means, at a time only one thread of a particular instance of that class can have the control
over that object.
nonatomic: It is not thread-safe. We can use the nonatomic property attribute to specify that synthesized
accessors simply set or return a value directly, with no guarantees about what happens if that same value
is accessed simultaneously from different threads. For this reason, it’s faster to access a nonatomic
property than an atomic one.
Part - 4
5- What’s accessibilityHint?
accessibilityHint describes the results of interacting with a user interface element. A hint should be
supplied only if the result of an interaction is not obvious from the element’s label.
6- Explain place holder constraint
This tells Interface Builder to go ahead and remove the constraints when we build and run this code. It
allows the layout engine to figure out a base layout, and then we can modify that base layout at run time.
15- Why do we need to specify self to refer to a stored property or a method When writing asynchronous
code?
Since the code is dispatched to a background thread we need to capture a reference to the correct object.
37- What kind of benefits does Xcode server have for developers?
Xcode server will automatically check out our project, build the app, run tests, and archive the app for
distribution.
47- How to find the distance between two points (1x, 1y and 2x, 2y)?
We need to calculate the distance between the points, we can omit the sqrt() which will make it a little
faster. This question’s background is Pythagorean theorem. We can find the result with CGPoint.
p1
|\
|\
| \H
| \
| \
|_ _ _\p2
The reuseIdentifier is used to group together similar rows in an UITableView; i.e., rows that differ only in
their content, but otherwise have 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 when the table view is scrolled, UITableView will
first attempt to reuse an already allocated UITableViewCell with the same reuseIdentifier. If
reuseIdentifier has not been set, the UITableView will be forced to allocate new UITableViewCell objects
for each new item that scrolls into view, potentially leading to laggy animations.
2. What are different ways that you can specify the layout of elements in a UIView?
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 CGRects describing the exact coordinates for each element and pass them to UIView’s -
(id)initWithFrame:(CGRect)frame method.
3. What is the difference between atomic and nonatomic properties? Which is the default for synthesized
properties? When would you use one vs. the other?
Properties specified as atomic are guaranteed to always return a fully initialized object. This also happens
to be the default state for synthesized properties so, while it’s a good practice to specify atomic to remove
the potential for confusion, if you leave it off, your properties will still be atomic. This guarantee of atomic
properties comes at a cost to performance, however. If you have a property for which you know that
retrieving an uninitialized value is not a risk (e.g. if all access to the property is already synchronized via
other means), then setting it to nonatomic can gain you a bit of performance.
4. Imagine you wanted to record the time that your application was launched, so you created a class that
defined a global variable in its header: NSString *startTime;. Then, in the class’ implementation, you set
the variable as follows:
+ (void)initialize {
NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
[formatter setDateStyle:NSDateFormatterNoStyle];
[formatter setTimeStyle:NSDateFormatterMediumStyle];
startTime = [formatter stringFromDate:[NSDate date]];
}
If you then added the following line to the application:didFinishLaunchingWithOptions: method in your
AppDelegate:
The debugger console will log Application was launched at: (null) because the global startTime variable
has not yet been set. The initialize method of an Objective-C class is only called right before the first
message is sent to that class. On the other hand, any load methods defined by Objective-C classes will
be called as soon as the class is added to the Objective-C runtime.
Way to Solve #1: Changing initialize to load will yield the desired result (but be cautious about doing too
much in load, as it may increase your application’s load time).
Way to Solve #2, thanks to commenter John, there is another way: create another class method on your
created class. Let’s call this new method getStartTime, and all it does is return our global startTime
object.
#import "TTAppDelegate.h"
@end
@implementation TTParent
@end
@end
@implementation TTChild
@end
@implementation TTAppDelegate
- (BOOL)application:(UIApplication *)application
didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
TTParent *parent = [[TTParent alloc] init];
parent.children = [[NSMutableArray alloc] init];
for (int i = 0; i < 10; i++) {
TTChild *child = [[TTChild alloc] init];
child.parent = parent;
[parent.children addObject:child];
}
return YES;
}
@end
What is the bug in this code and what is its consequence? How could you fix it?
This is a classic example of a retain cycle. The parent will retain the children array, and the array will
retain each TTChild object added to it. Each child object that is created will also retain its parent, so that
even after the last external reference to parent is cleared, the retain count on parent will still be greater
than zero and it will not be removed.
In order to fix this, the child’s reference back to the parent needs to be declared as a weak reference as
follows:
@end
A weak reference will not increment the target’s retain count, and will be set to nil when the target is
finally destroyed.
Note:
For a more complicated variation on this question, you could consider two peers that keep references to
each other in an array. In this case, you will need to substitute NSArray/NSMutableArray with an
NSPointerArray declared as:
@end
@implementation TTWaitController
- (void)viewDidLoad
{
CGRect frame = CGRectMake(20, 200, 200, 20);
self.alert = [[UILabel alloc] initWithFrame:frame];
self.alert.text = @"Please wait 10 seconds...";
self.alert.textColor = [UIColor whiteColor];
[self.view addSubview:self.alert];
@end
@implementation TTAppDelegate
- (BOOL)application:(UIApplication *)application
didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
self.window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
self.window.rootViewController = [[TTWaitController alloc] init];
[self.window makeKeyAndVisible];
return YES;
}
How could you fix this issue?
When the above code dispatches work using NSOperationQueue’s method addOperationWithBlock,
there is no guarantee that the block being enqueued will be executed on the main thread. Notice that the
content of the UILabel is being updated within the body of the block. UI updates that are not executed on
the main thread can lead to undefined behavior. This code might appear to be working correctly for a long
time before anything goes wrong, but UI updates should always happen on the main thread.
The easiest way to fix the potential issue is to change the body of the block so that the update is
re-enqueued using the main thread’s queue as follows:
[waitQueue addOperationWithBlock:^{
[NSThread sleepUntilDate:[NSDate dateWithTimeIntervalSinceNow:10]];
[[NSOperationQueue mainQueue] addOperationWithBlock:^{
self.alert.text = @"Thanks!";
}];
}];
7. What’s the difference between an “app ID” and a “bundle ID” and what is each used for?
An App ID is a two-part string used to identify one or more apps from a single development team. The
string consists of a Team ID and a bundle ID search string, with a period (.) separating the two parts. The
Team ID is supplied by Apple and is unique to a specific development team, while the bundle ID search
string is supplied by teh developer to match either the bundle ID of a single app or a set of bundle IDs for
a group of apps.
Because most people think of the App ID as a string, they think it is interchangeable with Bundle ID. It
appears this way because once the App ID is created in the Member Center, you only ever use the App
ID Prefix which matches the Bundle ID of the Application Bundle.
The bundle ID uniquely defines each App. It is specified in Xcode. A single Xcode project can have
multiple Targets and therefore output multiple apps. A common use case for this is an app that has both
lite/free and pro/full versions or is branded multiple ways.
8. What are “strong” and “weak” references? Why are they important and how can they be used to help
control memory management and avoid memory leaks?
By default, any variable that points to another object does so with what is referred to as a “strong”
reference. A retain cycle occurs when two or more objects have reciprocal strong references (i.e., strong
references to each other). Any such objects will never be destroyed by ARC (iOS’ Automatic Reference
Counting). Even if every other object in the application releases ownership of these objects, these objects
(and, in turn, any objects that reference them) will continue to exist by virtue of those mutual strong
references. This therefore results in a memory leak.
Reciprocal strong references between objects should therefore be avoided to the extent possible.
However, when they are necessary, a way to avoid this type of memory leak is to employ weak
references. Declaring one of the two references as weak will break the retain cycle and thereby avoid the
memory leak.
To decide which of the two references should be weak, think of the objects in the retain cycle as being in
a parent-child relationship. In this relationship, the parent should maintain a strong reference (i.e.,
ownership of) its child, but the child should not maintain maintain a strong reference (i.e., ownership of) its
parent.
For example, if you have Employer and Employee objects, which reference one another, you would most
likely want to maintain a strong reference from the Employer to the Employee object, but have a weak
reference from the Employee to thr Employer.
You can think of a managed object context as an intelligent scratch pad. When you fetch objects from a
persistent store, you bring temporary copies onto the scratch pad where they form an object graph (or a
collection of object graphs). You can then modify those objects however you like. Unless you actually
save those changes, though, the persistent store remains unchanged.
Life-cycle management. The context provides validation, inverse relationship handling, and undo/redo.
Through a context you can retrieve or “fetch” objects from a persistent store, make changes to those
objects, and then either discard the changes or commit them back to the persistent store. The context is
responsible for watching for changes in its objects and maintains an undo manager so you can have
finer-grained control over undo and redo. You can insert new objects and delete ones you have fetched,
and commit these modifications to the persistent store.
Notifications. A context posts notifications at various points which can optionally be monitored elsewhere
in your application.
Concurrency. Core Data uses thread (or serialized queue) confinement to protect managed objects and
managed object contexts. In OS X v10.7 and later and iOS v5.0 and later, when you create a context you
can specify the concurrency pattern with which you will use it using initWithConcurrencyType:.
For more information, see the iOS Developer Library Core Data Basics or the NSManagedObjectContext
reference.
10. Compare and contrast the different ways of achieving concurrency in OS X and iOS.
threads
dispatch queues
operation queues
The disadvantage of threads is that they relegate the burden of creating a scalable solution to the
developer. You have to decide how many threads to create and adjust that number dynamically as
conditions change. Also, the application assumes most of the costs associated with creating and
maintaining the threads it uses.
OS X and iOS therefore prefer to take an asynchronous design approach to solving the concurrency
problem rather than relying on threads.
One of the technologies for starting tasks asynchronously is Grand Central Dispatch (GCD) that relegates
thread management down to the system level. All the developer has to do is define the tasks to be
executed and add them to the appropriate dispatch queue. GCD takes care of creating the needed
threads and scheduling tasks to run on those threads.
All dispatch queues are first-in, first-out (FIFO) data structures, so tasks are always started in the same
order that they are added.
An operation queue is the Cocoa equivalent of a concurrent dispatch queue and is implemented by the
NSOperationQueue class. Unlike dispatch queues, operation queues are not limited to executing tasks in
FIFO order and support the creation of complex execution-order graphs for your tasks.
11. Will the code below log “areEqual” or “areNotEqual”? Explain your answer.
if (firstUserName == secondUserName)
{
NSLog(@"areEqual");
}
else
{
NSLog(@"areNotEqual");
}
12. List and explain the different types of iOS Application States.
Not running state: The app has not been launched or was running but was terminated by the system.
Inactive state: The app is running in the foreground but is currently not receiving events. (It may be
executing other code though.) An app usually stays in this state only briefly as it transitions to a different
state. The only time it stays inactive for any period of time is when the user locks the screen or the
system prompts the user to respond to some event (such as an incoming phone call or SMS message).
Active state: The app is running in the foreground and is receiving events. This is the normal mode for
foreground apps.
Background state: The app is in the background and executing code. Most apps enter this state briefly on
their way to being suspended. However, an app that requests extra execution time may remain in this
state for a period of time. In addition, an app being launched directly into the background enters this state
instead of the inactive state.
Suspended state: While suspended, an app remains in memory but does not execute any code. When a
low-memory condition occurs, the system may purge suspended apps without notice to make more space
for the foreground app.
application:willFinishLaunchingWithOptions
application:didFinishLaunchingWithOptions
What is the usage of these methods and what is difference between them?
Both methods are present in the AppDelegate.swift file. They are use to add functionality to the app when
the launching of app is going to take place.
MutableContainers: Arrays and dictionaries are created as variable objects, not constants.
MutableLeaves: Leaf strings in the JSON object graph are created as instances of variable strings.
allowFragments: The parser should allow top-level objects that are not an instance of arrays or
dictionaries.
Question 1
On a UITableViewCell constructor:
- (id)initWithStyle:(UITableViewCellStyle)style reuseIdentifier:(NSString *)reuseIdentifier
What is the reuseIdentifier used for?
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 2
Explain the difference between atomic and nonatomic synthesized properties?
Atomic and non-atomic refers to whether the setters/getters for a property will atomically read and write
values to the property. When the atomic keyword is used on a property, any access to it will be
“synchronized”. Therefore a call to the getter will be guaranteed to return a valid value, however this does
come with a small performance penalty. Hence in some situations nonatomic is used to provide faster
access to a property, but there is a chance of a race condition causing the property to be nil under rare
circumstances (when a value is being set from another thread and the old value was released from
memory but the new value hasn’t yet been fully assigned to the location in memory for the property).
Question 3
Explain the difference between copy and retain?
Retaining an object means the retain count increases by one. This means the instance of the object will
be kept in memory until it’s retain count drops to zero. The property will store a reference to this instance
and will share the same instance with anyone else who retained it too. Copy means the object will be
cloned with duplicate values. It is not shared with any one else.
Want to ace your technical interview? Schedule a Technical Interview Practice Session with an expert
now!
Question 4
What is method swizzling in Objective C and why would you use it?
Method swizzling allows the implementation of an existing selector to be switched at runtime for a
different implementation in a classes dispatch table. Swizzling allows you to write code that can be
executed before and/or after the original method. For example perhaps to track the time method
execution took, or to insert log statements
#import "UIViewController+Log.h"
@implementation UIViewController (Log)
+ (void)load {
static dispatch_once_t once_token;
dispatch_once(&once_token, ^{
SEL viewWillAppearSelector = @selector(viewDidAppear:);
SEL viewWillAppearLoggerSelector = @selector(log_viewDidAppear:);
Method originalMethod = class_getInstanceMethod(self, viewWillAppearSelector);
Method extendedMethod = class_getInstanceMethod(self, viewWillAppearLoggerSelector);
method_exchangeImplementations(originalMethod, extendedMethod);
});
}
- (void) log_viewDidAppear:(BOOL)animated {
[self log_viewDidAppear:animated];
NSLog(@"viewDidAppear executed for %@", [self class]);
}
@end
Question 5
What’s the difference between not-running, inactive, active, background and suspended execution
states?
● Not running: The app has not been launched or was running but was terminated by the system.
● Inactive: The app is running in the foreground but is currently not receiving events. (It may be
executing other code though.) An app usually stays in this state only briefly as it transitions to a
different state.
● Active: The app is running in the foreground and is receiving events. This is the normal mode for
foreground apps.
● Background: The app is in the background and executing code. Most apps enter this state briefly
on their way to being suspended. However, an app that requests extra execution time may remain
in this state for a period of time. In addition, an app being launched directly into the background
enters this state instead of the inactive state.
● Suspended: The app is in the background but is not executing code. The system moves apps to
this state automatically and does not notify them before doing so. While suspended, an app
remains in memory but does not execute any code. When a low-memory condition occurs, the
system may purge suspended apps without notice to make more space for the foreground app.
Question 6
What is a category and when is it used?
A category is a way of adding additional methods to a class without extending it. It is often used to add a
collection of related methods. A common use case is to add additional methods to built in classes in the
Cocoa frameworks. For example adding async download methods to the UIImage class.
Question 7
Can you spot the bug in the following code and suggest how to fix it:
@interface MyCustomController : UIViewController
@implementation MyCustomController
- (void)viewDidLoad {
CGRect frame = CGRectMake(100, 100, 100, 50);
self.alert = [[UILabel alloc] initWithFrame:frame];
self.alert.text = @"Please wait...";
[self.view addSubview:self.alert];
dispatch_async(
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0),
^{
sleep(10);
self.alert.text = @"Waiting over";
}
);
}
@end
All UI updates must be done on the main thread. In the code above the update to the alert text may or
may not happen on the main thread, since the global dispatch queue makes no guarantees . Therefore
the code should be modified to always run the UI update on the main thread
dispatch_async(
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0),
^{
sleep(10);
dispatch_async(dispatch_get_main_queue(), ^{
self.alert.text = @"Waiting over";
});
});
Question 8
What is the difference between viewDidLoad and viewDidAppear?
Which should you use to load data from a remote server to display in the view?
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 9
What considerations do you need when writing a UITableViewController which shows images
downloaded from a remote server?
This is a very common task in iOS and a good answer here can cover a whole host of knowledge. The
important piece of information in the question is that the images are hosted remotely and they may take
time to download, therefore when it asks for “considerations”, you should be talking about:
● Only download the image when the cell is scrolled into view, i.e. when cellForRowAtIndexPath is
called.
● Downloading the image asynchronously on a background thread so as not to block the UI so the
user can keep scrolling.
● When the image has downloaded for a cell we need to check if that cell is still in the view or
whether it has been re-used by another piece of data. If it’s been re-used then we should discard
the image, otherwise we need to switch back to the main thread to change the image on the cell.
Other good answers will go on to talk about offline caching of the images, using placeholder images while
the images are being downloaded.
Question 10
What is a protocol, and how do you define your own and when is it used?
A protocol is similar to an interface from Java. It defines a list of required and optional methods that a
class must/can implement if it adopts the protocol. Any class can implement a protocol and other classes
can then send messages to that class based on the protocol methods without it knowing the type of the
class.
@protocol MyCustomDataSource
- (NSUInteger)numberOfRecords;
- (NSDictionary *)recordAtIndex:(NSUInteger)index;
@optional
- (NSString *)titleForRecordAtIndex:(NSUInteger)index;
@end
Question 11
What is KVC and KVO? Give an example of using KVC to set a value.
KVC stands for Key-Value Coding. It's a mechanism by which an object's properties can be accessed
using string's at runtime rather than having to statically know the property names at development time.
KVO stands for Key-Value Observing and allows a controller or class to observe changes to a property
value.
Let's say there is a property name on a class:
@property (nonatomic, copy) NSString *name;
Question 12
What are blocks and how are they used?
Blocks are a way of defining a single task or unit of behavior without having to write an entire Objective-C
class. Under the covers Blocks are still Objective C objects. They are a language level feature that allow
programming techniques like lambdas and closures to be supported in Objective-C. Creating a block is
done using the ^ { }syntax:
myBlock = ^{
NSLog(@"This is a block");
}
It is essentially a function pointer which also has a signature that can be used to enforce type safety at
compile and runtime. For example you can pass a block with a specific signature to a method like so:
- (void)callMyBlock:(void (^)(void))callbackBlock;
If you wanted the block to be given some data you can change the signature to include them:
- (void)callMyBlock:(void (^)(double, double))block {
...
block(3.0, 2.0);
}
Question 13
What mechanisms does iOS provide to support multi-threading?
● NSThread creates a new low-level thread which can be started by calling the start method.
NSThread* myThread = [[NSThread alloc] initWithTarget:self
selector:@selector(myThreadMainMethod:)
object:nil];
[myThread start];
● GCD or Grand Central Dispatch is a modern feature of Objective-C that provides a rich set of
methods and API's to use in order to support common multi-threading tasks. GCD provides a way
to queue tasks for dispatch on either the main thread, a concurrent queue (tasks are run in
parallel) or a serial queue (tasks are run in FIFO order).
dispatch_queue_t myQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,
0);
dispatch_async(myQueue, ^{
printf("Do some work here.\n");
});
Question 14
What is the Responder Chain?
When an event happens in a view, for example a touch event, the view will fire the event to a chain of
UIResponder objects associated with the UIView. The first UIResponder is the UIView itself, if it does not
handle the event then it continues up the chain to until UIResponder handles the event. The chain will
include UIViewControllers, parent UIViews and their associated UIViewControllers, if none of those
handle the event then the UIWindow is asked if it can handle it and finally if that doesn't handle the event
then the UIApplicationDelegate is asked.
If you get the opportunity to draw this one out, it's worth doing to impress the interviewer:
Question 15
What's the difference between using a delegate and notification?
Both are used for sending values and messages to interested parties. A delegate is for one-to-one
communication and is a pattern promoted by Apple. In delegation the class raising events will have a
property for the delegate and will typically expect it to implement some protocol. The delegating class can
then call the _delegate_s protocol methods.
Notification allows a class to broadcast events across the entire application to any interested parties. The
broadcasting class doesn't need to know anything about the listeners for this event, therefore notification
is very useful in helping to decouple components in an application.
[NSNotificationCenter defaultCenter]
postNotificationName:@"TestNotification"
object:self];
Question 16
What's your preference when writing UI's? Xib files, Storyboards or programmatic UIView?
There's no right or wrong answer to this, but it's great way of seeing if you understand the benefits and
challenges with each approach. Here's the common answers I hear:
● 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
UIViews or Xib files.
Question 17
How would you securely store private user data offline on a device? What other security best practices
should be taken?
Again there is no right answer to this, but it's a great way to see how much a person has dug into iOS
security. If you're interviewing with a bank I'd almost definitely expect someone to know something about
it, but all companies need to take security seriously, so here's the ideal list of topics I'd expect to hear in
an answer:
● If the data is extremely sensitive then it should never be stored offline on the device because all
devices are crackable.
● The keychain is one option for storing data securely. However it's encryption is based on the pin
code of the device. User's are not forced to set a pin, so in some situations the data may not even
be encrypted. In addition the users pin code may be easily hacked.
● A better solution is to use something like SQLCipher which is a fully encrypted SQLite database.
The encryption key can be enforced by the application and separate from the user's pin code.
Other security best practices are:
● Only communicate with remote servers over SSL/HTTPS.
● If possible implement certificate pinning in the application to prevent man-in-the-middle attacks on
public WiFi.
● Clear sensitive data out of memory by overwriting it.
● Ensure all validation of data being submitted is also run on the server side.
Question 18
What is MVC and how is it implemented in iOS?
What are some pitfalls you've experienced with it? Are there any alternatives to MVC?
MVC stands for Model, View, Controller. It is a design pattern that defines how to separate out logic when
implementing user interfaces. In iOS, Apple provides UIView as a base class for all _View_s,
UIViewController is provided to support the Controller which can listen to events in a View and update the
View when data changes. The Model represents data in an application and can be implemented using
any NSObject, including data collections like NSArray and NSDictionary.
Some of the pitfalls that people hit are bloated UIViewController and not separating out code into classes
beyond the MVC format. I'd highly recommend reading up on some solutions to this:
● https://www.objc.io/issues/1-view-controllers/lighter-view-controllers/
● https://speakerdeck.com/trianglecocoa/unburdened-viewcontrollers-by-jay-thrash
● https://programmers.stackexchange.com/questions/177668/how-to-avoid-big-and-clumsy-uitablevi
ewcontroller-on-ios
In terms of alternatives, this is pretty open ended. The most common alternative is MVVM using
ReactiveCocoa, but others include VIPER and using Functional Reactive code.
Question 19
A product manager in your company reports that the application is crashing. What do you do?
This is a great question in any programming language and is really designed to see how you problem
solve. You're not given much information, but some interviews will slip you more details of the issue as
you go along. Start simple:
● get the exact steps to reproduce it.
● find out the device, iOS version.
● do they have the latest version?
● get device logs if possible.
Once you can reproduce it or have more information then start using tooling. Let's say it crashes because
of a memory leak, I'd expect to see someone suggest using Instruments leak tool. A really impressive
candidate would start talking about writing a unit test that reproduces the issue and debugging through it.
Other variations of this question include slow UI or the application freezing. Again the idea is to see how
you problem solve, what tools do you know about that would help and do you know how to use them
correctly.
Question 20
What is AutoLayout? What does it mean when a constraint is "broken" by iOS?
AutoLayout is way of laying out UIViews using a set of constraints that specify the location and size
based relative to other views or based on explicit values. AutoLayout makes it easier to design screens
that resize and layout out their components better based on the size and orientation of a screen.
_Constraint_s include:
● setting the horizontal/vertical distance between 2 views
● setting the height/width to be a ratio relative to a different view
● a width/height/spacing can be an explicit static value
Sometimes constraints conflict with each other. For example imagine a UIView which has 2 height
constraints: one says make the UIView 200px high, and the second says make the height twice the height
of a button. If the iOS runtime can not satisfy both of these constraints then it has to pick only one. The
other is then reported as being "broken" by iOS.
1. What was the latest version of iOS you worked with? What do you like about it and why?
The purpose of this question is to inquire if the interviewee actually keeps up with the latest development
from Apple.
Expected answer: he/she tells you what the latest version of the system is and what he/she has worked
with lately. And tells you about one of the new features of the system that he/she is excited about (i.e. I
love new multitasking on iPad because it’s going to make user experience way better and opens up a lot
of opportunities for us developers to build new cool things, etc.).
2. Have you worked with Swift? What do you like about it? What you don’t like?
This question will give you a sense of several things:
● is he cautious with using something as unstable as Swift. For example 2.0/2.1 releases broke a lot
of things/libraries and a senior developer would think twice about using Swift on a production
application. Because a lot of libraries and frameworks necessary for production ready iOS
development either do not exist yet in pure Swift or do not work anymore with newer versions of
the language (as of today - 11/11/15).
● whether the developer is bold enough to play with the cutting edge stuff
● what’s his long terms plans and expectations (is he optimistic or pessimistic or somewhere in
between)
Expected answer: be cautious, use Swift along with Objective-C for now and move to pure Swift down the
road in several years when it and the ecosystem of libraries around it matures enough.
4. What do you know about singletons? Where would you use one and where you wouldn't?
This is a typical objective oriented programming question. In case of iOS you can get a feel of how the
interviewee is using it in his/her apps. You’ll be able to weed out those people who came from Java/PHP
and such and use it as a “global” store or something similar.
Expected answer: singletons should be avoided and used only for objects that need to be shared
throughout your application for same reason. It should be used carefully, instantiated lazily, if it’s possible,
and passed into other objects as a dependency using Inversion of Control and Dependency Injection
principles.
Red flag: is when the interviewee talks about global variables and stores.
5. Could you explain what is the difference between Delegate and KVO?
With this question you are assessing their knowledge of different types of messaging patterns used in
iOS. Senior developer should’ve used both of those many times in his/her applications.
Expected answer: Both are ways to have relationships between objects. Delegation is a one to one
relationship where one object implements a delegate protocol and another uses it and sends messages
to assuming that those methods are implemented since the receiver promised to comply to the protocol.
KVO is many-to-many relationship where one object could broadcast a message and one or multiple
other objects can listen to it and react.
8. How do you serialize data on iOS (JSON from the web or local app data to Core Data and other
storages) ?
Data serialization is an important task for every iOS application. JSON is defacto standard of data
serialization on the web and every developer should know how to effectively work with it without spending
a lot of time writing boilerplate code. Same applies to data serialization for local storage. It can be
handled in multiple ways but a good developer should at least be aware of the challenges with these
tasks.
Expected answer: This is a tricky question. A naive developer would say that he/she parses JSON data
using Apple’s [NSJSONSerialization]
(https://developer.apple.com/library/ios/documentation/Foundation/Reference/NSJSONSerialization_Clas
s/) and then takes the resulting dictionary and assigns the data from each key to respective properties on
his/her model object. This is not what you expect a senior developer to tell you. Senior developer should
be aware of the issues that could arise with data serialization such as data validation and conversion. A
good answer would be clear understanding that in general there are two types of data serialization: JSON
to domain model, and domain model to persistence. Utilization of pods like Mantle or ObjectMapper or a
similar library/pod is expected.
15. Do you test your code? What do you do to make your code testable?
This is embarrassing but we admit that we don’t do testing as much as we should. We know we really
really should do it more. We are talking about Unit Testing and Integration Testing specifically here.
Expected answer: there is only one right answer here: either they do it or they wish they would. In general
iOS community isn’t as big on testing as say Ruby community. Partially it is due to inherited lack of testing
culture and partially due to lack of good tools for testing but things seems to be improving on that front.
The Questions
Now for the time you’ve been waiting for – the questions!
Our technical interviews last one hour and I have a sheet of 75 questions from which I will draw randomly
at first. Then, depending upon what I learn about the candidate, I will tailor my choice of questions
somewhat. For example, if I suspect the candidate has a weak spot, I will hone in on that area.
I do have favorites and go-to questions that will have to be retired after the publication of this article.
Expect my first question to now be: Have you read this article? :]
When answering questions, try to keep your answer brief and explain your thought process when it is
beneficial. The interviewer isn’t asking you these questions because they don’t know the answers – they
want to see if you know what you are talking about.
Note that I’m just going to list the questions here, not the answers. That’s for you to figure out, if you don’t
know already – learning is half the fun! Feel free to share the answers in the forums once you’ve figured
them out.
Without further ado, here are some sample questions for the technical interview:
● Explain method swizzling. When you would use it? — I like this question because it’s deep
language. Most people will never need to use swizzling. The developer’s answer to this question
also shows me how much restraint s/he has when implementing complex code. An answer of “I
swizzle everything” is much scarier than someone saying they have never worked with it.
● Take three objects: a grandparent, parent and child. The grandparent retains the parent, the
parent retains the child and the child retains the parent. The grandparent releases the parent.
Explain what happens. — Even with ARC, I like to ask a lot of memory-related questions, as it
shows that someone has been around for a while and has core knowledge about how things work.
● What happens when you invoke a method on a nil pointer? — Basic Objective-C handling is
important and it’s shocking how many times I have heard wrong answers to questions like this.
● Give two separate and independent reasons why retainCount should never be used in shipping
code. — This question has two benefits: to make sure someone isn’t using retainCount and to see
if they understand why they shouldn’t use it.
● Explain your process for tracing and fixing a memory leak. — This dives into the applicant’s
knowledge of memory, instruments and the debugging process. Sometimes I hear things like
“start commenting out code until it is fixed,” which is slightly terrifying.
● Explain how an autorelease pool works at the runtime level. — These types of questions go
beyond the basics a programmer will learn from a couple of books and investigates his or her
knowledge of how things actually work.
● When dealing with property declarations, what is the difference between atomic and non-atomic?
— Once again, it is shocking how many people don’t know the answer to this question. Many just
declare properties a certain way because it’s what they’ve seen others do. Questions like these
expose those issues.
● In C, how would you reverse a string as quickly as possible? — I don’t like to dive too deeply into
computer science, but this question lets me know how someone thinks about performance as well
as about his or her background in C. I have also been known to dig into big O notation.
● Which is faster: to iterate through an NSArray or an NSSet? — Another deep dive. Sometimes just
because a class solves a problem doesn’t mean it’s the one you should be using.
● Explain how code signing works. — A lot of applicants have no idea how code signing works and
then complain because they are having code signing issues.
● What is posing in Objective-C? — Posing is a little-used feature of Objective-C. Like the swizzling
question, this gives me an indication of how deep someone has dived into the language.
● List six instruments that are part of the standard. — This question gives me a general idea of how
much time someone has spent in instruments. Hint: It should be at least 10% of your coding time,
if not more.
● What are the differences between copy and retain? — Memory questions reveal a lot about a
developer’s knowledge, especially since many people are leaning on ARC these days.
● What is the difference between frames and bounds? — I don’t ask a lot of GUI-type questions and
I probably should ask more, but this one gives me an idea of how much layout work a developer
has done.
● What happens when the following code executes? Ball *ball = [[[[Ball alloc] init] autorelease]
autorelease]; — Another memory question. The answer I am looking for here is not just that it will
crash, which it will – I want to know why and when.
● List the five iOS app states. — Almost no one gets this question right. Normally I have to give an
example, such as background state, for them to know what I am talking about.
● Do you think this interview was a good representation of your skills as a developer? — Some
people test well and some don’t. I like to give people the option to explain their results a little.
Confidence is important and the answer to this question can reveal a lot about a person’s
confidence.
Many of these questions can be followed up with a “Why does that happen?” or “Explain your thinking in
getting there.” The point of a technical interview is to determine just how much of a language or platform a
candidate knows – and as you’ve seen, not just the breadth of knowledge, but the depth also.
The technical interview doesn’t do much to reveal what a person is like as a developer – it simply
determines if someone is worthy of moving forward in the process. The best academic developers who
may knock the technical interview out of the park may completely fall to pieces in the practical coding
interview, but someone who bombs the technical interview won’t be a good candidate for the position. If
they can’t discuss topics such as these with their coworkers, then they won’t be able to contribute to the
growth of the team.
A:Retain counts are the way in which memory is managed in Objective-C. When you create an object, it
has a retain count of 1. When you send an object a retain message, its retain count is incremented by 1.
When you send an object a release message, its retain count is decremented by 1. When you send an
object a autorelease message, its retain count is decremented by 1 at some stage in the future. If an
objectʼs retain count is reduced to 0, it is deallocated.
This will explain how the memory management is done in iOS
Development Basics
Q1. Where can you test Apple iPhone apps if you don’t have the device?
A. iOS Simulator can be used to test mobile applications. Xcode tool that comes along with iOS SDK
includes Xcode IDE as well as the iOS Simulator. Xcode also includes all required tools and frameworks
for building iOS apps. However, it is strongly recommended to test the app on the real device before
publishing it.
Q2. Does iOS support multitasking?
A. iOS 4 and above supports multi-tasking and allows apps to remain in the background until they are
launched again or until they are terminated.
Q3. Which JSON framework is supported by iOS?
A. SBJson framework is supported by iOS. It is a JSON parser and generator for Objective-C. SBJson
provides flexible APIs and additional control that makes JSON handling easier.
Q4. What are the tools required to develop iOS applications?
A. iOS development requires Intel-based Macintosh computer and iOS SDK.
Q5. Name the framework that is used to construct application’s user interface for iOS.
A. The UIKit framework is used to develop application’s user interface for iOS. UIKit framework provides
event handling, drawing model, windows, views, and controls specifically designed for a touch screen
interface.
Q6. Name the application thread from where UIKit classes should be used?
A. UIKit classes should be used only from an application’s main thread. Note: The derived classes of
UIResponder and the classes which manipulate application’s user interface should be used from
application’s main thread.
Q7. Which API is used to write test scripts that help in exercising the application's user interface
elements?
A. UI Automation API is used to automate test procedures. Tests scripts are written in JavaScript to the
UI Automation API. This in turn simulates user interaction with the application and returns log information
to the host computer.
App States and Multitasking
Q8. Why an app on iOS device behaves differently when running in foreground than in background?
A. An application behaves differently when running in foreground than in background because of the
limitation of resources on iOS devices.
Q9. How can an operating system improve battery life while running an app?
A. An app is notified whenever the operating system moves the apps between foreground and
background. The operating system improves battery life while it bounds what your app can do in the
background. This also improves the user experience with foreground app.
Q10. Which framework delivers event to custom object when app is in foreground?
A. The UIKit infrastructure takes care of delivering events to custom objects. As an app developer, you
have to override methods in the appropriate objects to process those events.
App States
Q11. When an app is said to be in not running state?
A. An app is said to be in 'not running' state when:
- it is not launched.
- it gets terminated by the system during running.
Q12. Assume that your app is running in the foreground but is currently not receiving events. In which
sate it would be in?
A. An app will be in InActive state if it is running in the foreground but is currently not receiving events. An
app stays in InActive state only briefly as it transitions to a different state.
Q13. Give example scenarios when an application goes into InActive state?
A. An app can get into InActive state when the user locks the screen or the system prompts the user to
respond to some event e.g. SMS message, incoming call etc.
Q14. When an app is said to be in active state?
A. An app is said to be in active state when it is running in foreground and is receiving events.
Q15. Name the app sate which it reaches briefly on its way to being suspended.
A. An app enters background state briefly on its way to being suspended.
Q16. Assume that an app is not in foreground but is still executing code. In which state will it be in?
A. Background state.
Q17. An app is loaded into memory but is not executing any code. In which state will it be in?
A. An app is said to be in suspended state when it is still in memory but is not executing any code.
Q18. Assume that system is running low on memory. What can system do for suspended apps?
A. In case system is running low on memory, the system may purge suspended apps without notice.
Q19. How can you respond to state transitions on your app?
A. On state transitions can be responded to state changes in an appropriate way by calling corresponding
methods on app's delegate object.
For example:
applicationDidBecomeActive method can be used to prepare to run as the foreground app.
applicationDidEnterBackground method can be used to execute some code when app is running in the
background and may be suspended at any time.
applicationWillEnterForeground method can be used to execute some code when your app is moving out
of the background
applicationWillTerminate method is called when your app is being terminated.
Q20. List down app's state transitions when it gets launched.
A. Before the launch of an app, it is said to be in not running state.
When an app is launched, it moves to the active or background state, after transitioning briefly through
the inactive state.
Q21. Who calls the main function of you app during the app launch cycle?
A. During app launching, the system creates a main thread for the app and calls the app’s main function
on that main thread. The Xcode project's default main function hands over control to the UIKit framework,
which takes care of initializing the app before it is run.
Core App Objects
Q22. What is the use of controller object UIApplication?
A. Controller object UIApplication is used without subclassing to manage the application event loop.
It coordinates other high-level app behaviors.
It works along with the app delegate object which contains app-level logic.
Q23. Which object is create by UIApplicationMain function at app launch time?
A. The app delegate object is created by UIApplicationMain function at app launch time. The app
delegate object's main job is to handle state transitions within the app.
Q24. How is the app delegate is declared by Xcode project templates?
A. App delegate is declared as a subclass of UIResponder by Xcode project templates.
Q25. What happens if IApplication object does not handle an event?
A. In such case the event will be dispatched to your app delegate for processing.
Q26. Which app specific objects store the app's content?
A. Data model objects are app specific objects and store app’s content. Apps can also use document
objects to manage some or all of their data model objects.
Q27. Are document objects required for an application? What does they offer?
A. Document objects are not required but are very useful in grouping data that belongs in a single file or
file package.
Q28. Which object manage the presentation of app's content on the screen?
A. View controller objects takes care of the presentation of app's content on the screen. A view controller
is used to manage a single view along with the collection of subviews. It makes its views visible by
installing them in the app’s window.
Q29. Which is the super class of all view controller objects?
A. UIViewController class. The functionality for loading views, presenting them, rotating them in response
to device rotations, and several other standard system behaviors are provided by UIViewController class.
Q30. What is the purpose of UIWindow object?
A. The presentation of one or more views on a screen is coordinated by UIWindow object.
Q31. How do you change the content of your app in order to change the views displayed in the
corresponding window?
A. To change the content of your app, you use a view controller to change the views displayed in the
corresponding window. Remember, window itself is never replaced.
Q32. Define view object.
A. Views along with controls are used to provide visual representation of the app content. View is an
object that draws content in a designated rectangular area and it responds to events within that area.
Q33. You wish to define your custom view. Which class will be subclassed?
A. Custom views can be defined by subclassing UIView.
Q34. Apart from incorporating views and controls, what else an app can incorporate?
A. Apart from incorporating views and controls, an app can also incorporate Core Animation layers into its
view and control hierarchies.
Q35. What are layer objects and what do they represent?
A. Layer objects are data objects which represent visual content. Layer objects are used by views to
render their content. Custom layer objects can also be added to the interface to implement complex
animations and other types of sophisticated visual effects.
Q Name four important data types found in Objective-C.
Four data types that you’ll definitely want your developer to be aware of are as follows:
NSString: Represents a string.
CGfloat: Represents a floating point value.
NSInteger: Represents an integer.
BOOL: Represents a boolean.
Q How proficient are you in Objective-C and Swift? Can you briefly describe their differences?
When Swift was first launched in 2014, it was aptly described as “Objective-C without the C.” By dropping
the legacy conventions that come with a language built on C, Swift is faster, safer, easier to read, easier
to maintain, and designed specifically for the modern world of consumer-facing apps. One of the most
immediately visible differences is the fact that Objective-C lacks formal support for namespaces, which
forces Objective-C code to use two- or three-letter prefixes to differentiate itself. Instead of simple names
like “String,” “Dictionary,” and “Array,” Objective-C must use oddities like “NSString,” “NSDictionary,” and
“NSArray.”
Another major advantage is that Swift avoids exposing pointers and other “unsafe” accessors when
referring to object instances. That said, Objective-C has been around since 1983, and there is a mountain
of Objective-C code and resources available to the iOS developer. The best iOS developers tend to be
pretty well versed in both, with an understanding that Swift is the future of iOS development.
Q What are UI elements and some common ways you can add them to your app?
Buttons, text fields, images, labels, and any other elements that are visible within the application are
called UI elements. These elements may be interactive and comprise the user interface (hence the term
“UI”) of an application. In iOS development, UI elements can be quickly added through Xcode’s interface
builder, or coded from scratch and laid out using NSLayoutConstraints and Auto Layout. Alternatively,
each element can also be positioned at exact coordinates using the UIView
“(id)initWithFrame:(CGRect)frame” method.
Q What is the purpose of managed object context (NSManagedObjectContext) in Objective-C and how
does it work?
Managed object context exists for three reasons: life-cycle management, notifications, and concurrency. It
allows the developer to fetch an object from a persistent store and make the necessary modifications
before deciding whether to discard or commit these changes back to the persistent store. The managed
object context tracks these changes and allows the developer to undo and redo changes.
Q Determine the value of “x” in the Swift code below. Explain your answer.
var a1 = [1, 2, 3, 4, 5]
var a2 = a1
a2.append(6)
var x = a1.count
In Swift, arrays are implemented as structs, making them value types rather than reference types (i.e.,
classes). When a value type is assigned to a variable as an argument to a function or method, a copy is
created and assigned or passed. As a result, the value of “x” or the count of array “a1” remains equal to 5
while the count of array “a2” is equal to 6, appending the integer “6” onto a copy of the array “a1.” The
arrays appear in the box below.
a1 = [1, 2, 3, 4, 5]
a2 = [1, 2, 3, 4, 5, 6]
Q Find the bug in the Objective-C code below. Explain your answer.
@end
@implementation HelloWorldController
- (void)viewDidLoad {
CGRect frame = CGRectMake(150, 150, 150, 50);
self.alert = [[UILabel alloc] initWithFrame:frame];
self.alert.text = @"Hello...";
[self.view addSubview:self.alert];
dispatch_async(
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0),
^{
sleep(10);
self.alert.text = @"World";
}
);
}
@end
All UI updates must be performed in the main thread. The global dispatch queue does not guarantee that
the alert text will be displayed on the UI. As a best practice, it is necessary to specify any updates to the
UI occur on the main thread, as in the fixed code below:
dispatch_async(
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0),
^{
sleep(10);
dispatch_async(dispatch_get_main_queue(), ^{
self.alert.text = @"World";
});
});
In the above example code, case “A” was explicitly assigned a raw value integer of 1, while cases “B” and
“C” were implicitly assigned raw value integers of 2 and 3, respectively. Associated values allow you to
store values of other types alongside case values, as demonstrated below:
Q You’ve just been alerted that your new app is prone to crashing. What do you do?
This classic interview question is designed to see how well your prospective programmer can solve
problems. What you’re looking for is a general methodology for isolating a bug, and their ability to
troubleshoot issues like sudden crashes or freezing. In general, when something goes wrong within an
app, a standard approach might look something like this:
○ Determine the iOS version and make or model of the device.
○ Gather enough information to reproduce the issue.
○ Acquire device logs, if possible.
○ Once you have an idea as to the nature of the issue, acquire tooling or create a unit test
and begin debugging.
A great answer would include all of the above, with specific examples of debugging tools like Buglife or
ViewMonitor, and a firm grasp of software debugging theory—knowledge on what to do with compile time
errors, run-time errors, and logical errors. The one answer you don’t want to hear is the haphazard
approach—visually scanning through hundreds of lines of code until the error is found. When it comes to
debugging software, a methodical approach is must.
2.What is Object?Ans. As the name implies that object orient programme based around object. The
object associate data with particular operation that that affect or use data.
An object-oriented approach to application development makes programs more intuitive to design, faster
to develop, more amenable to modification, and easier to understand.
Ans. Abstraction is a mechanism of exposing only the interfaces and hiding the implementation details
from the user.
Abstraction is "To represent the essential feature without representing the back ground details".
5.What is Encapsulation?
Ans. Encapsulation is an Object Oriented Programming concept that binds together the data and
functions that manipulate the data, and that keeps both safe from outside interference and misuse. Data
encapsulation led to the important OOP concept of data hiding.
6.What is polymorphism?
Ans. Ability of base class pointer to access the child class methods at run time is called polymorphism.
There is 2 types of polymorphism in OOPS:
● Compile time / Static (Over loading)
● Run Time / Dynamic (Over riding)
7.What is Inheritance?
Category allows you to add methods to an existing class without sub-classing it.For example we can
create category for NSObject that allow to add methods for NSObject class.(e.g. We can add our own
methods to NSString class.)
Unlike sub-classing, categories cant add instance variables.
Extension :
A class extension bears some similarity to a category, but it can only be added to a class for which you
have the source code at compile time (the class is compiled at the same time as the class extension).
Protocol :
Protocols are used to define methods that are to be implemented by other classes.For example we can
implement cellForRowatIndexPath method to ask for cell content to insert in tableview.This method is
defined in UITableViewDataSource protocol.
Declaration:
@protocol MyTestProtocol <NSObject>
@required
-(void)method1;
-(void)method1;
@optional
-(void)method1;
@end
Delegate :
Delegates are used when you want to call the built-in methods of a class.Here one object passes work to
another object.The object doing the work is the delegate of first object
(http://way2ios.com/category/refernece/programming/objective-c/)
(https://github.com/MaximAbramchuck/awesome-interview-questions#ios)
(https://github.com/9magnets/iOS-Developer-and-Designer-Interview-Questions)
iOS Technologies Questions:
● Explain Handoff, and in general, how it allows iOS and Mac/web apps to communicate?
● What technologies/services are contained inside of iCloud?
● What is an iOS extension? Can you list a few examples of popular/common extensions?
● What is HealthKit?
● What is HomeKit?
● What is Apple Pay? Could you describe a way we could use it in our applications?
● Explain application sandboxing.
● What is VoiceOver? Explain some of the accessibility features included in iOS and how
developers can utilize them.
● How does application multitasking work on iOS?
● What features does Game Center offer for iOS games?
● What are iBeacons?
● What is Cocoa/Cocoa Touch?
● Explain in general, what Core Audio, Core Data, and Core Location are, and how they help iOS
apps.
● Describe the role of SpriteKit and SceneKit.
● What is Metal?
● What is the responder chain? How does it work?
● What are the different actions that buttons and other controls can respond to?
● What is the role of the application delegate?
● Explain NSUserDefaults. How would you serialize an array to disk?
● How would you store user's credentials?
● Explain Keychain Services.
● Why are caching and compression important on mobile devices?
● Explain ~/Documents, ~/Library, ~/tmp. What directory is ~ on iOS?
● How does AirPlay work? How would you use it (programmatically) to enhance the utility and
presentation of an app?
● Give a brief overview of what sensors, IO and communication methods (Wifi, telephony, etc) are
available on iOS. How can you make use of these?
● What are the hardware performance differences among the iPad 2 / iPad mini 1-3, iPad Retina,
iPad Air 2, iPhone 5, 5s, 6, and 6+. What do these constraints mean for performance intensive
apps?
[⬆] Coding Questions:
● What does Cocoa Touch include and not include?
● Why do Cocoa Touch classes start with two capital letters?
● What is Swift, what is Objective-C and how do they relate and compare?
● Explain why optionals are useful in Swift.
● Explain NSError and how it works (or doesn't) in Swift.
● How does instancetype work and how is it useful?
● When is let appropriate in Swift? var?
● Why and where is the map function useful.
● How do you track down bugs? What are your tools of choice?
● You found a bug in Cocoa. What do you do?
● There is a regression in a new distributed version of our app causing crashes. How do you
mitigate it? How will you prevent new bugs from reaching customers?
● How are Objective-C classes implemented? Describe how the Objective-C runtime is
implemented.
● What security does iOS offer to protect customers and privileged information?
● Our app downloads data and displays it immediately. In accordance with MVC where is the best
place to perform the download?
● How does MVC influence the design of a codebase?
● What methods are part of the controller life-cycle? The view life-cycle?
● What design patterns does iOS make use of? What design patterns do you use in your codebase?
● What queues does iOS provide and how can you best utilize them?
● Give a brief description of how UIScrollView is implemented. How does it operate with gesture
recognizers, multiple touches and the run loops?
● What API would you add or improve on iOS?
[⬆] Interface Questions:
● What is the screen resolution of the iPhone 5, 6, 6+. and iPad Air 2?
● What units is the resolution measured in?
● Explain the purpose of Interface Builder, what is a NIB file?
● What image filetype should iOS UI assets be saved in?
● Describe some differences between a Storyboard and a standard NIB file.
● What is the device status bar? How tall is it in points? Is it opaque or transparent? What does it do
during a phone call or navigation?
● What is a navigation bar? Can you show me an Apple app on your phone that uses a navigation
bar?
● What is a tab bar? What is a toolbar? Compare and contrast them.
● What is a table view? What is a collection view?
● Describe when a popover is most appropriate.
● What is a split-view controller?
● What sort of content would be appropriate to place in a picker view?
● When are a label, text field and text view appropriate?
● What does a segmented control do?
● What is a modal view?
● What kind of notifications does iOS offer?
[⬆] Design Questions:
● What is an iOS app icon? Describe it as best as you can.
● What is the smallest size an app icon could be? What's the largest size it could be?
● Can an app icon contain any transparency?
● How does a Newsstand icon differ from a regular app icon?
● Explain a launch image.
● Describe the purpose of Auto Layout, and in general, how it works.
● Describe the role of animation in design of software.
● Describe the role of interactivity and feedback when designing software.
● What are some differences to take into account when building an iPhone app vs an iPad app?
● Describe the importance and role of prototyping when working on an app design.
[⬆] App Store Questions:
● How do In-App Purchases work? What can be purchased with IAP?
● Have you ever submitted an app to the App Store? Can you explain the general process?
● What is iTunes Connect?
● What is a provisioning profile?
● What is an App ID?
● What are the differences between Development and Production iOS signing certificates?
● How is TestFlight used? How were UUIDs used in ad-hoc app distribution?
● When do purchase receipts need to be verified?
● What is required to display iAds?
[⬆] Fun Questions:
● What's a cool thing you've coded recently? What's something you've built that you're proud of?
● What are some things you like about the developer tools you use?
● Who are some of your favorite independent Mac or iOS developers?
● Do you have any pet projects? What kind?
● What would you change about Xcode?
● What is your favorite iOS API?
● Do you have a pet or favorite bug report?
● What are your favorite ways to investigate a new technology?
● Why are dictionaries called dictionaries? Why not hash tables or hash maps?
[⬆] Other References:
● iOS Dev Weekly
● Accidental Tech Podcast
● Debug Podcast
● The Talk Show
● NSHipster
● KZBootstrap
● WWDC Videos
● ASCII WWDC
● Pttrns
● Ray Wenderlich Tutorials
● iOS Version Stats
● iOS Human Interface Guidelines
● Black Pixel blog post on hiring iOS and Mac engineers
● Macoscope guide to a technical interview
●