Architecture

The controller mediates between model and views — it owns the view lifecycle, wires outlets and actions, and formats data for display. It grows massive because MVC gives networking, persistence, and data-source code no home, so it all piles in.

The view model holds presentation state and logic — turning model data into display-ready values it exposes. It must never import UIKit or SwiftUI, so it stays framework-agnostic and testable. The view binds to it and re-renders when its published state changes.

An object receives its collaborators from outside instead of creating them. Constructor injection passes them into init, property injection sets them later, a container resolves them centrally. DI makes code testable because a test can swap in mocks for real dependencies.

A delegate fits a one-to-one contract where a callee reports back to one owner. A closure fits a short, local, one-shot callback. NotificationCenter fits one-to-many broadcast to unknown listeners. Combine or async fits streams of values and composable asynchronous work.

The observer pattern lets one subject notify many registered observers on a state change without knowing who they are. iOS uses it in NotificationCenter, KVO, and Combine. A delegate differs by being one-to-one — a single named callback — not a broadcast.

The coordinator owns navigation — it builds screens, injects dependencies, and picks what comes next, so view controllers no longer know each other. A child reports its result back through a delegate or closure, not by pushing directly. A deep link calls the same coordinator methods, driving the identical flow.

Extract in safe slices, not a rewrite. Move the data source and networking into their own types first — biggest, most testable, lowest-risk. Add characterization tests as you extract, point the controller at the new types, and ship after each step. A view model comes last.

GoF patterns name recurring object designs. On iOS singleton is URLSession.shared, factory a maker like UIButton(type:), adapter wraps a foreign API behind a protocol, facade is one entry over a subsystem, decorator adds behaviour by wrapping.

NotificationCenter posts synchronously on the poster's thread, so UI observers must hop to main, and block observers leak unless removed. KVO needs an @objc dynamic key path and can crash on double-removal. Combine cancels through a stored AnyCancellable.

Define a protocol the singleton conforms to and inject it through initializers. Migrate one type at a time, passing the shared instance at the call site so behaviour is unchanged. Keep .shared as a default argument during the switch; tests inject a fake, and drop .shared once the last caller moves over.

It breaks single-responsibility — four jobs in one type — and with it open/closed and dependency-inversion, since nothing varies alone. Split it into a fetcher, a cache, a decoder, and a view, each depending on the next through a small protocol, so any one can be swapped or tested alone.

For a large team, pick MVVM with coordinators: presentation logic is testable, most iOS engineers know it, and boilerplate is modest. MVC scales badly across teams; VIPER and TCA are more decoupled but cost onboarding and boilerplate. The trade-off is less structure than VIPER/TCA for speed and familiarity.

Layers run domain, presentation, then data. Dependencies point inward only — outer knows inner, never the reverse. The domain imports nothing framework-specific: no UIKit, no URLSession, no Core Data. It declares the repository protocols it needs, which the data layer implements at runtime.

Boundaries follow features, with shared foundation and domain modules beneath. Features depend only downward, never sideways — the package graph turns a sideways import into a compile error. When A needs B, it uses a protocol in a shared module that B implements, wired at composition time.