10 Most Important iOS Concepts every Developer Must Know

Important iOS 10 Swift 3 Development Concepts

"Following are some of the most common interview concepts to brush up for swift3+iOS10 jobs"

 

ARC: Automatic Reference Counting (ARC)
The LLVM 3.0 compiler handles memory management for you
It is not a garbage collector!
Prior to iOS5 – memory management was the single most difficult item to grasp in Objective-C. 
Unless you have specific reasons, all of your projects should use ARC.

MUTABILITY AND FOUNDATION VALUE TYPES 

Provide Swift structs without NS for the following Foundation
types and there mutable counterparts
▸ NSDate, NSURL, NSData, NSNotification
▸ NSIndexPath, NSIndexSet, NSCharacterSet
▸ NSAffineTransform, NSDateComponents,
NSPersonNameComponents, NSURLComponents,
NSURLQueryItem, NSUUID
▸ Obj-C APIs using these types will be automatically bridged to use
the structs in Swift 

let and var in Swift 

let keyword is used to declare a constant and var keyword is used to declare a variable. Variables created with both of them are either references/pointers or values. The difference between them is that when you create a constant with let you have to give it a value upon declaration and you can't reassign it. And when you declare a variable with var it can either be assigned right away or at a later time or not at all (i.e. be nil).

This is a fundamental Swift thing that you should be familiar with. Unlike with Objective-C where everything is dynamic and can be nil and nil in turn can receive messages without breaking everything in Swift you have to be very explicit about what you are declaring.

At the end of the day let, var, nil, and Optionals help define how you handle state in your apps. Swift forces you to be more explicit about it.

memory management in iOS 

it is great if interviewee knows MRC but it is not necessary. More important that he/she understands strong, weak, assign, etc. directives on properties and can confidently tell you what those directives imply and how it’s handled with blocks.

 Read : iOS User Interface 12 IMP MCQ Test

difference between Delegate and KVO   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. 

persist data on iOS

A senior developer should at least be able to tell you when it is appropriate to use NSUserDefaults, Core Data, and disk file storage. ****Core Data is what you’re expecting them to explain you the most. Other possible options are Realm and similar third party (non-Apple) solutions but make sure they know why they would want to use them instead of Core Data. With Core Data they should be able to explain how it works and how it’s different from SQLite (i.e. it’s an object graph rather than a relational database, etc.). 

manage dependencies

CocoaPods and/or Carthage. Red flags: if the say that they don’t use any dependency manager and just copy files to the project folder. Also a red flag if the use git submodules (it leads to project configuration issues and inconsistencies between local setups for different developers on the team).

handle async tasks

answers to this questions may vary from NSOperations and GCD to Promises and RAC. A good developer knows multiple ways to execute async operations and knows when they are necessary (i.e. with networking, local persistence, etc. see above). From a senior developer though we expect a more higher and broader level of tools they use such as ReactiveCocoa and PromiseKit.

 Read : Solved 50+ iOS SWIFT MCQ's

networking in iOS

Interviewee should be able to explain how to do not just basic networking but more advanced things like HTTP headers and token handling. But in general look for developers who use either [AFNetworking](https://github.com/AFNetworking/AFNetworking) or [Alamofire](https://github.com/Alamofire/Alamofire) or similar. The reason is these libraries are used very extensively by iOS community and are utilized in many other tools. Senior developer should be able to utilize that instead of reinventing a wheel.

 Read : Online Practice Test 190 Android App Development MCQs

JSON from the web or local app data to Core Data and other storages 

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_Class/) 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.