Mobile Apps with React Native

1. Native apps vs the web

React Native lets you keep React's component model while rendering real native views — no HTML, no DOM, no browser. That single substitution changes what your components are, how styling works, which APIs exist, and how an app must behave to feel at home on iOS and Android. This lesson builds the platform model from the ground up: the bridge to native views, what you gain (device APIs, app store distribution, offline-first performance), what you give up (the browser's free services), and the rules that separate portable React code from platform-specific code.

2. Layouts & styling

Mobile layouts are read at arm's length, tapped with thumbs, displayed at densities from 2× to 4×, and often enlarged by a user who needs larger text. This lesson covers React Native's layout system in depth — flexbox with its column default, size units and why they are density-independent, safe areas and notches, `StyleSheet` patterns and array composition, dynamic type and accessible text, dark mode, and the testing routine that catches layout bugs before a reviewer does. Layout on mobile is a constraint problem, and the constraints are the design.

3. Navigation patterns

Navigation on mobile is not a set of links — it is a set of patterns users already know from every app they have installed: stacks that drill down and pop back, tabs for top-level areas, modals for focused tasks, and drawers where space demands them. This lesson covers React Navigation's stack, tab and modal navigators; parameters and how much data should travel in them; preserving and restoring state; deep links; the platform back-button and gesture contracts; and the accessibility that makes navigation work without sight or a touch screen. Get navigation right and the app feels native; get it wrong and no amount of visual polish recovers.

1. State & device storage

A mobile app that forgets everything between launches feels broken; one that stores everything carelessly leaks its users' data. This lesson covers the storage choices — what belongs in plain local storage, what belongs behind the device's secure enclave, what belongs on a server — and the engineering around them: JSON as an explicit boundary that can fail, hydration and the loading screen, migrations when your schema changes, sync and conflict strategy, and the privacy posture users and stores now require. Persist deliberately, restore gracefully, and never let a corrupt file stop an app from opening.

2. Gestures, feedback & polish

On a phone the interface is touched, not pointed at — and touch changes everything: targets must be sized for fingers, every press needs immediate visible acknowledgement, destructive actions need a safety net, gestures must never be the only way to do something, and motion must communicate rather than decorate. This lesson covers pressables and hit targets, the feedback ladder (visual, haptic, auditory), confirmation versus undo, the gesture library landscape, animation with the native driver, and the accessibility and reduce-motion contracts. Polish is not decoration; it is the app telling you it heard you.

3. Test & release

The distance between an app that runs on your simulator and an app strangers install with confidence is a discipline: test on real devices and hostile networks, handle every permission and failure path, prepare icons, screenshots and privacy declarations, manage versions and builds, and get through store review the first time. This lesson is that discipline as a checklist you can run — the boundary between building software and shipping it.