rxSwift

Question 1

What is side effects?

Answer 1

Side effects are any change to the state outside of the current scope.

Question 2

What is Imperative programming?

Answer 2

Imperative programming is a programming paradigm that uses statements to change the program’s state.

Question 3

Core issues that rxSwift dealt with

Answer 3

Shared mutable data
The order in which pieces of work are performed

“RxSwift finds the sweet spot between traditionally imperative Cocoa code and purist functional code. It allows you to react to events by using immutable code definitions to process asynchronously pieces of input in a deterministic, composable way.”

Question 4

What is Subject in RxSwift

Answer 4

Observable and Observer

Publish/Behaviour/Replay

Replay:
To kill cache you have to call dispose
“buffer is held in memory.”

Question 5

What subject do after termination?

Answer 5

Every subject type, once terminated, will re-emit its stop event to future subscribers

Question 6

Creating observable factories

Answer 6

Observable.deferred { }

Question 7

Explain Observables

Answer 7

“Carry” an immutable piece of data Observable

Traits
Single
Maybe
Completable

Events
Next
Completed
Error

an observable won’t send events until it has a subscriber. Remember that an observable is really a sequence definition

Question 8

Filtering operators -> Ignoring operators

Answer 8

ignoreElements()
elementAt(1)
filter { $0 > 3 }

Question 9

Filtering operators -> skiping operators

Answer 9

skip(2)
skipWhile { $0 % 2 == 1}
skipUntil - hasTrigger

Question 10

Filtering operators -> taking operators

Answer 10

takeWhile { $0 < 3 }
take(2)
takeUntil - has trigger
elementAt(1)

Question 11

Filtering operators -> Distinct operators

Answer 11

DistinctUntilChanged {$0 $1}

Question 12

Filtering operators -> Transforming operators

Answer 12

toArray 
map -> can be .enumerated()
flatMap
flatMapLatest 
Materialize
Dematerialise

Question 13

Explain flatMap and flatMapLatest

Answer 13

Add async and project observable

Question 14

Combining operators

Answer 14

Combining operators
	Start with
	concat: sequential processing. concat
	concatMap
	merge: Just one event from observable that sends it event (can be many observables )
	cobineLatest: Combine events from observables and sends it together
	triggers
		withLatestFrom
		sample
	switches
		amb
		SwitchLatest
	reduce
	scan

Question 15

Timing operators

Answer 15

Timing operators
	Replaying past elements: You should call .connect() to start
		ReplayAll
		.replay(amount)
	Controlled buffering -> The only difference is that it emits an Observable of the buffered items, instead of emitting an array.
		.buffer(timeSpan:count:scheduler:)
	Windows of buffered observables
		.window(timeSpan:, count:, scheduler:)
	Time-shifting operators
		Delayed elements
		Delayed subscription
		Timer operators
			Intervals
			One-shot or repeating timers
			Timeouts

.take(5.0, scheduler: MainScheduler.instance)
.throttle(0.5, scheduler: MainScheduler.instance)

Question 16

Cold vs hot observables

Answer 16

“Note: In Rx, some observables are called “cold” while others are “hot”. Cold observables start emitting elements when you subscribe to them. Hot observables are more like permanent sources you happen to look at at some point (think of Notifications). When delaying a subscription, it won’t make a difference if the observable is cold. If it’s hot, you may skip elements, as in this example.
Hot and cold observables are a tricky topic that can take some time getting your head around. Remember that cold observables emit events only when subscribed to, but hot observables emit events independent of being subscribed to.”

Excerpt From: By Marin Todorov. “RxSwift - Reactive Programming with Swift”. Apple Books.

Question 17

Sharing

Answer 17

“To share a subscription, you can use the share() operator. A common pattern in Rx code is to create several sequences from the same source Observable by filtering out different elements in each of the results.”

share vs shareReplay