UPDATED FOR XCODE 13 & SWIFT 5

@aryamansharda

Ace The iOS Interview

Aryaman Sharda

Published by Aryaman Sharda | Digital Bunker LLC.

Copyright © 2022 Aryaman Sharda

All rights reserved.

No portion of this book may be reproduced in any form without permission from the publisher,
except as permitted by U.S. copyright law.

For permissions contact: [email protected]

https://digitalbunker.dev/
https://twitter.com/aryamansharda

Ace The iOS Interview

1
 @aryamansharda

Legal Disclaimer

This eBook is presented to you for informational purposes only and is not a substitution for
professional advice. The contents herein are based on the views and opinions of the author and
all associated contributors.

While every effort has been made by the author and all associated contributors to present
accurate and up to date information within this document, technology changes rapidly.
Therefore, the author and all associated contributors reserve the right to update the contents
and information provided herein as these changes progress. The author and / or all associated
contributors take no responsibility for any errors or omissions if such discrepancies exist within
this document.

The author and all other contributors accept no responsibility for any consequential actions
taken, whether monetary, legal, or otherwise, by any and all readers of the materials provided.

Readers’ results will vary based on their individual perception of the contents herein, and thus
no guarantees can be made accurately. As such, no guarantees are made.

This eBook and all corresponding materials (such as source code) are provided on an as-is
basis, without warranty of any kind, express or implied, including but not limited to the
warranties of merchantability, fitness for a particular purpose, and noninfringement.

In no event shall the author or copyright holder be liable for any claim, damages or other
liability, whether in action of contract, tort or otherwise, arising from, out of or in connection
with this eBook.

All trademarks and registered trademarks appearing in this eBook are the property of their
own respective owners.

Ace The iOS Interview

2
 @aryamansharda

Table of Contents
Legal Disclaimer 2

Table of Contents 3

About This Book 9

Onsite Interviews & Take-Home Assessments 11

How To Approach This Section 11
Breaking Down The Problem 11
Finding Practice Problems 12
Easy Wins 12
Documentation 13
Version Control 13
Writing A README 14
Conventions & Best Practices 14
Assessment 1: Networking & Basic Codables 16
Managing Endpoints 18
Third Party Dependencies 21
Building The Network Layer 22
Fetching Remote Images 23
Final Implementation 25
Assessment 2: UIKit & User Interaction 26
Add 28
Count 31
Undo 36
Redo 41
Assessment 3: Recreating Mockups & AutoLayout 46
Mockup 47
Building The Vehicle View 49
Building The Price Display 55
Assessment 4: Building A Logger 64
Clarifying Requirements 64
Defining The Scope 65
Handling Different Severity Levels 66
Making Our Logger Context Aware 67

Ace The iOS Interview

3
 @aryamansharda

Creating The Logger 68

Final Implementation 69
Assessment 5: Creating An Analytics Service 72
Basic Implementation 72
Final Implementation 73
Assessment 6: Efficiently Displaying The Fibonacci Sequence 76
Picking An Approach 76
Handling Integer Overflow 76
Making Optimizations 77
Final Implementation 78
Assessment 7: Visualizing Articles & Advanced Codables 83
Creating The Models 88
Parsing The JSON 89
Building The View Controller 90
Creating Custom Cells 91
Final Implementation 93

How To Approach The Data Structures & Algorithms Interview 97

iOS & Swift Interview Q & A 100

General Knowledge 101
What does app thinning mean? 101
What is the difference between the stack and the heap? 102
Is an enum a value type or a reference type? 103
What is the difference between an escaping closure and a non-escaping closure? 104
What are trailing closures? 106
What is code coverage? How do you enable it in Xcode? 108
What common problem does the Main Thread Checker help detect? 110
What are Swift’s different assertion options? 111
What are the differences between the static and class keywords? 114
What is the difference between the App ID and the Bundle ID? 115
What features of Swift do you like or dislike? 117
What are the different URLSessionConfiguration options? 118
What is the difference between static and dynamic dispatch? 119
What is the difference between the UIApplicationDelegate and SceneDelegate? 120
What is the difference between a dynamic library and a static library? 121
What are generics and what problem do they solve? 123
Ace The iOS Interview
4
 @aryamansharda

What is a .dSYM file? 125

What are the differences between a class and a struct? 127
What are the different execution states your application can be in? 129
How can we handle changes in our application’s lifecycle state? 130
How would you debug view layout issues? 132
What is operator overloading? 136
What are the differences between a delegate and a notification? 138
What are the differences between a library and a framework? 139
How do you create interoperability between Objective-C and Swift? 140
What does the File’s Owner do? 142
Are closures value or reference types? 143
What are the differences between Keychain and UserDefaults? 145
What are our options for storage and persistence? 146
When would you use a struct versus a class? 147
What do the Comparable, Equatable, and Hashable protocols do? 148
What methods are required to display data in a UITableView? 151
What does the CodingKey protocol allow you to do? 152
What is the difference between the designated and convenience initializer? 154
What is your preferred way of creating views? 155
What would happen if a struct had a reference type in it? 157
What are the stages in a UIViewController’s view lifecycle? 158
How does code signing work? 160
Swift Language Features 163
What is the difference between == and ===? 163
What's the difference between Self vs self? 165
How would you limit a function or a class to a specific iOS version? 166
What does the final keyword do? 167
What does the nil coalescing operator do? 168
What does defer do? 169
What is optional chaining? 170
Can we use Swift’s reserved keywords as variable or constant names? 171
What is the difference between try, try!, and try? ? 172
What is an inout parameter? 174
How can we limit a protocol conformance to a specific class or type? 175
Does Swift support implicit casting between data types? 177

Ace The iOS Interview

5
 @aryamansharda

What does the CaseIterable protocol do? 178

Can you explain what the @objc keyword does? 179
What are compilation conditions? 180
What are the differences between Swift’s access control modifiers? 181
What does the typealias keyword do? 182
What does copy on write mean? 184
How are Optionals implemented? 185
What are the higher order functions in Swift? 186
What is the difference between Any and AnyObject? 190
What is a raw value in an enum? 191
What are our options for unwrapping optionals in Swift? 193
What is an anonymous function? 194
What is the difference between is, as, as?, and as! ? 195
What are some of the main advantages of Swift over Objective-C? 198
How do we provide default implementations for protocol methods? 200
What does it mean to be a first class function or type? 202
Do all elements in a tuple need to be the same type? 204
What is protocol composition? How does it relate to Codable? 205
What does the mutating keyword do? 206
How do you use the Result type? 208
Is Swift a statically-typed language? 210
What is an associated value? 211
What does a deinitializer do? 212
How can you create a method with default values for its parameters? 213
What is type inference? 215
What does the rethrows keyword do? 216
What does the lazy keyword do? 218
What does typealiasing do? 219
What does the associatedtype keyword do? 221
While iterating through an array, how can we get both the value and the index? 223
Your app is crashing in production. What do you do? 224
AutoLayout & UIKit 226
What is a view’s intrinsic content size? 226
How would you animate a view that has a constraint? 227
On what thread should all UI updates be made? 228

Ace The iOS Interview

6
 @aryamansharda

What is the difference between bounds and frame? 229

What is the Responder Chain? 231
What does an unwind segue do? 232
What is the difference between pushing and presenting a new view? 235
What is the difference between a point and a pixel? 236
How are Content Hugging and Content Compression Resistance different? 237
What does App Transport Security do? 238
What are layer objects? 239
What is the purpose of the reuseIdentifier? 240
What is the difference between layoutIfNeeded() and setNeedsLayout()? 241
What does layoutSubviews() do? 242
What does viewDidLayoutSubviews() do? 243
What does setNeedsDisplay() do? 244
What is a placeholder constraint? 246
What is Dynamic Type in iOS? 247
What are the differences between a .xib and a .storyboard file? 248
What is the difference between layout margins and directional layout margins? 249
Concurrency 253
What are the differences between DispatchQueue, Operation, and Threads? 254
What is the difference between a serial and a concurrent queue? 256
What is a race condition? 258
How can we prevent race conditions [the reader-writer problem]? 260
What does deadlock mean? 262
How can we group multiple asynchronous tasks together? 263
How can you cancel a running asynchronous task? 265
Can you explain the different quality of service options GCD provides? 267
What does it mean for something to be thread safe? 269
Memory Management 270
What is automatic reference counting? 270
What is the difference between strong, weak, and unowned? 272
What is a memory leak? 273
How would you avoid retain cycles in a closure? 274
Testing 275
What is a unit test? 276
What does Arrange, Act, and Assert mean with respect to unit tests? 277

Ace The iOS Interview

7
 @aryamansharda

What are UI tests? 278

What is Snapshot Testing? 279
What is Test Driven Development? 280
What is Behavior Driven Development? 281
What are the purposes of setUp() and tearDown() in the XCTest framework? 283
How would we test the performance of a method in our tests? 284
More Questions? 284

Acing the Behavioral Interview 286

S.T.A.R. Format 286
You’re Not Out Of The Woods Yet 288
An Interviewer’s Perspective 288
Before The Interview 289
Focus On The Silver Lining 291
Be Specific 291
Example Behavioral Interview Questions 292
General 292
Teamwork 293
Integrity & Ethics 294
Initiative & Innovation 295
Leadership 295
Career & Personal Growth 296
Decision Making 296
Communication 297
Adaptability 298
Time Management & Prioritization 300
Engineering + Behavioral Questions 301
General Technical Questions 302
Platform Interview Questions 302
Questions For The Technical Interviewer 303
When It’s Your Turn To Ask Questions 304
Questions For The Hiring Manager 306

Afterword 307

Sources 308

Ace The iOS Interview

8
 @aryamansharda

About This Book

Hey there! My name is Aryaman Sharda and I started making iOS apps way back in 2015.
Since then, I’ve worked for a variety of companies like Porsche, Turo, and Scoop Technologies
just to name a few. Over the years, I’ve mentored junior engineers, built developer tools, and
shipped dozens of apps to the App Store.

As I was interviewing for these roles, I was always looking for easy-to-follow explanations of
all the relevant iOS interview topics and iOS-specific practice problems. After years of not
being able to find such a guide, I decided to write one myself.

Over the last five years, I’ve been consolidating every relevant question, concept, and
take-home assessment I've encountered during my interviews. They are all included in the
following pages, along with sample solutions, screenshots, and step-by-step instructions. This
book contains everything you need to know for your next iOS interview. “Ace The iOS
Interview” will help you take the guesswork out of your interview preparation and will
hopefully serve as a practical guide for landing your dream job.

With hundreds of interviews under my belt, both as a candidate and as an interviewer, I know
both what an interviewer is looking for as well as the common mistakes most candidates tend
to make. We'll go over in detail about how to tailor your responses to highlight the specific
criteria the interviewer is looking for, as well as strategies for the behavioral interview portion
and other “do's and don'ts” along the way.

For those of you looking for your first iOS job, I know first-hand how difficult it can be. Learning
iOS development has been one of the most impactful and rewarding experiences I've had. It’s
enabled a lucrative career and the opportunity to work on apps that impact millions of people.
All of that upside is on the other side of making it through the interview and hopefully this
book will help you do just that.

My sincerest hope is that you find this book helpful and that it helps you land your next iOS
position. If it does, I’d love to hear about it. Thanks for reading and good luck!

I’ve also created a free to join Slack workspace for anyone to discuss topics related to iOS
interviewing, mock interview requests, sharing interview questions, job opportunities, and
much more.

Ace The iOS Interview

9
 @aryamansharda

If you want to submit a question for inclusion in this book and to help other iOS developers, feel free to
contact me or share it in our Slack workspace.

Ace The iOS Interview

10
 @aryamansharda

Onsite Interviews & Take-Home Assessments

In this section, we’ll take a look at some of the onsite and take-home interview assessments
I’ve encountered over the last few years. We’ll cover how to break down the problem, clarify
requirements, and how to work with the interviewer to solve the problem.

While all of these questions contain a sample solution, my approach may not be convincing to
you and that’s absolutely fine. The sample solution is primarily meant to offer you a starting
point.

Feel free to modify it to match whatever conventions, design patterns, or problem-solving

approach you prefer.

If you come up with an improved implementation or have any suggestions for the answers to
these problems, I’d love to see it. Feel free to share them with me on Twitter or by contacting
me at [email protected].

How To Approach This Section

Over the following pages, I have reproduced the interview questions and take-home
assessments I encountered exactly as they were presented in the interview process.

All questions are supported by screenshots and sample implementations.

I recommend spending some time thinking about how you would answer the questions, what
you would ask the interviewer, and what requirements you would clarify before you peek at
the sample solution.

Breaking Down The Problem

Many onsite interviews are designed to mimic a situation where you and the interviewer are
working together on a project and may need to decide on specifics as you go along. Be
prepared to encounter a lot of deliberately vague questions.

Interviews of this type aim to assess your ability to think deeply about a new problem, what
concerns or bottlenecks you can identify, your ability to ask clarifying questions, and the level
of planning you do before you start writing code. The biggest mistake you can make here is to
jump right into writing code without doing any type of due diligence or planning.

Ace The iOS Interview

11
 @aryamansharda

From the interviewer’s perspective, they’re looking to see:

● What did you do when you didn’t have all of the information?
● Does your code have the flexibility to adapt to changing requirements?
● Did you spend enough time thinking about the problem before writing code?
● Did you consider how you’d handle errors?

At the end of the day, the interviewer is looking for a new teammate so demonstrating your
ability to collaborate professionally with others is equally, if not more, important than solving
the problem itself.

Don't be afraid to ask questions, explain your thought process out loud, and remember to be
personable - it sounds obvious, but sometimes we forget when our nerves get the best of us.

Finding Practice Problems

While interviewing, I found that one of the best places to find practice iOS interview problems
was GitHub.

I would periodically search for variations of "swift take home assessment" or "iOS exercise" and
would find public take-home assessments submitted by other iOS developers.

You’ll have to do some digging, but you’ll eventually find projects that are both novel and
updated recently. With this approach, you’ll have an inexhaustible supply of practice questions
at your disposal.

Once you begin doing this consistently, you'll start noticing patterns in the questions, and that
can give you a sense of what variations of a given problem are most popular.

If you would like to submit a problem for inclusion in this book, please feel free to contact me!

Easy Wins

As an interviewer, it's always refreshing to review a take-home project that's well documented,
follows typical Swift conventions, contains a README, and leverages version control.

Most candidates don't add this final touch to their submissions, but it can really make a
difference for very little additional effort.

Ace The iOS Interview

12
 @aryamansharda

Documentation

When writing comments, explaining why the code is written a certain way is arguably more
important than explaining what it does. Programmers can generally understand what a given
piece of code does, but they might find it harder to reason about the context in which it was
written and the potential side effects of its execution.

Here are some examples of good comments as they focus on communicating why the code
was written a certain way instead of what it does:

// TODO: When iOS 12 and lower support is dropped replace this

// method with withTintColor(color, renderingMode:)

// Declaring as private to avoid accidentally being instantiated from

// another instance.

// We're disabling the "Next" button as this is an invalid state and the
// user has no available options.

In contrast, these would be considered poor comments as they don't provide any additional
information or insight the code doesn't already convey:

// Hide error label

// - Parameter urlString: String representation of the URL to load the

// image from

// Presents the next view in the user flow

In addition, comments should:

● Be used to provide a brief summary for a longer piece of code.

● Be used to address questions or concerns the code is incapable of answering on its
own.
● Clearly communicate any possible side effects that execution of the code may cause.
● Be tailored to other developers who may not have the same familiarity and history with
the code as you do.

Version Control

Every project, take-home assessment or otherwise, should use version control.

Ace The iOS Interview

13
 @aryamansharda

Familiarity with version control (e.g. branching, resolving conflicts, etc.) is an essential skill for
your job. So, demonstrating your ability to use it correctly [with good conventions] will only
help reinforce the narrative that you'll be able to hit the ground running.

Writing A README

Your take-home assessment submission should contain a README.

At the very least, the README should provide a summary of the project, list any third-party
dependencies you’re using, and provide instructions about how to set up and run the
application (if applicable). For example, this is where you'd tell the interviewer that they will
have to run pod install before running the project.

You can also use the README to highlight known bugs, missing features, or any other pertinent
information the interviewer should know.

It’s also a good opportunity to address the following questions:

1. What are the major components of your implementation?

2. What notable technical decisions did you have to make?
3. Did you have to make any compromises to limit the scope?
4. What improvements would you make if there was more time?
5. Are there any remaining TODOs?
6. Did you implement error handling? Why or why not?
7. Why did you choose to organize your code this way? What other design and
architecture patterns did you consider?
8. What third-party dependencies are you using (if any)?

Conventions & Best Practices

Often, I’ll see candidates using a mix of different coding styles and language conventions in
their projects. I can’t count the number of times I’ve seen Swift code written with Objective-C
stylings or JavaScript conventions brought over to Swift.

This lack of standardization will make your code difficult to read and may make your
interviewer doubt your familiarity with the language and its conventions.

Ace The iOS Interview

14
 @aryamansharda

For the interview, I recommend you follow generally accepted Swift best practices and
conventions regardless of your personal preferences. It’s a small low-effort change, but it
becomes one less thing the interviewer can dock you for.

If you’re looking for a good place to get started, I’d check out this well-accepted Swift style
guide: https://github.com/raywenderlich/swift-style-guide

Apologies for any unusual formatting in the following code samples. It was done in an attempt
to make this book more readable.

Ace The iOS Interview

15
 @aryamansharda

Assessment 1: Networking & Basic Codables

You can find the final implementation here.

Problem Duration: On average, 60-90 minutes.

Over years of interviewing, as a candidate and as an interviewer, this is the most common
question I’ve encountered. If there’s anything you take away from this book, I hope it’s this
question.

The question takes a few different forms, but generally involves consuming some JSON
response (either mocked local data or retrieved as a result of an HTTP request) and presenting
the fetched data in a UITableView or UICollectionView.

I’ve seen the duration of this question range anywhere from a one hour on-site interview to a
few days when it’s part of a more involved take-home assessment.

When it’s assigned as part of a take-home assessment, it will often include additional UI
requirements like presenting a detail view, loading images, or even creating custom UI
components, but regardless of the specifics, this problem is everywhere.

It’s a great question as it touches on all the foundational concepts a iOS developer should
know:

Network Layer
- Foundation
- Asynchronous Tasks
- Error Handling
- Generics
- Codables
- URL Session

Caching & UI
- Foundation
- UIKit
- AutoLayout
- Creating Custom Cells

Ace The iOS Interview

16
 @aryamansharda

- Concurrency

Everything Else
- Architecture Patterns
- Design Patterns
- Delegates & Data Sources
- Coding Conventions
- Reusable Code
- Documentation
- Version Control

On GitHub, you’ll find hundreds of variations of this interview problem. I’ve shortlisted a few
variations in case you're curious, but at their core, they all revolve around making some API
calls and presenting the results in a UITableView.

It's not my intention to comment on the code quality or architecture design of these solutions,
I'm just sharing a few examples.

- https://github.com/ekeren/ios-interview
- https://github.com/raywenderlich/ios-interview/tree/master/Practical
- https://github.com/shayan18/Runtastic-Test-iOS
- https://github.com/mediassumani/TakeHome-iOS-challenge
- https://github.com/changjeffrey829/IOSGeniusPlaza
- https://github.com/brandaorafael/iOS-Faire-Take-Home-Assignment
- https://github.com/fila/Egeniq-assignment
- https://github.com/giblerw/HA-TakeHome
- https://github.com/ygapps/Movies/tree/master/Movies/Networking
- https://github.com/valizairov/AppStoreLightweight
- https://github.com/armaluca/clearScore
- https://github.com/ka-ching-as/take-home-assignment-junior-ios

In my experience, there have been certain variations of this question that allowed the use of
third-party libraries, but it was strongly discouraged. A library, like Alamofire, would be overkill
for an assignment like this.

Let’s get back to the implementation.

Ace The iOS Interview

17
 @aryamansharda

Managing Endpoints
In order to build our networking layer, we’ll need to come up with an elegant way of
representing our application’s various endpoints.

Let's start by identifying a few things that all API calls will have in common:

- HTTP Method (GET, POST, PUT, etc.)

- HTTP Scheme (HTTP & HTTPS)
- Base URL
- Path
- Query Parameters

We can model the HTTP method and the HTTP scheme with the following enums:

enum HTTPMethod: String {

case delete = "DELETE"
case get = "GET"
case patch = "PATCH"
case post = "POST"
case put = "PUT"
}

enum HTTPScheme: String {

case http
case https
}

Next, in order to represent a generic endpoint, we can create an API protocol which any
endpoint we wish to support must conform to:

Ace The iOS Interview

18
 @aryamansharda

/// The API protocol allows us to separate the task of constructing a URL,
/// its parameters, and HTTP method from the act of executing the URL request
/// and parsing the response.
protocol API {
/// .http or .https
var scheme: HTTPScheme { get }

// Example: "maps.googleapis.com"
var baseURL: String { get }

// "/maps/api/place/nearbysearch/"
var path: String { get }

// [URLQueryItem(name: "api_key", value: API_KEY)]

var parameters: [URLQueryItem] { get }

// "GET"
var method: HTTPMethod { get }
}

For example, if we wanted to add support for the Google Places API, we could do so like this:

enum GooglePlacesAPI: API {

case getNearbyPlaces(searchText: String?, latitude: Double,
longitude: Double)

var scheme: HTTPScheme {

switch self {
case .getNearbyPlaces:
return .https
}
}

var baseURL: String {

switch self {
case .getNearbyPlaces:
return "maps.googleapis.com"
}
}

var path: String {

switch self {
case .getNearbyPlaces:
return "/maps/api/place/nearbysearch/json"
Ace The iOS Interview
19
 @aryamansharda

}
}

var parameters: [URLQueryItem] {

switch self {
case .getNearbyPlaces(let query, let latitude, let longitude):
var params = [
URLQueryItem(name: "key", value: GooglePlacesAPI.key),
URLQueryItem(name: "language",
value: Locale.current.languageCode),
URLQueryItem(name: "type", value: "restaurant"),
URLQueryItem(name: "radius", value: "6500"),
URLQueryItem(name: "location",
value: "\(latitude),\(longitude)")
]

if let query = query {

params.append(URLQueryItem(name: "keyword", value: query))
}
return params
}
}

var method: HTTPMethod {

switch self {
case .getNearbyPlaces:
return .get
}
}
}

With this approach, not only can you represent any generic API, you can easily add support for
any new API your project needs to integrate with by simply creating a new enum. For example,
in a larger application, you could have separate enums to handle your authentication, booking,
and checkout endpoints respectively.

This approach helps ensure the API’s path, the scheme, and the required parameters are all
readable, well-documented, and consolidated in one place.

As the networking demands of our application grows, the last thing we want to do is litter our
codebase with multiple calls to URLSession. Instead, we should try and create some kind of

Ace The iOS Interview

20
 @aryamansharda

consolidated network service that can manage both making the request and parsing the
response. As part of that implementation, we’ll want our solution to be as reusable as
possible, so generics would be a great language feature to leverage here.

We’ll build out the networking service momentarily.

Third Party Dependencies

Even though it's tempting to use frameworks like Alamofire and Kingfisher in your take-home
assessment, I'd caution you against using them. Considering the limited scope of these
assessments, we will never be able to fully utilize these tools. By using them for such a simple
application, it gives off the impression that you are uncomfortable with URLSession which
would clearly work against you in the interview. Moreover, we don't want to give the
interviewer the impression that our approach for solving difficult technical problems is to
introduce additional dependencies.

There’s always a time and a place to add new dependencies to a project, but every additional
dependency increases the codebase's maintenance costs and risks its stability.

In my experience, there have been several times when a new version of Xcode or iOS breaks
one of our dependencies and we are left waiting for the developer to provide a fix before we
can continue releasing our application. Not to mention, this assumes that the third-party
dependency is still actively maintained!

Many times, we rely on large libraries only to utilize a small portion of their capabilities. In
certain situations, it may be easier to re-create the limited functionality you need rather than
introducing yet another dependency.

While bringing in a new dependency might solve your current problem, it will increase your
executable size, maintenance costs, potentially block future releases, be difficult to
de-integrate, and will likely be a black box of functionality. Finally, if the dependency were to
no-longer be maintained, then your only options would be to replace it with an alternative (if it
exists), become the maintainers yourself, or re-create the necessary behavior from scratch -
clearly, none of those options are ideal.

All that being said, if you choose to use a third-party dependency in your take-home project,
you should be prepared to defend that decision.

Ace The iOS Interview

21
 @aryamansharda

Building The Network Layer

This network layer implementation can be easily extended to support advanced networking
capabilities without having to rely on external libraries.

With this approach, our NetworkManager is blind to the specifics of the API being used and the
contents of the response.

That is exactly the behavior we want - our NetworkManager simply acts as a middleman. It’s
sole focus is on orchestrating the HTTP request, handling errors (if any), and passing along the
response to the call site.

import Foundation

final class NetworkManager {

/// Builds the relevant URL components from the values specified
/// in the API.
private class func buildURL(endpoint: API) -> URLComponents {
var components = URLComponents()
components.scheme = endpoint.scheme.rawValue
components.host = endpoint.baseURL
components.path = endpoint.path
components.queryItems = endpoint.parameters
return components
}

/// Executes the HTTP request and will attempt to decode the JSON
/// response into a Codable object.
/// - Parameters:
/// - endpoint: the endpoint to make the HTTP request to
/// - completion: the JSON response converted to the provided Codable
/// object when successful or a failure otherwise
class func request<T: Decodable>(endpoint: API,
completion: @escaping (Result<T, Error>)
-> Void) {
let components = buildURL(endpoint: endpoint)
guard let url = components.url else {
Log.error("URL creation error")
return
}

var urlRequest = URLRequest(url: url)

Ace The iOS Interview

22
 @aryamansharda

urlRequest.httpMethod = endpoint.method.rawValue

let session = URLSession(configuration: .default)

let dataTask = session.dataTask(with: urlRequest) {
data, response, error in
if let error = error {
completion(.failure(error))
Log.error("Unknown error", error)
return
}

guard response != nil, let data = data else {

return
}

if let responseObject = try? JSONDecoder().decode(T.self,

from: data) {
completion(.success(responseObject))
} else {
let error = NSError(domain: "com.AryamanSharda",
code: 200,
userInfo: [
NSLocalizedDescriptionKey: "Failed"
])
completion(.failure(error))
}
}

dataTask.resume()
}
}

Fetching Remote Images

To reduce the number of HTTP requests we make, we only want to fetch images for cells that
are currently visible and for images we do not already have cached. In the absence of caching,
we would have to create a new HTTP request every time a cell was shown, which would result
in a lot of repeated requests and would degrade the user experience significantly.
The following extension on UIImageView allows us to both fetch and cache images across
our application:

let imageCache = NSCache<NSString, UIImage>()

Ace The iOS Interview

23
 @aryamansharda

extension UIImageView {
/// Loads an image from a URL and saves it into an image cache, returns
/// the image if already available in the cache.
/// - Parameter urlString: String representation of the URL to load the
/// image from
/// - Parameter placeholder: An optional placeholder to show while the
/// image is being fetched
/// - Returns: A reference to the data task in order to pause, cancel,
/// resume, etc.
@discardableResult
func loadImageFromURL(urlString: String,
placeholder: UIImage? = nil) ->
URLSessionDataTask? {
self.image = nil

let key = NSString(string: urlString)

if let cachedImage = imageCache.object(forKey: key) {
self.image = cachedImage
return nil
}

guard let url = URL(string: urlString) else {

return nil
}

if let placeholder = placeholder {

self.image = placeholder
}

let task = URLSession.shared.dataTask(with: url) { data, _, _ in

DispatchQueue.main.async {
if let data = data,
let downloadedImage = UIImage(data: data) {
imageCache.setObject(downloadedImage,
forKey:
NSString(string: urlString))
self.image = downloadedImage
}
}
}

task.resume()

Ace The iOS Interview

24
 @aryamansharda

return task
}
}

Final Implementation
Finally, we’ll combine all of these calls together.

In our UITableViewController:

let endpoint = GooglePlacesAPI.getNearbyPlaces(searchText: query,

latitude: latitude,
longitude: longitude)

NetworkManager.request(endpoint: endpoint) { [weak self]

(result: Result<NearbyPlacesResponse, Error>) in

switch result {
case .success(let response):
self?.dataSource = response.results
self?.tableView.reloadData()
case .failure(let error):
Log.error(error)
}
}

And finally, in our custom UITableViewCell, we can leverage the extension we made on
UIImageView earlier:

thumbnailImageView.loadImageFromURL(urlString: photoURL)

We've now created an extensible and reusable network layer, a clean way to represent APIs,
and an extension for UIImageView that lets us fetch and maintain a cache of images without
any third-party dependencies.

This implementation will be easy to reuse in any future take-home assessment.

You can find the final implementation here.

Ace The iOS Interview

25
 @aryamansharda

Afterword
Congrats on making it to the end!

I hope by now you're feeling more confident about your upcoming iOS interview - I know you're
going to ace it. Writing this book has been one of the most difficult projects I've undertaken,
but it has without a doubt made me a better engineer. In my opinion, teaching others is one of
the best ways to improve as a developer. It forces you to delve deeper into topics than you
would otherwise, which is excellent for filling in any knowledge gaps you may have.

Whether you land your dream job or learnt something new along the way, please consider
leaving a review! I need a sign that I didn’t waste 6 months writing this

Also, if you come across something interesting or educational that would be useful to other
iOS developers, please send it my way. I love to share quality educational content on my social
media. Finally, if there’s anything I’ve missed or if you would like to propose a topic or question
for inclusion in this book, let me know that as well. You can email me at
[email protected] or message me on Twitter.

I will continue to update this book with new content, without charge, in the coming months.

It's time for a shameless plug, if you’ll indulge me::

- Want to work with me at Turo? Apply here [Top Workplaces USA 2022):
https://grnh.se/22f48f191us
- If you’re interested in more of my content, check out my Twitter, YouTube, or my
personal website.
- To hire me for freelancing work, email me at [email protected] or direct
message me on Twitter.
- If you’re in need of a deep link testing tool, check out my most recent developer tool
DeepLinkr.

I’ve got a few more books to come

I’ve also created a free to join Slack workspace for anyone to discuss topics related to iOS
interviewing, mock interview requests, sharing interview questions, job opportunities, and
much more.

Ace The iOS Interview

308