Assess Developer E

Not running, foreground/active, background, suspended/stopped, terminated. The OS can pause or kill the app at any time, so save state and release resources when going to the background, and restore when coming back.

The main thread draws the UI and handles touches. Blocking it freezes the app, and the OS may kill it (ANR on Android, watchdog on iOS). Do network, disk and heavy work in the background and update the UI back on the main thread.

Show loading, error and retry states; set timeouts; cache data locally so the app works offline; retry with backoff; queue writes and sync later; and handle a request finishing after the user has left the screen.

Beta testing (TestFlight / internal testing tracks), phased or staged rollout, crash and analytics monitoring, feature flags to switch features off remotely, and keep the backend compatible with old app versions — optionally a forced-update check for critical fixes.

A value that may be nil (String?). Unwrap with if let / guard let, optional chaining (a?.b), or ?? for a default. Avoid force unwrapping ! because it crashes on nil.

Structs are value types (copied on assignment, no inheritance); classes are reference types (shared instance, inheritance, deinit). Prefer structs for models; SwiftUI views are structs.

@State is simple local state owned by a view. @Binding gives a child read-write access to a parent’s state. @Observable (or ObservableObject with @StateObject/@ObservedObject) holds reference-type model state shared across views; the view owning it creates it once.

Use try await URLSession.shared.data(from:), decode with JSONDecoder into a Codable type, catch errors, and update UI state on the main actor (@MainActor). Start it from .task {} so it is cancelled when the view disappears.

Two objects hold strong references to each other, so neither is freed (memory leak). Common with closures capturing self. Break it with [weak self] (or unowned when the lifetime is guaranteed) and weak delegates.

Actors protect their mutable state so only one task touches it at a time, preventing data races. @MainActor guarantees code runs on the main thread, which UI updates require. The compiler enforces these rules (Sendable checking).

A signing certificate proves the developer’s identity; a provisioning profile ties the app ID, certificate, devices and capabilities (entitlements) together. Archive with a distribution profile, upload to App Store Connect, then distribute to testers via TestFlight after processing (and beta review for external testers).

Types are non-null by default; String? may be null. Use safe calls ?., the Elvis operator ?: for defaults, and let. !! throws if null and should be avoided.

The Activity is destroyed and recreated. Keep UI state in a ViewModel (survives configuration changes) and use SavedStateHandle / rememberSaveable for state that must survive process death.

When state read by a composable changes, Compose re-runs that composable to update the UI. Hoisting moves state up to the caller so composables are stateless, reusable and testable, with one source of truth (state down, events up).

The UI observes state from the ViewModel and sends it events; the ViewModel holds UI state (e.g. StateFlow) and logic, and survives configuration changes. The repository owns data access (network, Room database) and hides where data comes from.

Coroutines are started in a scope and are cancelled with it, so work never outlives its owner. viewModelScope cancels its coroutines when the ViewModel is cleared, preventing leaks and wasted work. Use Dispatchers.IO for blocking I/O.

A cold Flow starts producing for each collector when collected; a hot flow emits regardless of collectors. StateFlow always has a current value and replays the latest to new collectors (UI state). SharedFlow can have no value and configurable replay (one-off events).

Build an Android App Bundle (AAB) signed with the upload key (Play App Signing holds the app signing key), bump versionCode, upload to a testing track, then production. A staged rollout releases to a percentage of users first so crashes can be caught and the rollout halted.