iOS Architecture: A State Container based approach

Transcript

1. iOS Architecture A State Container based approach The Movie
2. iOS Mobile Apps Architecture A State Container based approach The Movie
3. Luis Recuenco @luisrecuenco
7. 1. Motivation 2. Implementation 3. Problems
9. Motivation
10. What is bad architecture?
14. And what is good architecture?
18. What about software?
19. Three traits of good design
20. 1. Balanced distribution of responsibilities
21. 2. Testability
22. 3. Easy to use
24. Good code is the one that you can easily delete
25. Good code is the one that you can easily delete — Luis Recuenco
27. pod install
28. pod remove
29. Good code depends on context
30. Buildings vs Software
31. Good software is more subjective
32. Difficult to know that bad code is actually bad code
33. Simple vs Easy
34. Software changes a lot more
35. Greenfield
36. Brownfield
37. Most of us are in an industry of changing existing software
38. A good design is easier to change than a bad design — Dave Thomas
39. I'm here to talk about my book
40. I'm here to talk about my book blog post
43. Who actually read it?
44. This talk is like the movie
45. Books are better than the movie
46. Books and movies are like apples and oranges. They both are fruit, but taste completely different — Stephen King
47. Mobile Apps Architecture A state container based approach
48. The Movie
49. First things first We need a name
51. Luis ---------------------- Swift
52. Luis ------------ Swift
53. Luis ------ Swift
54. Luis - Swift
55. Lwift
57. Current state of architectures
59. It all started with MVC
61. View Controller has too many responsibilities
62. View Controller has too many responsibilities • View lifecycle • Business logic • Data transformation • Network requests • Delegate and data source for UI components • And so on and so forth...
63. Massive View Controller
64. Testing issues View Controller is tightly coupled to the view
65. MVP
67. Better testing Presenter is a view independent mediator
68. But we have to mock the view...
69. The assembly "problem"
70. let viewController = UIViewController() let presenter = Presenter(viewController, model) viewController.presenter = presenter
71. let viewController = UIViewController() let presenter = Presenter(viewController, model) viewController.presenter = presenter
72. MVVM
74. Better testing No view mocks
75. Better assembly let viewModel = ViewModel(model) let viewController = UIViewController(viewModel)
76. VIPER
78. Router
79. Too many pieces
80. Problems?
81. Broad concepts Not concrete enough
82. The problem about multiple, scattered, out-of-sync outputs
83. What's an output?
84. MVP Command from presenter to view
85. MVVM An observable property
86. class ProcessListViewModel { private(set) var loading: Bool private(set) var processes: [Process] private(set) var error: Error func fetchProcesses() { loading = true service.loadProcesses { processes, error in if error { self.error = error } else { self.processes = processes } } } }
87. class ProcessListViewModel { private(set) var loading: Bool private(set) var processes: [Process] private(set) var error: Error func fetchProcesses() { loading = true service.loadProcesses { processes, error in if error { self.error = error } else { self.processes = processes } } } }
88. class ProcessListViewModel { private(set) var loading: Bool private(set) var processes: [Process] private(set) var error: Error func fetchProcesses() { loading = true service.loadProcesses { processes, error in if error { self.error = error } else { self.processes = processes } } } }
89. class ProcessListViewModel { private(set) var loading: Bool private(set) var processes: [Process] private(set) var error: Error func fetchProcesses() { loading = true service.loadProcesses { processes, error in if error { self.error = error } else { self.processes = processes } } } }
90. Conflicting states
91. Invisible outputs
92. No traceability
93. Outputs consistency
94. View State
95. struct ProcessListViewState { let loading: Bool let processes: [ProcessViewState]? let error: Error? static func loading() -> ProcessListViewState { return ProcessListViewState(loading: true, processes: nil, error: nil) } static func loaded(with processes: [Process]) -> ProcessListViewState { return ProcessListViewState(loading: false, processes: processes, error: nil) } static func error(with error: Error) -> ProcessListViewState { return ProcessListViewState(loading: false, processes: nil, error: error) } }
96. struct ProcessListViewState { let loading: Bool let processes: [ProcessViewState]? let error: Error? static func loading() -> ProcessListViewState { return ProcessListViewState(loading: true, processes: nil, error: nil) } static func loaded(with processes: [Process]) -> ProcessListViewState { return ProcessListViewState(loading: false, processes: processes, error: nil) } static func error(with error: Error) -> ProcessListViewState { return ProcessListViewState(loading: false, processes: nil, error: error) } }
97. struct ProcessListViewState { let loading: Bool let processes: [ProcessViewState]? let error: Error? static func loading() -> ProcessListViewState { return ProcessListViewState(loading: true, processes: nil, error: nil) } static func loaded(with processes: [Process]) -> ProcessListViewState { return ProcessListViewState(loading: false, processes: processes, error: nil) } static func error(with error: Error) -> ProcessListViewState { return ProcessListViewState(loading: false, processes: nil, error: error) } }
98. class ProcessListViewModel { private(set) var state: ProcessListViewState { didSet { queue.sync { // Save new state and notify subscribers } } } func fetchProcesses() { state = ProcessListViewState.loading() service.loadProcesses { processes, error in if error { state = ProcessListViewState.error(with: error) } else { state = ProcessListViewState.loaded(with: process) } } } }
99. class ProcessListViewModel { private(set) var state: ProcessListViewState { didSet { queue.sync { // Save new state, log it, serialize it and notify subscribers } } } func fetchProcesses() { state = ProcessListViewState.loading() service.loadProcesses { processes, error in if error { state = ProcessListViewState.error(with: error) } else { state = ProcessListViewState.loaded(with: process) } } } }
100. class ProcessListViewModel { private(set) var state: ProcessListViewState { didSet { queue.sync { // Save new state, log it, serialize it and notify subscribers } } } func fetchProcesses() { state = ProcessListViewState.loading() service.loadProcesses { processes, error in if error { state = ProcessListViewState.error(with: error) } else { state = ProcessListViewState.loaded(with: process) } } } }
101. Deterministic view renders
102. The problem about exclusive states
103. class ProcessListViewController { init(viewModel: ProcessListViewModel) { viewModel.subscribe(from: self) } func render(state: ProcessListViewState) { if let error = state.error { ... } else if state.loading { ... } else if let processes = state.processes { ... } } }
104. class ProcessListViewController { init(viewModel: ProcessListViewModel) { viewModel.subscribe(from: self) } func render(state: ProcessListViewState) { if let error = state.error { ... } else if state.loading { ... } else if let processes = state.processes { ... } } }
105. Can our APIs convey proper usage?
106. Sum types
107. Product type
108. OR
109. enum PushNotification { case showPrivateInfo case showProcessDetail(Process.Identifier) case showChatConversation(Chat.Identifier, Candidate.Identifier) }
110. Null References
111. Null References The billion dollar mistake
112. enum Optional<Value> { case none case some(Value) }
113. Maybe monad
114. enum Result<Value, Error> { case failure(Error) case success(Value) }
115. Result monad
116. Pattern matching service.doNetworkRequest { result in switch result { case .failure(let error): handleError(with: error) case .success(let value): renderScreen(with: value) } }
117. enum ProcessListViewState { case loading case loaded([ProcessViewState]) case error(Error) } class ProcessListViewController { func render(state: ProcessListViewState) { switch state { case .loading: renderLoading() case .loaded(let processes): render(processes) case .error(let error): render(error) } } }
118. enum ProcessListViewState { case loading case loaded([ProcessViewState]) case error(Error) } class ProcessListViewController { func render(state: ProcessListViewState) { switch state { case .loading: renderLoading() case .loaded(let processes): render(processes) case .error(let error): render(error) } } }
119. UI as a State Machine
120. enum ProcessListViewState { case loading case loaded([ProcessViewState]) case error(Error) mutating func toLoading() { switch self { case .loading: fatalError("Wrong state transition") case .loaded, .idle, .error: self = .loading } } }
121. enum ProcessListViewState { case loading case loaded([ProcessViewState]) case error(Error) mutating func toLoading() { switch self { case .loading: fatalError("Wrong state transition") case .loaded, .idle, .error: self = .loading } } }
122. Exhaustive Switch statements
123. State is now buried in the view layer
124. View state vs domain state
125. App = UI(state)
126. UI(viewState(domainState))
127. Domain State
128. Single source of truth
129. The value of values
130. COW semantics
131. ==
132. ===
133. 90% of our actors are reference objects
134. 90% of live instances are values
135. Move business logic to the value layer
136. Better testing
137. Queries Derived state
138. Decouple views from state shape specifics
139. To cache or not to cache
140. Staleness vs efficiency bugs
141. Commands Mutate state
142. New truth
143. lenses
144. mutating
145. mutating composition
146. Whole tree is rebuilt
147. Performance issues
148. Persistent Data Structures
151. Tries
152. Structural sharing
153. State enum ProcessStoreState { case idle case loading case loaded([Process]) case error(Error) }
154. Queries extension ProcessStoreState { var processes: [Process]? { switch self { case .idle, .loading, .error: return nil case .loaded(let processes): return processes } } var error: Error? { switch self { case .idle, .loaded, .loading: return nil case .error(let error): return error } } }
155. Commands extension ProcessStoreState { mutating func enterProcess(id: String) { // create modifiedProcesses... self = .loaded(modifiedProcesses) } mutating func toLoading() { // Check correct state transition if needed self = .loading } }
156. Only one missing piece...
157. Stores Domain State Containers
158. Store<DomainState>
159. Responsible for side effects
160. View State Pure function of domain state
161. enum ProcessListViewState { case loading case loaded([ProcessViewState]) case error(Error) init(domainState: ProcessStoreState) { switch domainState { case .idle, .loading: self = .loading case .loaded(let processes): self = .loaded(processes.map { ... }) case .error: self = .error(error.map { ... }) } } }
162. class ProcessListViewModel { private let store: ProcessStore private(set) var state: ProcessListViewState { didSet { print("New state: \(viewState)") } } init(store: ProcessStore) { self.store = store subscribe(to: store) { newDomainState in state = ProcessListViewState(domainState: newDomainState) } } func fetchProcesses() { store.fetchProcesses() } }
166. Implementation
167. It's just observing a state property That's all, really
168. NSNotificationCenter
169. Unsafely typed
170. Implicit dependency
171. keypath observers
172. token = store.observe(\.state) { ... }
173. strongly typed
174. Problems
175. @objc dynamic
176. Forgetting about dynamic
177. State must be represented in Objc
178. State must be represented in Objc No generics, enums, structs or sum types
179. Custom strongly typed pub sub implementation
180. protocol StoreState: Equatable {} protocol ViewState: StoreState {}
181. class Store<State: StoreState> { init(initialState: State) { state = initialState } ... }
182. class Store<State: StoreState> { ... private lazy var stateTransactionQueue = DispatchQueue(label: "com.jobandtalent.\(type(of: self)).StateTransactionQueue") var state: State { didSet(oldState) { if #available(iOS 10.0, *) { dispatchPrecondition(condition: .onQueue(stateTransactionQueue)) } stateDidChange(oldState: oldState, newState: state) } } ... }
183. class Store<State: StoreState> { ... private lazy var stateTransactionQueue = DispatchQueue(label: "com.jobandtalent.\(type(of: self)).StateTransactionQueue") var state: State { didSet(oldState) { if #available(iOS 10.0, *) { dispatchPrecondition(condition: .onQueue(stateTransactionQueue)) } stateDidChange(oldState: oldState, newState: state) } } ... }
184. class Store<State: StoreState> { ... private lazy var stateTransactionQueue = DispatchQueue(label: "com.jobandtalent.\(type(of: self)).StateTransactionQueue") var state: State { didSet(oldState) { if #available(iOS 10.0, *) { dispatchPrecondition(condition: .onQueue(stateTransactionQueue)) } stateDidChange(oldState: oldState, newState: state) } } ... }
185. class Store<State: StoreState> { ... func stateDidChange(oldState: State, newState: State) { guard oldState != newState else { print("Skip forwarding same state: \(newState)") return } print("State change: \(newState)") subscriptions.allObjects.forEach { $0.fire(state) } } }
186. class Store<State: StoreState> { ... func stateDidChange(oldState: State, newState: State) { guard oldState != newState else { print("Skip forwarding same state: \(newState)") return } print("State change: \(newState)") subscriptions.allObjects.forEach { $0.fire(state) } } }
187. class Store<State: StoreState> { ... func stateDidChange(oldState: State, newState: State) { guard oldState != newState else { print("Skip forwarding same state: \(newState)") return } print("State change: \(newState)") subscriptions.allObjects.forEach { $0.fire(state) } } }
188. class Store<State: StoreState> { ... func stateDidChange(oldState: State, newState: State) { guard oldState != newState else { print("Skip forwarding same state: \(newState)") return } print("State change: \(newState)") subscriptions.allObjects.forEach { $0.fire(state) } } }
189. class StateSubscription<State: StoreState> { private(set) var block: ((State) -> Void)? func fire(_ state: State) { block?(state) } func stop() { block = nil } deinit { stop() } }
190. class StateSubscription<State: StoreState> { private(set) var block: ((State) -> Void)? func fire(_ state: State) { block?(state) } func stop() { block = nil } deinit { stop() } }
191. class StateSubscription<State: StoreState> { private(set) var block: ((State) -> Void)? func fire(_ state: State) { block?(state) } func stop() { block = nil } deinit { stop() } }
192. class Store<State: StoreState> { private var subscriptions = NSHashTable<StateSubscription<State>>.weakObjects() func subscribe(_ block: @escaping (State) -> Void) -> StateSubscription<State> { let subscription = StateSubscription(block) subscriptions.add(subscription) subscription.fire(state) return subscription } }
193. class Store<State: StoreState> { private var subscriptions = NSHashTable<StateSubscription<State>>.weakObjects() func subscribe(_ block: @escaping (State) -> Void) -> StateSubscription<State> { let subscription = StateSubscription(block) subscriptions.add(subscription) subscription.fire(state) return subscription } }
194. class Store<State: StoreState> { private var subscriptions = NSHashTable<StateSubscription<State>>.weakObjects() func subscribe(_ block: @escaping (State) -> Void) -> StateSubscription<State> { let subscription = StateSubscription(block) subscriptions.add(subscription) subscription.fire(state) return subscription } }
195. class Store<State: StoreState> { private var subscriptions = NSHashTable<StateSubscription<State>>.weakObjects() func subscribe(_ block: @escaping (State) -> Void) -> StateSubscription<State> { let subscription = StateSubscription(block) subscriptions.add(subscription) subscription.fire(state) return subscription } }
196. class Store<State: StoreState> { private var subscriptions = NSHashTable<StateSubscription<State>>.weakObjects() func subscribe(_ block: @escaping (State) -> Void) -> StateSubscription<State> { let subscription = StateSubscription(block) subscriptions.add(subscription) subscription.fire(state) return subscription } }
197. class Store<State: StoreState> { private var subscriptions = NSHashTable<StateSubscription<State>>.weakObjects() func subscribe(_ block: @escaping (State) -> Void) -> StateSubscription<State> { let subscription = StateSubscription(block) subscriptions.add(subscription) subscription.fire(state) return subscription } }
198. RAII
199. protocol StatefulView { associatedtype State: ViewState func render(state: State) var renderPolicy: RenderPolicy { get } }
200. protocol StatefulView { associatedtype State: ViewState func render(state: State) var renderPolicy: RenderPolicy { get } }
201. protocol StatefulView { associatedtype State: ViewState func render(state: State) var renderPolicy: RenderPolicy { get } }
202. protocol StatefulView { associatedtype State: ViewState func render(state: State) var renderPolicy: RenderPolicy { get } }
203. enum RenderPolicy { case possible case notPossible(RenderError) enum RenderError { case viewNotReady case viewDeallocated }
204. type erasure
205. protocol StatefulView { func render() }
206. How to access state?
207. View needs to maintain view model
208. Not always the case
209. class ViewModel<State: ViewState>: Store<State> { private var views = Set<AnyStatefulView<State>>() override var state: State { didSet(oldState) { views.forEach { stateDidChange(oldState: oldState, newState: state, view: $0) } } } }
210. class ViewModel<State: ViewState>: Store<State> { private var views = Set<AnyStatefulView<State>>() override var state: State { didSet(oldState) { views.forEach { stateDidChange(oldState: oldState, newState: state, view: $0) } } } }
211. class ViewModel<State: ViewState>: Store<State> { private func stateDidChange(oldState: State, newState: State, view: AnyStatefulView<State>) { switch view.renderPolicy { case .possible: if newState == oldState { return } DispatchQueue.main.async { view.render(state: newState) } case .notPossible(let renderError): // Handle error } } }
212. class ViewModel<State: ViewState>: Store<State> { private func stateDidChange(oldState: State, newState: State, view: AnyStatefulView<State>) { switch view.renderPolicy { case .possible: if newState == oldState { return } DispatchQueue.main.async { view.render(state: newState) } case .notPossible(let renderError): // Handle error } } }
213. class ViewModel<State: ViewState>: Store<State> { private func stateDidChange(oldState: State, newState: State, view: AnyStatefulView<State>) { switch view.renderPolicy { case .possible: if newState == oldState { return } DispatchQueue.main.async { view.render(state: newState) } case .notPossible(let renderError): // Handle error } } }
214. class ViewModel<State: ViewState>: Store<State> { private func stateDidChange(oldState: State, newState: State, view: AnyStatefulView<State>) { switch view.renderPolicy { case .possible: if newState == oldState { return } DispatchQueue.main.async { view.render(state: newState) } case .notPossible(let renderError): // Handle error } } }
215. class ViewModel<State: ViewState>: Store<State> { private func stateDidChange(oldState: State, newState: State, view: AnyStatefulView<State>) { switch view.renderPolicy { case .possible: if newState == oldState { return } DispatchQueue.main.async { view.render(state: newState) } case .notPossible(let renderError): // Handle error } } }
216. class ViewModel<State: ViewState>: Store<State> { private func stateDidChange(oldState: State, newState: State, view: AnyStatefulView<State>) { switch view.renderPolicy { case .possible: if newState == oldState { return } DispatchQueue.main.async { view.render(state: newState) } case .notPossible(let renderError): // Handle error } } }
218. Problems
219. Problems • Not being able to subscribe to specific parts of the state.
220. Problems • Not being able to subscribe to specific parts of the state. • Not persistent data structures.
221. Problems • Not being able to subscribe to specific parts of the state. • Not persistent data structures. • No guarantee only subclasses can change the state (no protected modifier in swift).
222. Problems • Not being able to subscribe to specific parts of the state. • Not persistent data structures. • No guarantee only subclasses can change the state (no protected modifier in swift). • Mutating can be cumbersome with big trees -> leverage composition.
223. Problems • Not being able to subscribe to specific parts of the state. • Not persistent data structures. • No guarantee only subclasses can change the state (no protected modifier in swift). • Mutating can be cumbersome with sum types -> leverage composition. • Stores interdependencies can lead to infinite loops.
224. State vs Events
225. Navigation and alerts
226. Listen to the code
227. The problem about stopping thinking
228. Gratitude
230. Thanks