Design Patterns

Question 1

Two main philosophies behind design patterns ?

Answer 1

• Code reuse
• Flexibility

Question 2

Name 5 creational design patterns

Answer 2

Singleton pattern
Builder pattern

Factory method pattern
Abstract factory pattern
Prototype pattern

Question 3

What is the singleton pattern

Answer 3

Restricts the initialization of a class to a single instance for the lifetime of the application

Question 4

Disadvantages of the singleton pattern

Answer 4

• Introduces global state
• Can introduce hidden dependencies and tight coupling
• Dealing with race conditions in multi-threaded apps

Question 5

Advantages of the singleton pattern

Answer 5

Can share object without having to pass it in every method call (ex: store a Bluetooth connection in singleton to maintain connection across pages)

Question 6

Code Example of Singleton Pattern

Answer 6

static variable

class MySingleton {
static let sharedInstance = MySingleton();
var myNumber = 0
private init() { }
}

Question 7

What is the builder pattern ?

Answer 7

Initializing an instance of a type that requires a large number of configurable values

A separate “builder type” is used that contains information required to initialize the complex type.

Have multiple “builder types” to initialize each type
OR
Single builder type and then set options as needed

Question 8

Code Example of Builder Pattern

Answer 8

protocol BurgerBuilder {
var name: String {get }
var patties: Int {get}
var bacon: Bool { get}
var cheese: Bool {get}
…
var tomato: Bool: {get}
}

struct HamburgerBuilder: BurgerBuilder {
let name = “Hamburger”
let patties = 1
let cheese = false;
…
let tomato = false
}

struct CheeseburgerBuilder {
let name = “Cheeseburger”
let patties = 1
let cheese = true
…
let tomato = false
}

struct Burger {
var name: String
var patties: Int
var cheese: Bool
…
var tomato: Bool

init(builder: BurgerBuilder_ {
self.name = builder.name
self.patties = builder.patties
…
}

var myCheeseburger = Burger(builder: CheeseburgerBuilder());

var holdKetchupCB = Burger(CheeseBurgerBuilder())
holdTheKetchupCB.ketchup = false

Question 9

Alternate Code for Build Pattern

Answer 9

struct BurgerBuilder {
var name = “Burger”
var patties = 1
var cheese = false
…
}

mutating func setPatties(choice: Int) { self.patties = choice }
}

// Bacon Cheeseburger
var burgerBuilder = BurgerBuilder()
burgerBuilder.setCheese(choice: true)
burgerBuilder.setBacon(choice:true)

Question 10

Name some structural design patterns

Answer 10

Bridge
Facade
Proxy

Adapter
Composite
Decorator
Flyweight

Question 11

Describe the bridge pattern

Answer 11

Can be thought of as 2-layer abstraction

Taking interacting features and separating the functionality that is SPECIFIC to each feature from the SHARED functionality. a BRIDGE type encapsulates the shared functionality

Question 12

Code example for the bridge pattern

Answer 12

protocol Message {
var messageString: String {get set}
init(messageString: String)
func prepareMessage()
}

protocol Sender {
sendMessage(message: Message)
}

// PlainTextMessage - prepareMessage is empty
// DESEncryptedMessage - prepareMessage does the encryption

// Advanced - Using a bridge
struct MessagingBridge {
static func sendMessage(message: Message, sender: Sender) {
var mySender = sender
message.PrepareMessage()
mySender.message = message
mySender.verifyMessage()
mySender.sendMessage()
}

Question 13

Describe the facade pattern

Answer 13

Hide the complexity of the API behind a simple interface

CDP example - cameraCapture (CaptureCheck: sides = 2, source = camera, orient = landscape)
CaptureReceipt(sides = 1, source = camera OR photo roll, orient = portrait)

Question 14

Describe the proxy pattern

Answer 14

There is one type acting as an interface for another type or API

Usually one of two uses:
layer of abstraction between a single API and my code

Need API changes but don’t have the code or there are dependencies on the API elsewhere in the code

Question 15

Code example for the proxy design pattern

Answer 15

struct HouseProxy {
var house= House()
mutating func addStory(floorPlan: FloorPlan) -> Bool {
if house.stories.count <= 2 {
house.addStory(floorPlan: floorplan)
return true
} else {
return false
}
}
}

var ourHouse = HouseProxy()
// create floorplans for each level
ourHouse.addStory(floorPlan: basement)
ourHouse.addStory(floorPlan: firstStory)
ourHouse.addStory(floorPlan: secondStory)

Question 16

Name some behavioral design patterns

Answer 16

Command
Strategy

Chain of responsibility
Iterator
Mediator
Memento
Observer
State
Visitor

Question 17

Describe the command design pattern

Answer 17

Separate the execution of a command from its invoker. When a type needs to perform ONE of SEVERAL actions

Question 18

Code example for command pattern

Answer 18

protocol Command {
func execute()
}

struct RockerSwitchLightOnCommand: Command { … }

struct RockerSwitchLightOffCommand: Command { … }

struct PullSwitchLightOnCommand: Command { … }

struct PullSwitchLightOffCommand: Command { … }

struct Light {
var LightOnCommand: Command
var lightOffCommand: Command

func turnOnLight() {
self.lightOnCommand.execute()
}

func turnOffLight() {
self.lightOffCommand.execute()
}

var on = PullswitchLightOnCommand()
var off = PullSwitchLightOffCommand()
var light = Light(lightOnCommand: on, lightOffCommand: off)
light.turnOnLight()

Question 19

Describe the strategy design pattern

Answer 19

Similar to command pattern but is intended to encapsulate algorithms.

Which also to use needs to be determined at runtime

Question 20

Describe the observer pattern in iOS

Answer 20

• Also known as pubSub
• iOS example is notifications (which are synchronous)
• NotificationCenter .default.addObserver(_:selector:name:object:)

Question 21

Best way to abstract a singleton ?

Answer 21

Example - Create a protocol for Logging

Place log(0 call in protocol extension (so all classes that implement it get it).

Place call using singleton inside the protocol extension (so only 1 place to change if singleton is not longer wanted).

Question 22

Describe decorator pattern generally and then iOS-specific

Answer 22

General - add functionality to an object without modifying its code.

Swift implements this using:
* Delegates
* extensions
* object composition (ex: inputAccessoryView - KB toolbar)

Question 23

Describe flyweight pattern and how Apple uses it in iOS

Answer 23

Flyweight pattern allows us to use ONE object in many places to avoid excessive memory use.

iOS example is UIFont. For fonts with same settings, iOS shares a single instance.