Swift

Question 1

what is a strong reference

Answer 1

• default behavior
• incremements ARC
• allows it to be captured by ARC, keeping it in memory as long as there is a reference to it

Question 2

what is a weak reference

Answer 2

• not taken into account by ARC
• they do not keep a reference to the instance they are referencing
• can be set to nil, so always an optional
• must be unwrapped to use
• important to use when there may be retain cycles

Question 3

what is an unowned reference

Answer 3

• not taken into account by ARC
• they do not keep a reference to the instance they are referencing
• always expected to have a value
• can directly access the value

Question 4

compare weak vs unowned

Answer 4

• use weak when it’s valid for the reference to be nil at some point
• use unowned when you know the reference will never be nil once set during initialization

Question 5

what is a lazy reference

Answer 5

• only created when they are first needed
• must always be a var
• the initial value is not calculated the first time it is used
• can’t be used with computed properties
• are not initialised atomically and so is not thread safe.

Question 6

what is an optional

Answer 6

• a property that can be nil, ie, can handle the absence of a value
• in Swift, an enum that has two cases: .none and .some

Question 7

what is a retain cycle

Answer 7

• a retain cycle occurs when two or more objects hold strong references to each other.
• as a result these objects retain each other in memory because their retain count would never decrement to 0, which would prevent deinit from ever being called and memory from being freed

Question 8

what are generics

Answer 8

• create code that does not get specific about underlying data types
• allow us to know what type it is going to contain
• provides optimization for our code

Question 9

what are protocols

Answer 9

• a blueprint of methods, properties, and other requirements that suit a particular task or piece of functionality.
• it can then be adopted by a class, structure, or enumeration to provide an actual implementation of those requirements.
• can be extended to implement some of these requirements, or to implement additional functionality

Question 10

what are protocol extensions

Answer 10

• provide method, initializer, subscript, and computed property implementations to conforming types.
• This allows you to define behavior on protocols themselves, rather than in each type’s individual conformance or in a global function

Question 11

what are DispatchGroups

Answer 11

• 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.

Question 12

what is a closure

Answer 12

• self-contained blocks of functionality that can be passed around and used in your code
• can capture and store references to any constants and variables from the context in which they are defined

Question 13

what is concurrency and multithreading

Answer 13

• Process, An instance of an executing app
• Thread, Path of execution for code
• Multithreading, Multiple threads or multiple paths of execution running at the same time.
• Concurrency, Execute multiple tasks at the same time in a scalable manner.
• Queues, Queues are lightweight data structures that manage objects in the order of First-in, First-out (FIFO).
• Synchronous vs Asynchronous tasks

Question 14

what is a race condition

Answer 14

• occurs when two or more threads can access shared data and they try to change it at the same time

Question 15

what is a deadlock

Answer 15

• when two or sometimes more tasks wait for the other to finish, and neither ever does

Question 16

explain swizzling

Answer 16

• Method Swizzling is a well-known practice in Objective-C and in other languages that support dynamic method dispatching.
• Through swizzling, the implementation of a method can be replaced with a different one at runtime, by changing the mapping between a specific #selector(method) and the function that contains its implementation.
• The class containing the methods to be swizzled must extend NSObject
• The methods you want to swizzle must have the dynamic attribute

Question 17

escaping vs non-escaping closures

Answer 17

• allows the the closure to outlive the function

- allows you to store the result in a global property, for example

Question 18

explain dependency injection and it’s different types

Answer 18

• giving an object its instance variables
• useful in testing to insert mock data
• constructor/initializer injection: a dependency injected upon object initialization
• property injection: injecting a dependency into a property (eg, view.title = “Title”)
• method injection: injecting a dependency in the parameters of a method

Question 19

what are functional methods

Answer 19

filter, map, compactMap, reduce

Question 20

filter vs map

Answer 20

• Map, we pass in a function that returns a value for each element in an array. The return value of this function represents what an element becomes in our new array.
• Filter, we pass in a function that returns either true or false for each element. If the function that we pass returns true for a given element, then the element is included in the final array.

Question 21

compare frame vs bounds

Answer 21

• The bounds of a 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 a UIView is the rectangle, expressed as a location (x,y) and size (width, height) relative to the superview it is contained within.

Question 22

what are the advantages of Swift

Answer 22

• Optional Types, which make applications crash-resistant
• Built-in error handling
• Closures
• Much faster compared to other languages
• Type-safe language
• Supports pattern matching

Question 23

what are escaping vs non-escaping closures

Answer 23

• non-escaping is the default behavior
• non-escaping dereferences the properties when it completes
• escaping allows the the closure to outlive the function
• escaping allows you to store the result in a global property, for example
• escaping requires a weak reference to self ([weak self] in, and guard let self = self to avoid using optional chaining)

Question 24

what is a memory leak

Answer 24

• when an amount of allocated space in memory cannot be deallocated due to retain cycles

Question 25

what is ARC

Answer 25

• Apple’s way of handling memory management
• It keeps track of class instances and it decides when it is safe to deallocate the class instances it monitors. It does this by counting the references of each class instance.
• ensures a class instance isn’t deallocated as long as a property, constant, or variable keeps a strong reference to the class instance.

Question 26

what is nil coalescing

Answer 26

let name: String? = nil
let unwrappedName = name ?? "Anonymous"

Question 27

what is a ternary operator

Answer 27

let score = 88
let result = score > 85 ? "Pass" : "Fail"

Question 28

explain dependency injection and it’s different types

Answer 28

• giving an object its instance variables
• allows you to pass mock dependencies for testing
• initializer injection: passing dependencies when initializing an object
• property injection: pass a dependency to a property on an object (eg, vc.manager = Manager())
• method injection: requires the dependency in the method parameters

Question 29

explain filter

Answer 29

• use filter to loop over a collection and return an Array containing only those elements that match an include condition.

Question 30

explain map, flatMap, and compactMap

Answer 30

• use map to loop over a collection and apply the same operation to each element in the collection
• use compactMap to unwrap optionals and remove nils
• use flatMap to flatten, or merge, multiple sequences into a single sequence (eg, 3 arrays into 1 array)

Question 31

explain reduce

Answer 31

• use reduce to combine all items in a collection to create a single new value
• it takes two values: an initial value, and the combine closure or operator

Question 32

explain value vs reference types

Answer 32

• in Swift, value types are structs, and reference types are classes
• value types pass a copy of a property
• reference types pass a reference to an instance in memory
• structs have memberwise initializers
• classes can use inheritance

Question 33

what are extensions

Answer 33

• can be used to extend an existing type, even if you don’t have access to the original type - such as Date, or String
• cannot hold a property

Question 34

compare guard let and if let

Answer 34

• guard let is designed to exit the current function, loop, or condition if the check fails, so any values you unwrap using it will stay around after the check
• guard let is when you’re fairly certain you’ll be on the happy path
• if let to unwrap optional if you’re not sure if the value(s) will exist
• if let does not require a return statement

Question 35

compare sync and async operations

Answer 35

• Synchronous: waits until the task have completed

- Asynchronous: completes a task in the background and can notify you when complete

Question 36

explain defer

Answer 36

• provides a block of code that will be executed in the case when execution is leaving the current scop

Question 37

explain GCD

Answer 37

• Dispatch Queues, A dispatch queue is responsible for executing a task in the first-in, first-out order.
• Serial Dispatch Queue A serial dispatch queue runs tasks one at a time.
• Concurrent Dispatch Queue A concurrent dispatch queue runs as many tasks as it can without waiting for the started tasks to finish.
• Main Dispatch Queue A globally available serial queue that executes tasks on the application’s main thread.

Question 38

explain capture lists

Answer 38

• enable us to customize how a given closure captures any of the objects or values that it refers to
• ie, ‘[weak self] user in’

Question 39

discuss Swift access control

Answer 39

• Open access and public access enable entities to be used within any source file from their defining module, and also in a source file from another module that imports the defining module. You typically use open or public access when specifying the public interface to a framework. The difference between open and public access is described below.
• Internal access enables entities to be used within any source file from their defining module, but not in any source file outside of that module. You typically use internal access when defining an app’s or a framework’s internal structure.
• File-private access restricts the use of an entity to its own defining source file. Use file-private access to hide the implementation details of a specific piece of functionality when those details are used within an entire file.
• Private access restricts the use of an entity to the enclosing declaration, and to extensions of that declaration that are in the same file. Use private access to hide the implementation details of a specific piece of functionality when those details are used only within a single declaration.