Tweet
Tweet

Slide 1

Slide 1 text

The Great iOS Concurrency ! " Bake-Off mobOS | Cluj-Napoca, Romania | February 2019 @DesignatedNerd | bakkenbaeck.no | justhum.com

Slide 2

Slide 2 text

What is Concurrency?

Slide 3

Slide 3 text

Concurrency vs. Parallelism

Slide 4

Slide 4 text

Metaphor Time!

Slide 5

Slide 5 text

No content

Slide 6

Slide 6 text

No content

Slide 7

Slide 7 text

No content

Slide 8

Slide 8 text

No content

Slide 9

Slide 9 text

No content

Slide 10

Slide 10 text

No content

Slide 11

Slide 11 text

No content

Slide 12

Slide 12 text

No content

Slide 13

Slide 13 text

No content

Slide 14

Slide 14 text

No content

Slide 15

Slide 15 text

No content

Slide 16

Slide 16 text

No content

Slide 17

Slide 17 text

No content

Slide 18

Slide 18 text

No content

Slide 19

Slide 19 text

No content

Slide 20

Slide 20 text

No content

Slide 21

Slide 21 text

No content

Slide 22

Slide 22 text

No content

Slide 23

Slide 23 text

No content

Slide 24

Slide 24 text

No content

Slide 25

Slide 25 text

No content

Slide 26

Slide 26 text

Concurrency: "One thing should do these tasks at as close to the same time as possible."

Slide 27

Slide 27 text

No content

Slide 28

Slide 28 text

No content

Slide 29

Slide 29 text

No content

Slide 30

Slide 30 text

No content

Slide 31

Slide 31 text

No content

Slide 32

Slide 32 text

No content

Slide 33

Slide 33 text

No content

Slide 34

Slide 34 text

No content

Slide 35

Slide 35 text

Parallelism: "Many things should do all these identical mini-tasks at the same time."

Slide 36

Slide 36 text

No content

Slide 37

Slide 37 text

No content

Slide 38

Slide 38 text

No content

Slide 39

Slide 39 text

No content

Slide 40

Slide 40 text

No content

Slide 41

Slide 41 text

No content

Slide 42

Slide 42 text

!

Slide 43

Slide 43 text

Taking the result of an asynchronous function

Slide 44

Slide 44 text

Taking the result of an asynchronous function Giving it to another asynchronous function

Slide 45

Slide 45 text

Taking the result of an asynchronous function Giving it to another asynchronous function (and another and another)

Slide 46

Slide 46 text

The Problem: ! Callback Hell

Slide 47

Slide 47 text

Teh Codez! https://github.com/designatednerd/ OperationComparison

Slide 48

Slide 48 text

As a user, I want to see a profile picture when viewing a profile.

Slide 49

Slide 49 text

As a developer, I want a list of profiles with icons to drop frames when scrolling.

Slide 50

Slide 50 text

User Data -> Icon Image -> Resized Icon Image static func fetchUser(failureCompletion: @escaping (Error) -> Void, successCompletion: @escaping (User) -> Void) static func fetchImage(for user: User, failureCompletion: @escaping (Swift.Error) -> Void, successCompletion: @escaping (UIImage) -> Void) static func resizeImage(_ image: UIImage, to size: CGSize, failureCompletion: @escaping (Swift.Error) -> Void, successCompletion: @escaping (UIImage) -> Void)

Slide 51

Slide 51 text

Not Horrible... self.activityIndicator.startAnimating() FakeAPI.fetchUser(failureCompletion: { [weak self] error in guard let self = self else { return } self.activityIndicator.stopAnimating() self.operationLabel.text = "Error fetching user: \(error)" }, successCompletion: { [weak self] user in guard let self = self else { return } self.operationLabel.text = "Fetching image..." })

Slide 52

Slide 52 text

Not ideal... self.activityIndicator.startAnimating() FakeAPI.fetchUser(failureCompletion: { [weak self] error in guard let self = self else { return } self.activityIndicator.stopAnimating() self.operationLabel.text = "Error fetching user: \(error)" }, successCompletion: { [weak self] user in guard let self = self else { return } self.operationLabel.text = "Fetching image..." RealAPI.fetchImage(for: user, failureCompletion: { [weak self] error in guard let self = self else { return } self.activityIndicator.stopAnimating() self.operationLabel.text = "Error fetching image: \(error)" }, successCompletion: { [weak self] image in guard let self = self else { return } self.operationLabel.text = "Resizing image..." }) })

Slide 53

Slide 53 text

...Does anyone have a ? self.activityIndicator.startAnimating() FakeAPI.fetchUser(failureCompletion: { [weak self] error in guard let self = self else { return } self.activityIndicator.stopAnimating() self.operationLabel.text = "Error fetching user: \(error)" }, successCompletion: { [weak self] user in guard let self = self else { return } self.operationLabel.text = "Fetching image..." RealAPI.fetchImage(for: user, failureCompletion: { [weak self] error in guard let self = self else { return } self.activityIndicator.stopAnimating() self.operationLabel.text = "Error fetching image: \(error)" }, successCompletion: { [weak self] image in guard let self = self else { return } self.operationLabel.text = "Resizing image..." ImageResizer.resizeImage(image, to: self.imageView.frame.size, failureCompletion: { [weak self] error in guard let self = self else { return } self.activityIndicator.stopAnimating() self.operationLabel.text = "Error resizing image: \(error)" }, successCompletion: { [weak self] resizedImage in guard let self = self else { return } self.activityIndicator.stopAnimating() self.imageView.image = resizedImage self.operationLabel.text = "Complete in \(self.formattedSecondsSince(start))!" }) }) })

Slide 54

Slide 54 text

¯\_(ϑ)_/¯ Avoid UI interaction and don't care about retain cycles!

Slide 55

Slide 55 text

¯\_(ϑ)_/¯ Avoid UI interaction and don't care about retain cycles!* * - not recommended

Slide 56

Slide 56 text

FakeAPI.fetchUser(failureCompletion: { error in debugPrint("Error fetching user: \(error)") }, successCompletion: { user in RealAPI.fetchImage(for: user, failureCompletion: { error in debugPrint("Error fetching image: \(error)") }, successCompletion: { image in ImageResizer.resizeImage(image, to: self.imageView.frame.size, failureCompletion: { error in debugPrint("Error resizing image: \(error)") }, successCompletion: { resizedImage in self.imageView.image = resizedImage debugPrint("Complete in \(self.formattedSecondsSince(start))!" }) }) })

Slide 57

Slide 57 text

Think Indent Different

Slide 58

Slide 58 text

FakeAPI.fetchUser( errorCompletion: { error in debugPrint("Error fetching user: \(error)") }, successCompletion: { user in RealAPI.fetchImage( for: user, failureCompletion: { error in debugPrint("Error fetching image: \(error)") }, successCompletion: { image in ImageResizer.resizeImage( image, to: self.imageView.frame.size, failureCompletion: { error in debugPrint("Error resizing image: \(error)") }, successCompletion: { resizedImage in self.imageView.image = resizedImage debugPrint("Complete in \(self.formattedSecondsSince(start))!" }) }) })

Slide 59

Slide 59 text

Try to break it a p a r t

Slide 60

Slide 60 text

private func fetchUser() { FakeAPI.fetchUser( failureCompletion: { error in debugPrint("Error fetching user: \(error)") }, successCompletion: { user in self.fetchImage(for: user) }) } private func fetchImage(for user: User) { RealAPI.fetchImage( for: user, failureCompletion: { error in debugPrint("Error fetching image: \(error)") }, successCompletion: { image in self.resizeImage(image, to: self.imageView.frame.size) }) } private func resizeImage(_ image: UIImage, to size: CGSize) { ImageResizer.resizeImage( image, to: self.imageView.frame.size, failureCompletion: { error in debugPrint("Error resizing image: \(error)") }, successCompletion: { [weak self] resizedImage in guard let self = self else { return } self.imageView.image = resizedImage debugPrint("Complete in \(self.formattedSecondsSince(start))!") }) }

Slide 61

Slide 61 text

The problem: Dependent functions

Slide 62

Slide 62 text

private func fetchUser() { FakeAPI.fetchUser( failureCompletion: { error in debugPrint("Error fetching user: \(error)") }, successCompletion: { user in self.fetchImage(for: user) }) } private func fetchImage(for user: User) { RealAPI.fetchImage( for: user, failureCompletion: { error in debugPrint("Error fetching image: \(error)") }, successCompletion: { image in self.resizeImage(image, to: self.imageView.frame.size) }) } private func resizeImage(_ image: UIImage, to size: CGSize) { ImageResizer.resizeImage( image, to: self.imageView.frame.size, failureCompletion: { error in debugPrint("Error resizing image: \(error)") }, successCompletion: { [weak self] resizedImage in guard let self = self else { return } self.imageView.image = resizedImage debugPrint("Complete in \(self.formattedSecondsSince(start))!") }) }

Slide 63

Slide 63 text

private func fetchUser() { FakeAPI.fetchUser( failureCompletion: { error in debugPrint("Error fetching user: \(error)") }, successCompletion: { user in self.fetchImage(for: user) }) } private func fetchImage(for user: User) { RealAPI.fetchImage( for: user, failureCompletion: { error in debugPrint("Error fetching image: \(error)") }, successCompletion: { image in self.resizeImage(image, to: self.imageView.frame.size) }) } private func resizeImage(_ image: UIImage, to size: CGSize) { ImageResizer.resizeImage( image, to: self.imageView.frame.size, failureCompletion: { error in debugPrint("Error resizing image: \(error)") }, successCompletion: { [weak self] resizedImage in guard let self = self else { return } self.imageView.image = resizedImage debugPrint("Complete in \(self.formattedSecondsSince(start))!") }) }

Slide 64

Slide 64 text

FakeAPI.fetchUser( errorCompletion: { error in debugPrint("Error fetching user: \(error)") }, successCompletion: { user in RealAPI.fetchImage( for: user, failureCompletion: { error in debugPrint("Error fetching image: \(error)") }, successCompletion: { image in ImageResizer.resizeImage( image, to: self.imageView.frame.size, failureCompletion: { error in debugPrint("Error resizing image: \(error)") }, successCompletion: { resizedImage in self.imageView.image = resizedImage debugPrint("Complete in \(self.formattedSecondsSince(start))!" }) }) })

Slide 65

Slide 65 text

A slight help: The Result Type

Slide 66

Slide 66 text

! Swift 5.0 https://github.com/apple/swift/ blob/master/stdlib/public/core/ Result.swift

Slide 67

Slide 67 text

Result.Swift public enum Result { /// A success, storing a `Success` value. case success(Success) /// A failure, storing a `Failure` value. case failure(Failure) }

Slide 68

Slide 68 text

User Data -> Icon Image -> Resized Icon Image static func fetchUser(failureCompletion: @escaping (Error) -> Void, successCompletion: @escaping (User) -> Void) static func fetchImage(for user: User, failureCompletion: @escaping (Swift.Error) -> Void, successCompletion: @escaping (UIImage) -> Void) static func resizeImage(_ image: UIImage, to size: CGSize, failureCompletion: @escaping (Swift.Error) -> Void, successCompletion: @escaping (UIImage) -> Void)

Slide 69

Slide 69 text

User Data -> Icon Image -> Resized Icon Image static func fetchUser(completion: @escaping (Result) -> Void) static func fetchImage(for user: User, completion: @escaping (Result) -> Void) static func resizeImage(_ image: UIImage, to size: CGSize, failureCompletion: @escaping (Result) -> Void)

Slide 70

Slide 70 text

FakeAPI.fetchUser { userResult in switch userResult { case .success(let user): RealAPI.fetchImage(for: user) { imageResult in switch imageResult { case .success(let image): ImageResizer.resizeImage(image, to: self.imageView.frame.size) { resizedImageResult in switch resizedImageResult { case .success(let resizedImage): self.imageView.image = resizedImage debugPrint("Complete") case .failure(let error): debugPrint("Error resizing image: \(error)") } } case .failure(let error): debugPrint("Error fetching image: \(error)") } } case .failure(let error): debugPrint("Error fetching user: \(error)") } }

Slide 71

Slide 71 text

FakeAPI.fetchUser { userResult in switch userResult { case .success(let user): RealAPI.fetchImage(for: user) { imageResult in switch imageResult { case .success(let image): ImageResizer.resizeImage(image, to: self.imageView.frame.size) { resizedImageResult in switch resizedImageResult { case .success(let resizedImage): self.imageView.image = resizedImage debugPrint("Complete") case .failure(let error): debugPrint("Error resizing image: \(error)") } } case .failure(let error): debugPrint("Error fetching image: \(error)") } } case .failure(let error): debugPrint("Error fetching user: \(error)") } }

Slide 72

Slide 72 text

FakeAPI.fetchUser { userResult in switch userResult { case .success(let user): RealAPI.fetchImage(for: user) { imageResult in switch imageResult { case .success(let image): ImageResizer.resizeImage( image, to: self.imageView.frame.size) { resizedImageResult in switch resizedImageResult { case .success(let resizedImage): self.imageView.image = resizedImage debugPrint("Complete") case .failure(let error): debugPrint("Error resizing image: \(error)") } } case .failure(let error): debugPrint("Error fetching image: \(error)") } } case .failure(let error): debugPrint("Error fetching user: \(error)") } }

Slide 73

Slide 73 text

FakeAPI.fetchUser { userResult in switch userResult { case .success(let user): RealAPI.fetchImage(for: user) { imageResult in switch imageResult { case .success(let image): ImageResizer.resizeImage( image, to: self.imageView.frame.size) { resizedImageResult in switch resizedImageResult { case .success(let resizedImage): self.imageView.image = resizedImage debugPrint("Complete") case .failure(let error): debugPrint("Error resizing image: \(error)") } } case .failure(let error): debugPrint("Error fetching image: \(error)") } } case .failure(let error): debugPrint("Error fetching user: \(error)") } }

Slide 74

Slide 74 text

How do we chain operations which need each others' results clearly?

Slide 75

Slide 75 text

How do we chain operations which need each others' results in an easy-to-follow way?

Slide 76

Slide 76 text

How do we chain operations which need each others' results so we can figure out where something's going wrong?

Slide 77

Slide 77 text

! " Bake-Off!

Slide 78

Slide 78 text

No content

Slide 79

Slide 79 text

Three competitors

Slide 80

Slide 80 text

Three competitors (out of way more than three)

Slide 81

Slide 81 text

No content

Slide 82

Slide 82 text

No content

Slide 83

Slide 83 text

No content

Slide 84

Slide 84 text

The Problem: ! Callback Hell

Slide 85

Slide 85 text

Three competitors

Slide 86

Slide 86 text

Three competitors 1. Operator Overloading

Slide 87

Slide 87 text

Three competitors 1. Operator Overloading 2. PromiseKit

Slide 88

Slide 88 text

Three competitors 1. Operator Overloading 2. PromiseKit 3. RxSwift

Slide 89

Slide 89 text

! Signature Challenge:

Slide 90

Slide 90 text

! Signature Challenge: Making Code More Readable

Slide 91

Slide 91 text

Competitor #1: Operator Overloading

Slide 92

Slide 92 text

Competitor #1: Operator Overloading "We don't need no stinkin' libraries!"

Slide 93

Slide 93 text

No content

Slide 94

Slide 94 text

typealias ResultCompletion = (Result) -> Void infix operator -->: MultiplicationPrecedence func -->(_ firstFunction: @escaping (@escaping ResultCompletion) -> Void, _ secondFunction: @escaping (T, @escaping ResultCompletion) -> Void) -> (@escaping ResultCompletion) -> Void { return { completion in firstFunction { result in switch result { case .success(let item): secondFunction(item) { result2 in completion(result2) } case .error(let error): completion(.error(error)) } } } }

Slide 95

Slide 95 text

typealias ResultCompletion = (Result) -> Void infix operator -->: MultiplicationPrecedence func -->(_ firstFunction: @escaping (@escaping ResultCompletion) -> Void, _ secondFunction: @escaping (T, @escaping ResultCompletion) -> Void) -> (@escaping ResultCompletion) -> Void { return { completion in firstFunction { result in switch result { case .success(let item): secondFunction(item) { result2 in completion(result2) } case .error(let error): completion(.error(error)) } } } }

Slide 96

Slide 96 text

typealias ResultCompletion = (Result) -> Void infix operator -->: MultiplicationPrecedence func -->(_ firstFunction: @escaping (@escaping ResultCompletion) -> Void, _ secondFunction: @escaping (T, @escaping ResultCompletion) -> Void) -> (@escaping ResultCompletion) -> Void { return { completion in firstFunction { result in switch result { case .success(let item): secondFunction(item) { result2 in completion(result2) } case .error(let error): completion(.error(error)) } } } }

Slide 97

Slide 97 text

PEMDAS

Slide 98

Slide 98 text

PEMDAS (parentheses, exponents, multiplication, division, addition, subtraction)

Slide 99

Slide 99 text

typealias ResultCompletion = (Result) -> Void infix operator -->: MultiplicationPrecedence func -->(_ firstFunction: @escaping (@escaping ResultCompletion) -> Void, _ secondFunction: @escaping (T, @escaping ResultCompletion) -> Void) -> (@escaping ResultCompletion) -> Void { return { completion in firstFunction { result in switch result { case .success(let item): secondFunction(item) { result2 in completion(result2) } case .error(let error): completion(.error(error)) } } } }

Slide 100

Slide 100 text

typealias ResultCompletion = (Result) -> Void infix operator -->: MultiplicationPrecedence func -->(_ firstFunction: @escaping (@escaping ResultCompletion) -> Void, _ secondFunction: @escaping (T, @escaping ResultCompletion) -> Void) -> (@escaping ResultCompletion) -> Void { return { completion in firstFunction { result in switch result { case .success(let item): secondFunction(item) { result2 in completion(result2) } case .error(let error): completion(.error(error)) } } } }

Slide 101

Slide 101 text

typealias ResultCompletion = (Result) -> Void infix operator -->: MultiplicationPrecedence func -->(_ firstFunction: @escaping (@escaping ResultCompletion) -> Void, _ secondFunction: @escaping (T, @escaping ResultCompletion) -> Void) -> (@escaping ResultCompletion) -> Void { return { completion in firstFunction { result in switch result { case .success(let item): secondFunction(item) { result2 in completion(result2) } case .error(let error): completion(.error(error)) } } } }

Slide 102

Slide 102 text

typealias ResultCompletion = (Result) -> Void infix operator -->: MultiplicationPrecedence func -->(_ firstFunction: @escaping (@escaping ResultCompletion) -> Void, _ secondFunction: @escaping (T, @escaping ResultCompletion) -> Void) -> (@escaping ResultCompletion) -> Void { return { completion in firstFunction { result in switch result { case .success(let item): secondFunction(item) { result2 in completion(result2) } case .error(let error): completion(.error(error)) } } } }

Slide 103

Slide 103 text

typealias ResultCompletion = (Result) -> Void infix operator -->: MultiplicationPrecedence func -->(_ firstFunction: @escaping (@escaping ResultCompletion) -> Void, _ secondFunction: @escaping (T, @escaping ResultCompletion) -> Void) -> (@escaping ResultCompletion) -> Void { return { completion in firstFunction { result in switch result { case .success(let item): secondFunction(item) { result2 in completion(result2) } case .error(let error): completion(.error(error)) } } } }

Slide 104

Slide 104 text

User Data -> Icon Image -> Resized Icon Image static func fetchUser(completion: @escaping (Result) -> Void) static func fetchImage(for user: User, completion: @escaping (Result) -> Void) static func resizeImage(_ image: UIImage, to size: CGSize, failureCompletion: @escaping (Result) -> Void)

Slide 105

Slide 105 text

User Data -> Icon Image -> Resized Icon Image static func fetchUser(completion: @escaping (Result) -> Void) static func fetchImage(for user: User, completion: @escaping (Result) -> Void) static func resizeImage(_ image: UIImage, to size: CGSize, failureCompletion: @escaping (Result) -> Void)

Slide 106

Slide 106 text

User Data -> Icon Image -> Resized Icon Image static func fetchUser(completion: @escaping (Result) -> Void) static func fetchImage(for user: User, completion: @escaping (Result) -> Void) static func resizeImage(_ image: UIImage, to size: CGSize, failureCompletion: @escaping (Result) -> Void)

Slide 107

Slide 107 text

! Wrapper Methods private func resizeImageForImageView(_ image: UIImage, completion: @escaping (Swift.Result) -> Void) { ImageResizer.resizeImage(image, to: self.imageView.frame.size, completion: completion) }

Slide 108

Slide 108 text

! Wrapper Methods private func resizeImageForImageView(_ image: UIImage, completion: @escaping (Swift.Result) -> Void) { self.operationLabel.text = "Resizing image (Custom Operator)..." ImageResizer.resizeImage(image, to: self.imageView.frame.size, completion: completion) } private func fetchUserImage(for user: User, completion: @escaping (Swift.Result) -> Void) { self.operationLabel.text = "Fetching image (Custom Operator)..." RealAPI.fetchImage(for: user, completion: completion) }

Slide 109

Slide 109 text

self.activityIndicator.startAnimating() let chain = API.fetchUser --> fetchUserImage --> resizeImageForImageView chain { result in self.activityIndicator.stopAnimating() switch result { case .success(let image): self.imageView.image = image self.operationLabel.text = "Complete (Custom Operator)!" case .error(let error): self.operationLabel.text = "Error occurred (Custom Operator): \(error)" } }

Slide 110

Slide 110 text

self.activityIndicator.startAnimating() let chain = API.fetchUser --> fetchUserImage --> resizeImageForImageView chain { result in self.activityIndicator.stopAnimating() switch result { case .success(let image): self.imageView.image = image self.operationLabel.text = "Complete (Custom Operator)!" case .error(let error): self.operationLabel.text = "Error occurred (Custom Operator): \(error)" } }

Slide 111

Slide 111 text

self.activityIndicator.startAnimating() let chain = API.fetchUser --> fetchUserImage --> resizeImageForImageView chain { result in self.activityIndicator.stopAnimating() switch result { case .success(let image): self.imageView.image = image self.operationLabel.text = "Complete (Custom Operator)!" case .error(let error): self.operationLabel.text = "Error occurred (Custom Operator): \(error)" } }

Slide 112

Slide 112 text

typealias ResultCompletion = (Result) -> Void infix operator -->: MultiplicationPrecedence func -->(_ firstFunction: @escaping (@escaping ResultCompletion) -> Void, _ secondFunction: @escaping (T, @escaping ResultCompletion) -> Void) -> (@escaping ResultCompletion) -> Void { return { completion in firstFunction { result in switch result { case .success(let item): secondFunction(item) { result2 in completion(result2) } case .error(let error): completion(.error(error)) } } } }

Slide 113

Slide 113 text

typealias ResultCompletion = (Result) -> Void infix operator -->: MultiplicationPrecedence func -->(_ firstFunction: @escaping (@escaping ResultCompletion) -> Void, _ secondFunction: @escaping (T, @escaping ResultCompletion) -> Void) -> (@escaping ResultCompletion) -> Void { return { completion in firstFunction { result in switch result { case .success(let item): secondFunction(item) { result2 in completion(result2) } case .error(let error): completion(.error(error)) } } } }

Slide 114

Slide 114 text

Pro: You Do It Yourself

Slide 115

Slide 115 text

Con: You Do It Yourself

Slide 116

Slide 116 text

Competitor #2: PromiseKit

Slide 117

Slide 117 text

Competitor #2: PromiseKit "OK, fine. Maybe we do need a library."

Slide 118

Slide 118 text

No content

Slide 119

Slide 119 text

No content

Slide 120

Slide 120 text

User Data -> Icon Image -> Resized Icon Image static func fetchUser(completion: @escaping (Result) -> Void) static func fetchImage(for user: User, completion: @escaping (Result) -> Void) static func resizeImage(_ image: UIImage, to size: CGSize, failureCompletion: @escaping (Result) -> Void)

Slide 121

Slide 121 text

User Data -> Icon Image -> Resized Icon Image static func fetchUser() -> Promise static func fetchImage(for user: User) -> Promise static func resizeImage(_ image: UIImage, to size: CGSize) -> Promise

Slide 122

Slide 122 text

self.activityIndicator.startAnimating() FakeAPI.fetchUser() .then { user in RealAPI.fetchImage(for: user) } .then { image in ImageResizer.resizeImage(image, to: self.imageView.frame.size) } .ensure { self.activityIndicator.stopAnimating() } .done { resizedImage in self.imageView.image = resizedImage self.operationLabel.text = "Complete (PromiseKit)!" } .catch { [weak self] error in self?.operationLabel.text = "Error occurred (PromiseKit): \(error)" }

Slide 123

Slide 123 text

self.activityIndicator.startAnimating() FakeAPI.fetchUser() .then { user in RealAPI.fetchImage(for: user) } .then { image in ImageResizer.resizeImage(image, to: self.imageView.frame.size) } .ensure { self.activityIndicator.stopAnimating() } .done { resizedImage in self.imageView.image = resizedImage self.operationLabel.text = "Complete (PromiseKit)!" } .catch { [weak self] error in self?.operationLabel.text = "Error occurred (PromiseKit): \(error)" }

Slide 124

Slide 124 text

self.activityIndicator.startAnimating() FakeAPI.fetchUser() .then { user in RealAPI.fetchImage(for: user) } .then { image in ImageResizer.resizeImage(image, to: self.imageView.frame.size) } .ensure { self.activityIndicator.stopAnimating() } .done { resizedImage in self.imageView.image = resizedImage self.operationLabel.text = "Complete (PromiseKit)!" } .catch { [weak self] error in self?.operationLabel.text = "Error occurred (PromiseKit): \(error)" }

Slide 125

Slide 125 text

self.activityIndicator.startAnimating() FakeAPI.fetchUser() .then { user in RealAPI.fetchImage(for: user) } .then { image in ImageResizer.resizeImage(image, to: self.imageView.frame.size) } .ensure { self.activityIndicator.stopAnimating() } .done { resizedImage in self.imageView.image = resizedImage self.operationLabel.text = "Complete (PromiseKit)!" } .catch { [weak self] error in self?.operationLabel.text = "Error occurred (PromiseKit): \(error)" }

Slide 126

Slide 126 text

self.activityIndicator.startAnimating() FakeAPI.fetchUser() .then { user in RealAPI.fetchImage(for: user) } .then { image in ImageResizer.resizeImage(image, to: self.imageView.frame.size) } .ensure { self.activityIndicator.stopAnimating() } .done { resizedImage in self.imageView.image = resizedImage self.operationLabel.text = "Complete (PromiseKit)!" } .catch { [weak self] error in self?.operationLabel.text = "Error occurred (PromiseKit): \(error)" }

Slide 127

Slide 127 text

self.activityIndicator.startAnimating() FakeAPI.fetchUser() .then { user in RealAPI.fetchImage(for: user) } .then { image in ImageResizer.resizeImage(image, to: self.imageView.frame.size) } .ensure { self.activityIndicator.stopAnimating() } .done { resizedImage in self.imageView.image = resizedImage self.operationLabel.text = "Complete (PromiseKit)!" } .catch { [weak self] error in self?.operationLabel.text = "Error occurred (PromiseKit): \(error)" }

Slide 128

Slide 128 text

self.activityIndicator.startAnimating() FakeAPI.fetchUser() .then { user in RealAPI.fetchImage(for: user) } .then { image in ImageResizer.resizeImage(image, to: self.imageView.frame.size) } .ensure { self.activityIndicator.stopAnimating() } .done { resizedImage in self.imageView.image = resizedImage self.operationLabel.text = "Complete (PromiseKit)!" } .catch { [weak self] error in self?.operationLabel.text = "Error occurred (PromiseKit): \(error)" }

Slide 129

Slide 129 text

No content

Slide 130

Slide 130 text

Solution #3: RxSwift

Slide 131

Slide 131 text

Solution #3: RxSwift "Use ALL the libraries!"

Slide 132

Slide 132 text

User Data -> Icon Image -> Resized Icon Image static func fetchUser() -> Promise static func fetchImage(for user: User) -> Promise static func resizeImage(_ image: UIImage, to size: CGSize) -> Promise

Slide 133

Slide 133 text

User Data -> Icon Image -> Resized Icon Image static func fetchUser() -> Single static func fetchImage(for user: User) -> Single static func resizeImage(_ image: UIImage, to size: CGSize) -> Single

Slide 134

Slide 134 text

No content

Slide 135

Slide 135 text

Observable

Slide 136

Slide 136 text

Observable "I could get many values from this, until it tells me things are complete or an error has occurred."

Slide 137

Slide 137 text

Single

Slide 138

Slide 138 text

Single "This will either succeed or fail once."

Slide 139

Slide 139 text

FakeAPI.rx.fetchUser() .flatMap { user in RealAPI.rx.fetchImage(for: user) } .flatMap { image in ImageResizer.rx.resizeImage(image, to: self.imageView.frame.size) } .subscribe( onSuccess: { resizedImage in self.imageView.image = resizedImage self.operationLabel.text = "Complete (RxSwift) in \(self.formattedSecondsSince(start))!" }, onError: { error in self.operationLabel.text = "Error occurred (RxSwift): \(error)" } ) .disposed(by: bag)

Slide 140

Slide 140 text

FakeAPI.rx.fetchUser() .flatMap { user in RealAPI.rx.fetchImage(for: user) } .flatMap { image in ImageResizer.rx.resizeImage(image, to: self.imageView.frame.size) } .subscribe( onSuccess: { resizedImage in self.imageView.image = resizedImage self.operationLabel.text = "Complete (RxSwift) in \(self.formattedSecondsSince(start))!" }, onError: { error in self.operationLabel.text = "Error occurred (RxSwift): \(error)" } ) .disposed(by: bag)

Slide 141

Slide 141 text

FakeAPI.rx.fetchUser() .flatMap { user in RealAPI.rx.fetchImage(for: user) } .flatMap { image in ImageResizer.rx.resizeImage(image, to: self.imageView.frame.size) } .subscribe( onSuccess: { resizedImage in self.imageView.image = resizedImage self.operationLabel.text = "Complete (RxSwift) in \(self.formattedSecondsSince(start))!" }, onError: { error in self.operationLabel.text = "Error occurred (RxSwift): \(error)" } ) .disposed(by: bag)

Slide 142

Slide 142 text

No content

Slide 143

Slide 143 text

FakeAPI.rx.fetchUser() .flatMap { user in RealAPI.rx.fetchImage(for: user) } .flatMap { image in ImageResizer.rx.resizeImage(image, to: self.imageView.frame.size) } .subscribe( onSuccess: { resizedImage in self.imageView.image = resizedImage self.operationLabel.text = "Complete (RxSwift) in \(self.formattedSecondsSince(start))!" }, onError: { error in self.operationLabel.text = "Error occurred (RxSwift): \(error)" } ) .disposed(by: bag)

Slide 144

Slide 144 text

FakeAPI.rx.fetchUser() .flatMap { user in RealAPI.rx.fetchImage(for: user) } .flatMap { image in ImageResizer.rx.resizeImage(image, to: self.imageView.frame.size) } .subscribe( onSuccess: { resizedImage in self.imageView.image = resizedImage self.operationLabel.text = "Complete (RxSwift) in \(self.formattedSecondsSince(start))!" }, onError: { error in self.operationLabel.text = "Error occurred (RxSwift): \(error)" } ) .disposed(by: bag)

Slide 145

Slide 145 text

FakeAPI.rx.fetchUser() .flatMap { user in RealAPI.rx.fetchImage(for: user) } .flatMap { image in ImageResizer.rx.resizeImage(image, to: self.imageView.frame.size) } .subscribe( onSuccess: { resizedImage in self.imageView.image = resizedImage self.operationLabel.text = "Complete (RxSwift) in \(self.formattedSecondsSince(start))!" }, onError: { error in self.operationLabel.text = "Error occurred (RxSwift): \(error)" } ) .disposed(by: bag)

Slide 146

Slide 146 text

No content

Slide 147

Slide 147 text

! Technical Challenge:

Slide 148

Slide 148 text

! Technical Challenge: Handling Threading

Slide 149

Slide 149 text

Operator Overloading private func fetchUserImage(for user: User, completion: @escaping (Result) -> Void) { self.operationLabel.text = "Fetching image (Custom Operator)..." API.fetchImage(for: user, completion: completion) }

Slide 150

Slide 150 text

Operator Overloading private func fetchUserImage(for user: User, completion: @escaping (Result) -> Void) { self.operationLabel.text = "Fetching image (Custom Operator)..." DispatchQueue.global(qos: .background).async { API.fetchImage(for: user, completion: completion) } }

Slide 151

Slide 151 text

Operator Overloading private func fetchUserImage(for user: User, completion: @escaping (Result) -> Void) { self.operationLabel.text = "Fetching image (Custom Operator)..." DispatchQueue.global(qos: .background).async { API.fetchImage(for: user, completion: completion) } }

Slide 152

Slide 152 text

Operator Overloading private func fetchUserImage(for user: User, completion: @escaping (Result) -> Void) { self.operationLabel.text = "Fetching image (Custom Operator)..." DispatchQueue.global(qos: .background).async { API.fetchImage(for: user, completion: completion) } }

Slide 153

Slide 153 text

No content

Slide 154

Slide 154 text

PromiseKit FakeAPI.fetchUser() .then { user in RealAPI.fetchImage(for: user) } .then { image in ImageResizer.resizeImage(image, to: self.imageView.frame.size) } .ensure { self.activityIndicator.stopAnimating() } .done { resizedImage in self.imageView.image = resizedImage self.operationLabel.text = "Complete (PromiseKit)!" } .catch { [weak self] error in self?.operationLabel.text = "Error occurred (PromiseKit): \(error)" }

Slide 155

Slide 155 text

PromiseKit FakeAPI.fetchUser() .then(on: .global(qos: .background)) { user in RealAPI.fetchImage(for: user) } .then(on: .global(qos: .background)) { image in ImageResizer.resizeImage(image, to: self.imageView.frame.size) } .ensure { self.activityIndicator.stopAnimating() } .done { resizedImage in self.imageView.image = resizedImage self.operationLabel.text = "Complete (PromiseKit)!" } .catch { [weak self] error in self?.operationLabel.text = "Error occurred (PromiseKit): \(error)" }

Slide 156

Slide 156 text

PromiseKit FakeAPI.fetchUser() .then(on: .global(qos: .background)) { user in RealAPI.fetchImage(for: user) } .then(on: .global(qos: .background)) { image in ImageResizer.resizeImage(image, to: self.imageView.frame.size) } .ensure { self.activityIndicator.stopAnimating() } .done { resizedImage in self.imageView.image = resizedImage self.operationLabel.text = "Complete (PromiseKit)!" } .catch { [weak self] error in self?.operationLabel.text = "Error occurred (PromiseKit): \(error)" }

Slide 157

Slide 157 text

PromiseKit FakeAPI.fetchUser() .then(on: .global(qos: .background)) { user in RealAPI.fetchImage(for: user) } .then(on: .global(qos: .background)) { image in ImageResizer.resizeImage(image, to: self.imageView.frame.size) } .ensure { self.activityIndicator.stopAnimating() } .done { resizedImage in self.imageView.image = resizedImage self.operationLabel.text = "Complete (PromiseKit)!" } .catch { [weak self] error in self?.operationLabel.text = "Error occurred (PromiseKit): \(error)" }

Slide 158

Slide 158 text

PromiseKit 6

Slide 159

Slide 159 text

PromiseKit 6

Slide 160

Slide 160 text

PromiseKit 6

Slide 161

Slide 161 text

PromiseKit 6

Slide 162

Slide 162 text

PromiseKit 6

Slide 163

Slide 163 text

PromiseKit 6

Slide 164

Slide 164 text

No content

Slide 165

Slide 165 text

No content

Slide 166

Slide 166 text

PromiseKit 6

Slide 167

Slide 167 text

PromiseKit FakeAPI.fetchUser() .then(on: .global(qos: .background)) { user in RealAPI.fetchImage(for: user) } .map { image in (image, self.imageView.frame.size) } .then(on: .global(qos: .background)) { tuple in ImageResizer.resizeImage(tuple.0, to: tuple.1) } .then(on: .global(qos: .background)) { image in ImageResizer.resizeImage(image, to: self.imageView.frame.size) } .ensure { self.activityIndicator.stopAnimating() } .done { resizedImage in self.imageView.image = resizedImage self.operationLabel.text = "Complete (PromiseKit)!" } .catch { [weak self] error in self?.operationLabel.text = "Error occurred (PromiseKit): \(error)" }

Slide 168

Slide 168 text

PromiseKit FakeAPI.fetchUser() .then(on: .global(qos: .background)) { user in RealAPI.fetchImage(for: user) } .map { image in (image, self.imageView.frame.size) } .then(on: .global(qos: .background)) { tuple in ImageResizer.resizeImage(tuple.0, to: tuple.1) } .then(on: .global(qos: .background)) { image in ImageResizer.resizeImage(image, to: self.imageView.frame.size) } .ensure { self.activityIndicator.stopAnimating() } .done { resizedImage in self.imageView.image = resizedImage self.operationLabel.text = "Complete (PromiseKit)!" } .catch { [weak self] error in self?.operationLabel.text = "Error occurred (PromiseKit): \(error)" }

Slide 169

Slide 169 text

RxSwift:

Slide 170

Slide 170 text

RxSwift: ! Scheduler

Slide 171

Slide 171 text

It's not a queue!

Slide 172

Slide 172 text

It's not a queue! (it's just way easier to think of it as one)

Slide 173

Slide 173 text

observeOn: tell me what happened here

Slide 174

Slide 174 text

RxSwift FakeAPI.rx.fetchUser() .flatMap { user in RealAPI.rx.fetchImage(for: user) } .flatMap { image in ImageResizer.rx.resizeImage(image, to: self.imageView.frame.size) } .subscribe( onSuccess: { resizedImage in self.imageView.image = resizedImage self.operationLabel.text = "Complete (RxSwift) in \(self.formattedSecondsSince(start))!" }, onError: { error in self.operationLabel.text = "Error occurred (RxSwift): \(error)" } ) .disposed(by: bag)

Slide 175

Slide 175 text

RxSwift FakeAPI.rx.fetchUser() .flatMap { user in RealAPI.rx.fetchImage(for: user) } .flatMap { image in ImageResizer.rx.resizeImage(image, to: self.imageView.frame.size) } .observeOn(MainScheduler.instance) .subscribe( onSuccess: { resizedImage in self.imageView.image = resizedImage self.operationLabel.text = "Complete (RxSwift) in \(self.formattedSecondsSince(start))!" }, onError: { error in self.operationLabel.text = "Error occurred (RxSwift): \(error)" } ) .disposed(by: bag)

Slide 176

Slide 176 text

RxSwift FakeAPI.rx.fetchUser() .flatMap { user in RealAPI.rx.fetchImage(for: user) } .flatMap { image in ImageResizer.rx.resizeImage(image, to: self.imageView.frame.size) } .observeOn(MainScheduler.instance) .subscribe( onSuccess: { resizedImage in self.imageView.image = resizedImage self.operationLabel.text = "Complete (RxSwift) in \(self.formattedSecondsSince(start))!" }, onError: { error in self.operationLabel.text = "Error occurred (RxSwift): \(error)" } ) .disposed(by: bag)

Slide 177

Slide 177 text

subscribeOn: actually do stuff here

Slide 178

Slide 178 text

RxSwift FakeAPI.rx.fetchUser() .flatMap { user in RealAPI.rx.fetchImage(for: user) } .flatMap { image in ImageResizer.rx.resizeImage(image, to: self.imageView.frame.size) } .subscribeOn(ConcurrentDispatchQueueScheduler(qos: .background)) .observeOn(MainScheduler.instance) .subscribe( onSuccess: { resizedImage in self.imageView.image = resizedImage self.operationLabel.text = "Complete (RxSwift) in \(self.formattedSecondsSince(start))!" }, onError: { error in self.operationLabel.text = "Error occurred (RxSwift): \(error)" } ) .disposed(by: bag)

Slide 179

Slide 179 text

No content

Slide 180

Slide 180 text

Operator overloading: Hard mode

Slide 181

Slide 181 text

PromiseKit: Perform on a queue you specify Call back on a pre-defined queue

Slide 182

Slide 182 text

RxSwift: Always specify where to do stuff Always specify where to call back

Slide 183

Slide 183 text

! Show-Stopper Challenge:

Slide 184

Slide 184 text

! Show-Stopper Challenge: Multi-Function Concurrency

Slide 185

Slide 185 text

Two functions at the same time Do something with both results

Slide 186

Slide 186 text

Operator Overloading

Slide 187

Slide 187 text

Operator Overloading

Slide 188

Slide 188 text

No content

Slide 189

Slide 189 text

PromiseKit: Same Type let userPromise1 = FakeAPI.fetchUser() let userPromise2 = FakeAPI.fetchUser() when(fulfilled: [userPromise1, userPromise2]) .done { users in debugPrint("Users: \(users)") } .catch { error in debugPrint("Error: \(error)") }

Slide 190

Slide 190 text

PromiseKit: Same Type let userPromise1 = FakeAPI.fetchUser() let userPromise2 = FakeAPI.fetchUser() when(fulfilled: [userPromise1, userPromise2]) .done { users in debugPrint("Users: \(users)") } .catch { error in debugPrint("Error: \(error)") }

Slide 191

Slide 191 text

PromiseKit: Same Type let userPromise1 = FakeAPI.fetchUser() let userPromise2 = FakeAPI.fetchUser() when(fulfilled: [userPromise1, userPromise2]) .done { users in debugPrint("Users: \(users)") } .catch { error in debugPrint("Error: \(error)") }

Slide 192

Slide 192 text

PromiseKit: Same Type let userPromise1 = FakeAPI.fetchUser() let userPromise2 = FakeAPI.fetchUser() when(fulfilled: userPromise1, userPromise2) .done { user1, user2 in debugPrint("User1: \(user1), User2: \(user2)") } .catch { error in debugPrint("Error: \(error)") }

Slide 193

Slide 193 text

PromiseKit: Same Type let userPromise1 = FakeAPI.fetchUser() let userPromise2 = FakeAPI.fetchUser() when(fulfilled: userPromise1, userPromise2) .done { user1, user2 in debugPrint("User1: \(user1), User2: \(user2)") } .catch { error in debugPrint("Error: \(error)") }

Slide 194

Slide 194 text

PromiseKit: Different Types let userPromise1 = FakeAPI.fetchUser() let imagePromise = ImageResizer.resizeImage(UIImage(), to: self.imageView.frame.size) when(fulfilled: userPromise1, imagePromise) .done { user, image in debugPrint("User: \(user), image: \(image)") } .catch { error in debugPrint("Error: \(error)") }

Slide 195

Slide 195 text

PromiseKit: Different Types let userPromise1 = FakeAPI.fetchUser() let imagePromise = ImageResizer.resizeImage(UIImage(), to: self.imageView.frame.size) when(fulfilled: userPromise1, imagePromise) .done { user, image in debugPrint("User: \(user), image: \(image)") } .catch { error in debugPrint("Error: \(error)") }

Slide 196

Slide 196 text

PromiseKit: Different Types let userPromise1 = FakeAPI.fetchUser() let imagePromise = ImageResizer.resizeImage(UIImage(), to: self.imageView.frame.size) when(fulfilled: userPromise1, imagePromise) .done { user, image in debugPrint("User: \(user), image: \(image)") } .catch { error in debugPrint("Error: \(error)") }

Slide 197

Slide 197 text

No content

Slide 198

Slide 198 text

No content

Slide 199

Slide 199 text

RxSwift

Slide 200

Slide 200 text

No content

Slide 201

Slide 201 text

Rx Marble Diagrams

Slide 202

Slide 202 text

RxSwift

Slide 203

Slide 203 text

RxSwift

Slide 204

Slide 204 text

RxSwift

Slide 205

Slide 205 text

RxSwift

Slide 206

Slide 206 text

RxSwift

Slide 207

Slide 207 text

No content

Slide 208

Slide 208 text

No content

Slide 209

Slide 209 text

No content

Slide 210

Slide 210 text

JUST PICK ONE!

Slide 211

Slide 211 text

! PromiseKit

Slide 212

Slide 212 text

! PromiseKit FOR ME

Slide 213

Slide 213 text

No content

Slide 214

Slide 214 text

! Killing flies with a sledgehammer

Slide 215

Slide 215 text

Sometimes you need a sledgehammer

Slide 216

Slide 216 text

Most of the time you only need a fly swatter

Slide 217

Slide 217 text

Obligatory Summary Slide

Slide 218

Slide 218 text

Obligatory Summary Slide → Harder concurrency is it looks than.

Slide 219

Slide 219 text

Obligatory Summary Slide → Concurrency is harder than it looks.

Slide 220

Slide 220 text

Obligatory Summary Slide → Concurrency is harder than it looks. → You can try to handle it yourself, but it's going to be a difficult time sink.

Slide 221

Slide 221 text

Obligatory Summary Slide → Concurrency is harder than it looks. → You can try to handle it yourself, but it's going to be a difficult time sink. → PromiseKit is great for most concurrency handling and readability

Slide 222

Slide 222 text

Obligatory Summary Slide → Concurrency is harder than it looks. → You can try to handle it yourself, but it's going to be a difficult time sink. → PromiseKit is great for most concurrency handling and readability → RxSwift is a giant hammer...but sometimes you need a giant hammer.

Slide 223

Slide 223 text

No content

Slide 224

Slide 224 text

Choose Wisely

Slide 225

Slide 225 text

Links! → Vincent Pradeilles' Function Composition Talk https://vimeo.com/292702159 → John Sundell's Tasks post https://www.swiftbysundell.com/posts/ task-based-concurrency-in-swift → RxMarbles Visualization https://rxmarbles.com

Slide 226

Slide 226 text

! The Future! → Chris Lattner's Concurrency Manifesto https://gist.github.com/lattner/ 31ed37682ef1576b16bca1432ea9f782 → Kotlin Coroutines: Async/Await + More https://kotlinlang.org/docs/reference/ coroutines-overview.html