iOS Interview Questions ( Part 2 )

7 min readFeb 17, 2024

Hello! This series of articles will be an important resource for iOS developers. In each installment, we will tackle three questions that are commonly encountered in iOS interviews and are critical for successful performance. Our aim is to guide developers preparing for interviews and provide valuable tips for those aiming for a successful career on the iOS platform.

In this series of articles, we will address three fundamental topics that are commonly encountered and considered important in iOS interviews. First, we will examine the differences between CocoaPods and Swift Package Manager (SPM), which are basic concepts in the Swift programming language. Next, we will focus on Optionals, which are frequently used when creating interfaces with Storyboard. Finally, we will explore the role of Extension, which manages the lifecycle of applications and performs fundamental functions. As we explain each topic, we will support them with examples to ensure better understanding of the concepts. Now, let’s dive into these important topics in detail to enhance the knowledge of iOS Developers!

1-) CocoaPods and Swift Package Manager Differences ?

Cocoapods :

Difference :

CocoaPods is a dependency manager used for managing Objective-C and Swift libraries. It uses a file called Podfile and is commonly used in Objective-C projects.

Advantages :

Extensive Library Support : CocoaPods has a wide repository of libraries, allowing you to easily add popular libraries to your project.
Easy Integration : It has easy installation and usage, quickly connecting to your project.

Disadvantages :

Project Complexity : It can make your project files complex and add unnecessary dependencies.
Speed : Download and installation times can be long for large projects.

Example Podfile for CocoaPods installation :

# Podfile

platform :ios, '10.0'
use_frameworks!

target 'YourApp' do
  pod 'Alamofire', '~> 5.0'
end

Swift Package Manager (SPM) :

Difference :

Swift Package Manager is the official Swift package manager used for managing Swift libraries. It comes built-in with Swift 3 and later versions.

Advantages :

Swift-Focused : It is a formal solution for managing Swift packages and is compatible with Swift projects.
Fast and Efficient : It offers fast download and installation times, especially effective for large projects.

Disadvantages :

Library Limitations : It has more limited library support compared to CocoaPods, making it challenging to find some popular libraries.
Experimental Features : Some developers still consider it experimental, which can lead to stability issues.

Why should we use CocoaPods ?

CocoaPods provides extensive library support and easy integration, particularly useful for Objective-C projects. If you need to add popular and widely used libraries to your project, CocoaPods can be preferred.

Why should we use Swift Package Manager ?

Swift Package Manager is an official solution for Swift projects and is a natural part of the Swift language. Using it for library management, especially in Swift projects, ensures a cleaner and Swift-specific approach. Additionally, it offers advantages such as quick installation and low dependency.

2-) What are Optionals in Swift and Why Are They Important ?

Optionals are a concept used in Swift to represent nil values. Without optionals, a variable’s value must always be present, but in Swift, a variable’s value can be absent (nil value). Optionals are used to express this situation.

Importance :

It enhances the safety of the Swift language by making the handling of nil values defined and secure.
It ensures code clarity and readability by explicitly indicating that a variable can accept a nil value.

Disadvantages :

Additional Complexity : The use of optionals can introduce additional complexity to your codebase. You may need to add extra control structures to check for the existence of optional values and handle them appropriately. This can make the code more complex and harder to read.
Requirement for Correct Usage : It’s important to use optionals correctly. Improper usage of optionals can lead to unexpected errors or application crashes. For example, using forced unwrapping (!) to unwrap an optional value may result in a runtime error or application crash if the value is nil.
Performance Overhead : Optionals can incur a performance cost in some cases. Additional code execution may be required to check for the existence of optional values and unwrap them. This can impact the performance of the application, especially in scenarios involving large data structures or frequently repeated operations.
Code Complexity : Improper management of optionals can lead to code complexity and maintenance challenges. Especially in large and complex projects, handling and managing optionals properly may require time and increase the likelihood of making errors.

Sample Code :

var optionalString: String? = nil

// Attempting to unwrap the optional value
let unwrappedString = optionalString!

print("Optional string value: \(unwrappedString)")

In this code, an optional String value optionalString is assigned as nil. Then, the optional value is attempted to be unwrapped using forced unwrapping (!) operator. Forced unwrapping tries to access the value directly without checking if the optionalString is nil or not.

However, since optionalString is nil in this case, using forced unwrapping will result in an error and the application will crash. This is because we are trying to unwrap a nil value, which is an invalid operation.

Therefore, instead of using forced unwrapping to unwrap optional values, it’s more appropriate to use safer techniques like optional binding or nil coalescing. These techniques check for nil values and handle them safely.

For example:

var optionalString: String? = nil

// Unwrapping the optional value using optional binding
if let unwrappedString = optionalString {
    print("Optional string value: \(unwrappedString)")
} else {
    print("Optional string has a nil value")
}

In this example, we use optional binding to check if the optional value optionalString is nil or not. If the optional value is not nil, its unwrapped value is assigned to a constant variable unwrappedString, and this value is used. If the optional value is nil, the else block is executed and "Optional string has a nil value" is printed. This way, the application continues to run safely without unexpected crashes.

3-) What is an Extension and How to Use It ?

An extension is a feature used in the Swift programming language to extend the functionality of an existing type (struct, class, enum, protocol, or a type). It is used to add new functionality to an existing type without directly modifying it. This makes the code more modular and increases reusability.

Some benefits of extensions include :

Making Code More Modular : By extending an existing type, you can add new features to it and distribute these features to relevant places.
Improving Code Readability : Extensions provide a place where specific functionality of a type is consolidated and kept separate, which improves code readability.
Default Implementations : Extensions can be used to provide default implementations for protocols.
Reduced Complexity : Extensions make the code less complex by grouping specific functionality consistently and also by explicitly expressing relationships between types.

Let’s take a look at how extensions are used with some examples :

This extension adds a property to the UIViewController type. Named “hideKeyboardWhenTappedAround”, this property is used to hide the keyboard when a user taps anywhere inside the UIViewController.

import UIKit

extension UIViewController {
    func hideKeyboardWhenTappedAround() {
        let tap = UITapGestureRecognizer(target: self, action: #selector(UIViewController.dismissKeyboard))
        tap.cancelsTouchesInView = false
        view.addGestureRecognizer(tap)
    }
    
    @objc func dismissKeyboard() {
        view.endEditing(true)
    }
}

Usage :

import UIKit

class MyViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Utilizing the extension to detect taps for hiding the keyboard.
        hideKeyboardWhenTappedAround()
    }
}

This approach allows us to write this extension once, integrating it wherever needed, and thereby avoiding code clutter.

For more examples, see this article.

This article series will be an important resource for iOS developers. In each installment, we will address three questions commonly encountered in iOS interviews and crucial for successful performance. Our aim is to guide developers preparing for interviews and provide valuable tips for those aiming for a successful career on the iOS platform.

At the end of the article, with careful attention to supporting these fundamental topics with examples for better understanding, we will delve into these important areas in detail to enhance the knowledge of iOS Developers.

Additionally, as a continuation of this article series, a new installment will be published every week. So, next week, you will find here an article titled “iOS Interview Questions (Part 3)”. Each new installment will present new questions and tips that iOS developers can benefit from while preparing for interview processes. Stay tuned for fresh content every week!

We hope these articles will be a valuable resource for your iOS development journey and assist you in achieving success in interview processes. Wishing this serves as a guiding resource for beginners as well!

iOS Interview Questions ( Part 2 )

1-) CocoaPods and Swift Package Manager Differences ?

2-) What are Optionals in Swift and Why Are They Important ?

3-) What is an Extension and How to Use It ?

Written by Kerem DEMİR