What is lazy loading?

Ans :  Lazy Loading Images is a technique to resolve loading image from the web. The thing is that, I need to display images directly from the web in UIImageView or any other control. 

For this, if you simply try to set the image using in-built setImage method then your application gets stuck while loading image from the web. To overcome this issue, there is a technique generally known as Lazy Loading Image. The thing actually happening in lazy loading is that the task of image loading from web is performed in background and at that time a temporary placeholder image is displayed in the control. When the actual image is fully loaded from the web, it is replaced with the placeholder image and you get your actual image on the control without having stuck interface.

You can use third party library to load image :  SDWebImage

Try to make own coding for loading image from URL and Save in cache and display in imageView.

What is apple enterprise account?

Ans : 

To Develop and Distribute app, there are two types of licence available.

1. Apple Developer
2. Apple Developer Enterprise

Difference : 

Source : LeoLearning

Can I store null value in info.plist?

Ans : 

Null or NSNull value type is not supported in info.plist file. Base type of info.plist file is array or dictionary. In array or dictionary, you can save only following type :

1. Array
2. Dictionary
3. Boolean
4. Data
5. Date
6. Number
7. String

No above type supports nil value. They are not optional. So null or nil value can not be stored in info.plist file.

What is .dSYM file?

Ans :

A dSYM file is "debug symbol file". It is generated when "strip debug symbols" setting is enabled in build setting.

When this setting is enabled, symbol names of your objects are removed from the resulting compiled binary  (Benefit of this is protect our code from hackers/crackers to reverse engineering your code, amongst other optimisations for binary size, etc.).

dSYM files will likely change each time your app is compiled.

They are useful for re-symbolicating your crash reports. With a stripped binary, you won't be able to read any crash reports without first re-symbolicating them. Without the dSYM the crash report will just show memory addresses of objects and methods. Xcode uses the dSYM to put the symbols back into the crash report and allow you to read it properly.

 The created archive contains your app and its dSYM and is stored within Xcode's derived data directory. It is good if we keep dSYM file in every where like build fro QA, UAT, Appstore, Distribution.

For debug mode, if "strip debug symbols"  setting is set to "No" then it is okay, but for release, "Yes" is recommended for read crash report.


If you have any comment, question, or recommendation, feel free to post them in the comment section below!  

Json serialization and deserialization

Ans :  

JSON is a format that encodes objects in a string. Serialization means to convert an object into that string, and deserialization is its inverse operation (convert string -> object).

When transmitting data or storing them in a file, the data are required to be byte strings, but complex objects are seldom in this format. Serialization can convert these complex objects into byte strings for such use. After the byte strings are transmitted, the receiver will have to recover the original object from the byte string. This is known as deserialization.

import UIKit

var str = "Hello, playground"

// Starting decode -> json to class or object

// ------------- De-Serialization ----------------

let singleDict = """

{

    "foodName" : "Banana"

    "calories" : 100

}

""".data(using: .utf8)

class Food: Codable {

    

    let foodname : String

    let calories : Int

    

    init(foodname: String, calories: Int) {

        self.foodname = foodname

        self.calories = calories

    }

}

let jsonDecoder = JSONDecoder()

do {

    let foodResult = try jsonDecoder.decode(Food.self, from: singleDict!)

    print(foodResult.foodname)

} catch {

    print("failed to decode \(error.localizedDescription)")

}

// Starting encode -> class or object to json

// ------------- Serialization ----------------

let apple = Food(foodname: "apple", calories: 80)

let jsonEncoder = JSONEncoder()

jsonEncoder.outputFormatting = .prettyPrinted

do {

    let jsonData = try jsonEncoder.encode(apple)

    if let jsonString = String(data: jsonData, encoding: .utf8) {

        print(jsonString)

    }

} catch {

    

}

What is Codable?

Codable is a type alias for the Encodable and Decodable protocols. When you use Codable as a type or a generic constraint, it matches any type that conforms to both protocols.

Before Swift 4, You’d have to serialize the JSON yourself with JSONSerialization, and then typecast every property of the JSON to the right Swift type. We have to do manually map data with struct (Model) properties.

If we are using Codable, then we don't required to map response data with struct property manually. If response's name is different then we can use CodingKey

struct User:Codable 

{

    var firstName: String

    var lastName: String

    var country: String

    enum CodingKeys: String, CodingKey {

        case firstName = "first_name"

        case lastName = "last_name"

        case country

    }

}

If you have any comments, questions, or recommendations, feel free to post them in the comment section below!