The Great iOS Concurrency Bake-Off - Swift Usergroup Netherlands, Amsterdam, February 2019

Transcript

The Great iOS Concurrency
! "
Bake-Off
!
Swift Usergroup NL
!
| Amsterdam | February 2019
@DesignatedNerd | bakkenbaeck.no | justhum.com

View Slide

What is Concurrency?

View Slide

Concurrency
vs.
Parallelism

View Slide

Metaphor
Time!

View Slide

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

View Slide

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

View Slide

!

View Slide

Taking the result of an asynchronous function

View Slide

Giving it to another asynchronous function

View Slide

Giving it to another asynchronous function
(and another and another)

View Slide

The Problem:
!
Callback Hell

View Slide

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

View Slide

As a user, I want to see
a proﬁle picture
when viewing a proﬁle.

View Slide

As a developer, I want a
list of proﬁles with icons to not
drop frames when scrolling.

View Slide

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,

View Slide

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
self.operationLabel.text = "Fetching image..."
})

View Slide

Not ideal...
},
RealAPI.fetchImage(for: user,
failureCompletion: { [weak self] error in
self.operationLabel.text = "Error fetching image: \(error)"
},
successCompletion: { [weak self] image in
self.operationLabel.text = "Resizing image..."
})
})

View Slide

...Does anyone have a ?
},
self.operationLabel.text = "Error fetching image: \(error)"
},
successCompletion: { [weak self] image in
self.operationLabel.text = "Resizing image..."
ImageResizer.resizeImage(image,
to: self.imageView.frame.size,
self.operationLabel.text = "Error resizing image: \(error)"
},
successCompletion: { [weak self] resizedImage in
self.imageView.image = resizedImage
self.operationLabel.text = "Complete in \(self.formattedSecondsSince(start))!"
})
})
})

View Slide

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

View Slide

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

View Slide

FakeAPI.fetchUser(failureCompletion: { error in
debugPrint("Error fetching user: \(error)")
},
successCompletion: { user in
failureCompletion: { error in
debugPrint("Error fetching image: \(error)")
},
successCompletion: { image in
debugPrint("Error resizing image: \(error)")
},
successCompletion: { resizedImage in
debugPrint("Complete in \(self.formattedSecondsSince(start))!"
})
})
})

View Slide

Think Indent Different

View Slide

FakeAPI.fetchUser(
errorCompletion: { error in
},
RealAPI.fetchImage(
for: user,
},
ImageResizer.resizeImage(
image,
},
})
})
})

View Slide

Try to break it
a p a r t

View Slide

private func fetchUser() {
FakeAPI.fetchUser(
},
self.fetchImage(for: user)
})
}
private func fetchImage(for user: User) {
RealAPI.fetchImage(
for: user,
},
self.resizeImage(image, to: self.imageView.frame.size)
})
}
private func resizeImage(_ image: UIImage, to size: CGSize) {
image,
},
debugPrint("Complete in \(self.formattedSecondsSince(start))!")
})
}

View Slide

The problem:
Dependent functions

View Slide

FakeAPI.fetchUser(
},
})
}
RealAPI.fetchImage(
for: user,
},
})
}
image,
},
})
}

View Slide

FakeAPI.fetchUser(
},
})
}
RealAPI.fetchImage(
for: user,
},
})
}
image,
},
})
}

View Slide

FakeAPI.fetchUser(
errorCompletion: { error in
},
RealAPI.fetchImage(
for: user,
},
image,
},
})
})
})

View Slide

A slight help:
The Result Type

View Slide

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

View Slide

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

View Slide

static func fetchUser(failureCompletion: @escaping (Error) -> Void,
successCompletion: @escaping (User) -> Void)
to size: CGSize,

View Slide

static func fetchUser(completion: @escaping (Result) -> Void)
completion: @escaping (Result) -> Void)
to size: CGSize,
failureCompletion: @escaping (Result) -> Void)

View Slide

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

View Slide

switch userResult {
}
}
}
}
}
}

View Slide

switch userResult {
image,
}
}
}
}
}
}

View Slide

switch userResult {
image,
}
}
}
}
}
}

View Slide

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

View Slide

in an easy-to-follow way?

View Slide

so we can ﬁgure out where something's
going wrong?

View Slide

! "
Bake-Off!

View Slide

Three competitors

View Slide

Three competitors
(out of way more than three)

View Slide

The Problem:
!
Callback Hell

View Slide

Three competitors

View Slide

Three competitors
1. Operator Overloading

View Slide

Three competitors
2. PromiseKit

View Slide

Three competitors
2. PromiseKit
3. RxSwift

View Slide

!
Signature Challenge:

View Slide

!
Signature Challenge:
Making Code More Readable

View Slide

Competitor #1:
Operator Overloading

View Slide

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

View Slide

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))
}
}
}
}

View Slide

switch result {
completion(result2)
}
}
}
}
}

View Slide

switch result {
completion(result2)
}
}
}
}
}

View Slide

PEMDAS

View Slide

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

View Slide

switch result {
completion(result2)
}
}
}
}
}

View Slide

switch result {
completion(result2)
}
}
}
}
}

View Slide

switch result {
completion(result2)
}
}
}
}
}

View Slide

switch result {
completion(result2)
}
}
}
}
}

View Slide

switch result {
completion(result2)
}
}
}
}
}

to size: CGSize,

to size: CGSize,

to size: CGSize,

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

View Slide

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

View Slide

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

View Slide

--> fetchUserImage
chain { result in
switch result {
}
}

View Slide

--> fetchUserImage
chain { result in
switch result {
}
}

View Slide

switch result {
completion(result2)
}
}
}
}
}

View Slide

switch result {
completion(result2)
}
}
}
}
}

View Slide

Pro: You Do It Yourself

View Slide

Con: You Do It Yourself

View Slide

Competitor #2:
PromiseKit

View Slide

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

View Slide

to size: CGSize,

View Slide

static func fetchUser() -> Promise
static func fetchImage(for user: User) -> Promise
to size: CGSize) -> Promise

View Slide

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

View Slide

FakeAPI.fetchUser()
.then { user in
}
.then { image in
}
.ensure {
}
}
}

View Slide

FakeAPI.fetchUser()
.then { user in
}
.then { image in
}
.ensure {
}
}
}

View Slide

FakeAPI.fetchUser()
.then { user in
}
.then { image in
}
.ensure {
}
}
}

View Slide

FakeAPI.fetchUser()
.then { user in
}
.then { image in
}
.ensure {
}
}
}

View Slide

FakeAPI.fetchUser()
.then { user in
}
.then { image in
}
.ensure {
}
}
}

View Slide

FakeAPI.fetchUser()
.then { user in
}
.then { image in
}
.ensure {
}
}
}

View Slide

Solution #3:
RxSwift

View Slide

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

View Slide

static func fetchUser() -> Promise
static func fetchImage(for user: User) -> Promise
to size: CGSize) -> Promise

View Slide

static func fetchUser() -> Single
static func fetchImage(for user: User) -> Single
to size: CGSize) -> Single

View Slide

Observable

View Slide

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

View Slide

Single

View Slide

Single
"This will either
succeed or fail once."

View Slide

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.operationLabel.text = "Complete (RxSwift) in \(self.formattedSecondsSince(start))!"
},
onError: { error in
self.operationLabel.text = "Error occurred (RxSwift): \(error)"
}
)
.disposed(by: bag)

View Slide

.flatMap { user in
}
.flatMap { image in
}
.subscribe(
},
onError: { error in
}
)
.disposed(by: bag)

View Slide

.flatMap { user in
}
.flatMap { image in
}
.subscribe(
},
onError: { error in
}
)
.disposed(by: bag)

View Slide

.flatMap { user in
}
.flatMap { image in
}
.subscribe(
},
onError: { error in
}
)
.disposed(by: bag)

View Slide

.flatMap { user in
}
.flatMap { image in
}
.subscribe(
},
onError: { error in
}
)
.disposed(by: bag)

View Slide

.flatMap { user in
}
.flatMap { image in
}
.subscribe(
},
onError: { error in
}
)
.disposed(by: bag)

View Slide

!
Technical Challenge:

View Slide

!
Technical Challenge:
Handling Threading

View Slide

completion: @escaping (Result) -> Void) {
API.fetchImage(for: user, completion: completion)
}

View Slide

DispatchQueue.global(qos: .background).async {
}
}

View Slide

}
}

View Slide

}
}

View Slide

PromiseKit
FakeAPI.fetchUser()
.then { user in
}
.then { image in
}
.ensure {
}
}
}

View Slide

PromiseKit
FakeAPI.fetchUser()
.then(on: .global(qos: .background)) { user in
}
.then(on: .global(qos: .background)) { image in
}
.ensure {
}
}
}

View Slide

PromiseKit
FakeAPI.fetchUser()
}
}
.ensure {
}
}
}

View Slide

PromiseKit
FakeAPI.fetchUser()
}
}
.ensure {
}
}
}

PromiseKit 6

PromiseKit 6

PromiseKit 6

PromiseKit 6

PromiseKit 6

PromiseKit 6

PromiseKit 6

PromiseKit
FakeAPI.fetchUser()
}
.map { image in
(image, self.imageView.frame.size)
}
.then(on: .global(qos: .background)) { tuple in
ImageResizer.resizeImage(tuple.0, to: tuple.1)
}
}
.ensure {
}
}
}

View Slide

PromiseKit
FakeAPI.fetchUser()
}
.map { image in
(image, self.imageView.frame.size)
}
.then(on: .global(qos: .background)) { tuple in
ImageResizer.resizeImage(tuple.0, to: tuple.1)
}
}
.ensure {
}
}
}

RxSwift:

RxSwift:
!
Scheduler

It's not a queue!

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

View Slide

observeOn:
tell me what happened here

View Slide

RxSwift
.flatMap { user in
}
.flatMap { image in
}
.subscribe(
},
onError: { error in
}
)
.disposed(by: bag)

View Slide

RxSwift
.flatMap { user in
}
.flatMap { image in
}
.observeOn(MainScheduler.instance)
.subscribe(
},
onError: { error in
}
)
.disposed(by: bag)

View Slide

RxSwift
.flatMap { user in
}
.flatMap { image in
}
.subscribe(
},
onError: { error in
}
)
.disposed(by: bag)

View Slide

subscribeOn:
actually do stuff here

View Slide

RxSwift
.flatMap { user in
}
.flatMap { image in
}
.subscribeOn(ConcurrentDispatchQueueScheduler(qos: .background))
.subscribe(
},
onError: { error in
}
)
.disposed(by: bag)

View Slide

Operator overloading:
Hard mode

View Slide

PromiseKit:
Perform on a queue you specify
Call back on a pre-deﬁned queue

View Slide

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

View Slide

!
Show-Stopper Challenge:

View Slide

!
Show-Stopper Challenge:
Multi-Function Concurrency

View Slide

Two functions at the same time
Do something with both results

View Slide

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

View Slide

.done { users in
}
.catch { error in
}

View Slide

.done { users in
}
.catch { error in
}

View Slide

when(fulfilled: userPromise1, userPromise2)
.done { user1, user2 in
debugPrint("User1: \(user1), User2: \(user2)")
}
.catch { error in
}

View Slide

when(fulfilled: userPromise1, userPromise2)
.done { user1, user2 in
debugPrint("User1: \(user1), User2: \(user2)")
}
.catch { error in
}

View Slide

PromiseKit: Different Types
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
}

View Slide

}
.catch { error in
}

View Slide

}
.catch { error in
}

RxSwift

Rx Marble Diagrams

RxSwift

RxSwift

RxSwift

RxSwift

RxSwift

JUST PICK ONE!

!
PromiseKit

!
PromiseKit
FOR ME

!
Killing ﬂies
with a sledgehammer

View Slide

Sometimes you
need
a sledgehammer

View Slide

Most of the time
you only need a
ﬂy swatter

View Slide

Obligatory Summary Slide

View Slide

→ Harder concurrency is it looks than.

View Slide

→ Concurrency is harder than it looks.

View Slide

→ You can try to handle it yourself, but it's going to
be a difﬁcult time sink.

View Slide

→ PromiseKit is great for most concurrency handling
and readability

View Slide

→ PromiseKit is great for most concurrency handling
and readability
→ RxSwift is a giant hammer...but sometimes you
need a giant hammer.

View Slide

Choose Wisely

View Slide

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

View Slide

!
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

View Slide

The Great iOS Concurrency Bake-Off - Swift Usergroup Netherlands, Amsterdam, February 2019

The Great iOS Concurrency Bake-Off - Swift Usergroup Netherlands, Amsterdam, February 2019

Ellen Shapiro
PRO

More Decks by Ellen Shapiro

Other Decks in Technology

Featured

Transcript

The Great iOS Concurrency Bake-Off - Swift Usergroup Netherlands, Amsterdam, February 2019

The Great iOS Concurrency Bake-Off - Swift Usergroup Netherlands, Amsterdam, February 2019

Ellen Shapiro PRO

More Decks by Ellen Shapiro

Other Decks in Technology

Featured

Transcript

Ellen Shapiro
PRO